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;
}
public TypeClassInfo createBasicClassInfo(Class typeClass) {
TypeClassInfo info = new TypeClassInfo();
info.setDescription("class '" + typeClass.getName() + '\'');
info.setTypeClass(typeClass);
return info;
}
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);
}
/**
* Create a AegisType for a Method parameter.
*
* @param m the method to create a type for
* @param index The parameter index. If the index is less than zero, the return type is used.
*/
public AegisType createType(Method m, int index) {
TypeClassInfo info = createClassInfo(m, index);
info.setDescription(
(index == -1 ? "return type" : "parameter " + index)
+ " of method "
+ m.getName()
+ " in "
+ m.getDeclaringClass());
return createTypeForClass(info);
}
public TypeClassInfo createBasicClassInfo(Type type) {
TypeClassInfo info = new TypeClassInfo();
Class<?> typeClass = TypeUtil.getTypeClass(type, false);
if (typeClass != null) {
info.setDescription("class '" + typeClass.getName() + "'");
} else {
info.setDescription("type '" + type + "'");
}
info.setType(type);
return info;
}
protected Type createHolderType(TypeClassInfo info) {
if (info.getGenericType() == null) {
throw new UnsupportedOperationException(
"To use holder types " + "you must have an XML descriptor declaring the component type.");
}
Class heldCls = (Class) info.getGenericType();
info.setTypeClass(heldCls);
Type delegate = createType(heldCls);
HolderType type = new HolderType(delegate);
return type;
}
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 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;
}
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 QName createCollectionQName(TypeClassInfo info, AegisType type) {
String ns;
if (type.isComplex()) {
ns = type.getSchemaType().getNamespaceURI();
} else {
ns = tm.getMappingIdentifierURI();
}
if (WSDLConstants.NS_SCHEMA_XSD.equals(ns)) {
ns = HTTP_CXF_APACHE_ORG_ARRAYS;
}
String first = type.getSchemaType().getLocalPart().substring(0, 1);
String last = type.getSchemaType().getLocalPart().substring(1);
String localName = "ArrayOf" + first.toUpperCase() + last;
if (info.nonDefaultAttributes()) {
localName += "-";
if (info.getMinOccurs() >= 0) {
localName += info.getMinOccurs();
}
localName += "-";
if (info.getMaxOccurs() >= 0) {
localName += info.getMaxOccurs();
}
if (info.isFlat()) {
localName += "Flat";
}
}
return new QName(ns, localName);
}
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);
}
}
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 Type createArrayType(TypeClassInfo info) {
ArrayType type = new ArrayType();
type.setTypeMapping(getTypeMapping());
type.setTypeClass(info.getTypeClass());
type.setSchemaType(createCollectionQName(info, type.getComponentType()));
if (info.getMinOccurs() != -1) type.setMinOccurs(info.getMinOccurs());
if (info.getMaxOccurs() != -1) type.setMaxOccurs(info.getMaxOccurs());
type.setFlat(info.isFlat());
return type;
}
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;
}
public TypeClassInfo createClassInfo(Field f) {
TypeClassInfo info = createBasicClassInfo(f.getType());
info.setDescription("field " + f.getName() + " in " + f.getDeclaringClass());
return info;
}
public AegisType createType(Class<?> clazz) {
TypeClassInfo info = createBasicClassInfo(clazz);
info.setDescription(clazz.toString());
return createTypeForClass(info);
}
/**
* Create an Aegis type from a reflected type description. This will only work for the restricted
* set of collection types supported by Aegis.
*
* @param t the reflected type.
* @return the type
*/
public AegisType createType(Type t) {
TypeClassInfo info = new TypeClassInfo();
info.setType(t);
info.setDescription("reflected type " + t.toString());
return createTypeForClass(info);
}
/**
* Create type information for a <code>Field</code>.
*
* @param f the field to create a type from
*/
public AegisType createType(Field f) {
TypeClassInfo info = createClassInfo(f);
info.setDescription("field " + f.getName() + " in " + f.getDeclaringClass());
return createTypeForClass(info);
}
/**
* Create type information for a PropertyDescriptor.
*
* @param pd the propertydescriptor
*/
public AegisType createType(PropertyDescriptor pd) {
TypeClassInfo info = createClassInfo(pd);
info.setDescription("property " + pd.getName());
return createTypeForClass(info);
}
public QName getElementName(Method m, int index) {
TypeClassInfo info = createClassInfo(m, index);
return info.getMappedName();
}
