protected AegisType createUserType(TypeClassInfo info) {
try {
AegisType type = info.getAegisTypeClass().newInstance();
QName name = info.getTypeName();
if (name == null) {
// We do not want to use the java.lang.whatever schema type.
// If the @ annotation or XML file didn't specify a schema type,
// but the natural type has a schema type mapping, we use that rather
// than create nonsense.
Class<?> typeClass = TypeUtil.getTypeRelatedClass(info.getType());
if (typeClass.getPackage().getName().startsWith("java")) {
name = tm.getTypeQName(typeClass);
}
// if it's still null, we'll take our lumps, but probably end up with
// an invalid schema.
if (name == null) {
name = createQName(typeClass);
}
}
type.setSchemaType(name);
type.setTypeClass(info.getType());
type.setTypeMapping(getTypeMapping());
return type;
} catch (InstantiationException e) {
throw new DatabindingException(
"Couldn't instantiate type classs " + info.getAegisTypeClass().getName(), e);
} catch (IllegalAccessException e) {
throw new DatabindingException(
"Couldn't access type classs " + info.getAegisTypeClass().getName(), e);
}
}
protected AegisType createHolderType(TypeClassInfo info) {
Type heldType = TypeUtil.getSingleTypeParameter(info.getType(), 0);
if (heldType == null) {
throw new UnsupportedOperationException("Invalid holder type " + info.getType());
}
info.setType(heldType);
return createType(heldType);
}
public AegisType createTypeForClass(TypeClassInfo info) {
Class<?> javaClass = TypeUtil.getTypeRelatedClass(info.getType());
AegisType result = null;
boolean newType = true;
if (info.getType() instanceof TypeVariable) {
// it's the generic type
result = getOrCreateGenericType(info);
} else if (info.getAegisTypeClass() != null) {
result = createUserType(info);
} else if (isArray(javaClass)) {
result = createArrayType(info);
} else if (isMap(javaClass)) {
result = createMapType(info);
} else if (isHolder(javaClass)) {
result = createHolderType(info);
} else if (isCollection(javaClass)) {
result = createCollectionType(info);
} else if (isEnum(javaClass)) {
result = createEnumType(info);
} else if (javaClass.equals(byte[].class)) {
result = getTypeMapping().getType(javaClass);
} else {
AegisType type = getTypeMapping().getType(info.getType());
if (type == null
|| (info.getTypeName() != null && !type.getSchemaType().equals(info.getTypeName()))) {
if (info.getTypeName() != null) {
type = getTypeMapping().getType(info.getTypeName());
}
if (type == null) {
type = getTypeMapping().getType(javaClass);
}
if (type == null) {
type = createDefaultType(info);
} else {
newType = false;
}
} else {
newType = false;
}
result = type;
}
if (newType && !getConfiguration().isDefaultNillable()) {
result.setNillable(false);
}
return result;
}
protected AegisType createCollectionTypeFromGeneric(TypeClassInfo info) {
AegisType component = getOrCreateGenericType(info);
CollectionType type = new CollectionType(component);
type.setTypeMapping(getTypeMapping());
QName name = info.getTypeName();
if (name == null) {
name = createCollectionQName(info, component);
}
type.setSchemaType(name);
type.setTypeClass(info.getType());
if (info.getMinOccurs() != -1) {
type.setMinOccurs(info.getMinOccurs());
}
if (info.getMaxOccurs() != -1) {
type.setMaxOccurs(info.getMaxOccurs());
}
type.setFlat(info.isFlat());
return type;
}
public Type createTypeForClass(TypeClassInfo info) {
Class javaType = info.getTypeClass();
Type result = null;
boolean newType = true;
if (info.getType() != null) {
result = createUserType(info);
} else if (isHolder(javaType)) {
result = createHolderType(info);
} else if (isArray(javaType)) {
result = createArrayType(info);
} else if (isMap(javaType)) {
result = createMapType(info);
} else if (isCollection(javaType)) {
result = createCollectionType(info);
} else if (isEnum(javaType)) {
result = createEnumType(info);
} else {
Type type = getTypeMapping().getType(javaType);
if (type == null) {
type = createDefaultType(info);
} else {
newType = false;
}
result = type;
}
if (newType && !getConfiguration().isDefaultNillable()) result.setNillable(false);
return result;
}
protected AegisType createMapType(TypeClassInfo info, AegisType keyType, AegisType valueType) {
QName schemaType = createMapQName(info, keyType, valueType);
MapType type = new MapType(schemaType, keyType, valueType);
type.setTypeMapping(getTypeMapping());
type.setTypeClass(info.getType());
return type;
}
protected QName createMapQName(TypeClassInfo info, AegisType keyType, AegisType valueType) {
String name =
keyType.getSchemaType().getLocalPart() + '2' + valueType.getSchemaType().getLocalPart();
Class<?> cls = TypeUtil.getTypeRelatedClass(info.getType());
name += cls.getSimpleName();
// TODO: Get namespace from XML?
return new QName(tm.getMappingIdentifierURI(), name);
}
protected Type createUserType(TypeClassInfo info) {
try {
Type type = (Type) info.getType().newInstance();
QName name = info.getTypeName();
if (name == null) name = createQName(info.getTypeClass());
type.setSchemaType(name);
type.setTypeClass(info.getTypeClass());
type.setTypeMapping(getTypeMapping());
return type;
} catch (InstantiationException e) {
throw new XFireRuntimeException(
"Couldn't instantiate type classs " + info.getType().getName(), e);
} catch (IllegalAccessException e) {
throw new XFireRuntimeException("Couldn't access type classs " + info.getType().getName(), e);
}
}
protected AegisType createArrayType(TypeClassInfo info) {
ArrayType type = new ArrayType();
type.setTypeMapping(getTypeMapping());
type.setTypeClass(info.getType());
type.setSchemaType(createCollectionQName(info, type.getComponentType()));
if (info.getMinOccurs() != -1) {
type.setMinOccurs(info.getMinOccurs());
} else {
type.setMinOccurs(typeConfiguration.getDefaultMinOccurs());
}
if (info.getMaxOccurs() != -1) {
type.setMaxOccurs(info.getMaxOccurs());
}
type.setFlat(info.isFlat());
return type;
}
