public AnyTypeImpl(Navigator<T,C,?,?> nav) { this.type = nav.ref(Object.class); this.nav = nav; }
public TypeInfoSetImpl(Navigator<T,C,F,M> nav, AnnotationReader<T,C,F,M> reader, Map<T,? extends BuiltinLeafInfoImpl<T,C>> leaves) { this.nav = nav; this.reader = reader; this.builtins.putAll(leaves); this.anyType = createAnyType(); // register primitive types. for (Map.Entry<Class, Class> e : RuntimeUtil.primitiveToBox.entrySet()) { this.builtins.put( nav.getPrimitive(e.getKey()), leaves.get(nav.ref(e.getValue())) ); } // make sure at lease we got a map for global ones. elementMappings.put(null,new LinkedHashMap<QName,ElementInfoImpl<T,C,F,M>>()); }
/** * Creates all the {@link BuiltinLeafInfoImpl}s as specified in the spec. * * {@link LeafInfo}s are all defined by the spec. */ public static <TypeT,ClassDeclT> Map<TypeT,BuiltinLeafInfoImpl<TypeT,ClassDeclT>> createLeaves( Navigator<TypeT,ClassDeclT,?,?> nav ) { Map<TypeT,BuiltinLeafInfoImpl<TypeT,ClassDeclT>> leaves = new HashMap<TypeT,BuiltinLeafInfoImpl<TypeT,ClassDeclT>>(); for( RuntimeBuiltinLeafInfoImpl<?> leaf : RuntimeBuiltinLeafInfoImpl.builtinBeanInfos ) { TypeT t = nav.ref(leaf.getClazz()); leaves.put( t, new BuiltinLeafInfoImpl<TypeT,ClassDeclT>(t,leaf.getTypeNames()) ); } return leaves; } }
/** * Adds an additional element declaration. * * @param tagName * The name of the element declaration to be added. * @param type * The type this element refers to. * Can be null, in which case the element refers to an empty anonymous complex type. */ public void add( QName tagName, boolean isNillable, NonElement<T,C> type ) { if(type!=null && type.getType()==navigator.ref(CompositeStructure.class)) return; // this is a special class we introduced for JAX-WS that we *don't* want in the schema Namespace n = getNamespace(tagName.getNamespaceURI()); n.elementDecls.put(tagName.getLocalPart(), n.new ElementWithType(isNillable,type)); // search for foreign namespace references if(type!=null) n.addDependencyTo(type.getTypeName()); }
public Adapter(ClassDeclT adapterType,Navigator<TypeT,ClassDeclT,?,?> nav) { this.adapterType = adapterType; TypeT baseClass = nav.getBaseClass(nav.use(adapterType), nav.asDecl(XmlAdapter.class)); // because the parameterization of XmlJavaTypeAdapter requires that the class derives from XmlAdapter. assert baseClass!=null; if(nav.isParameterizedType(baseClass)) defaultType = nav.getTypeArgument(baseClass,0); else defaultType = nav.ref(Object.class); if(nav.isParameterizedType(baseClass)) customType = nav.getTypeArgument(baseClass,1); else customType = nav.ref(Object.class); } }
public XmlSchemaGenerator( Navigator<T,C,F,M> navigator, TypeInfoSet<T,C,F,M> types ) { this.navigator = navigator; this.types = types; this.stringType = types.getTypeInfo(navigator.ref(String.class)); this.anyType = types.getAnyTypeInfo(); // populate the object for( ClassInfo<T,C> ci : types.beans().values() ) add(ci); for( ElementInfo<T,C> ei1 : types.getElementMappings(null).values() ) add(ei1); for( EnumLeafInfo<T,C> ei : types.enums().values() ) add(ei); for( ArrayInfo<T,C> a : types.arrays().values()) add(a); }
/** * @param clazz * @param type * clazz and type should both point to the enum class * that this {@link EnumLeafInfo} represents. * Because of the type parameterization we have to take them separately. */ public EnumLeafInfoImpl(ModelBuilder<T,C,F,M> builder, Locatable upstream, C clazz, T type ) { super(builder,upstream); this.clazz = clazz; this.type = type; elementName = parseElementName(clazz); // compute the type name // TODO: I guess it must be allowed for enums to have @XmlElement typeName = parseTypeName(clazz); // locate the base type. // this can be done eagerly because there shouldn't be no cycle. XmlEnum xe = builder.reader.getClassAnnotation(XmlEnum.class, clazz, this); if(xe!=null) { T base = builder.reader.getClassValue(xe, "value"); baseType = builder.getTypeInfo(base,this); } else { baseType = builder.getTypeInfo(builder.nav.ref(String.class),this); } }
public AnyTypeImpl(Navigator<T,C,?,?> nav) { this.type = nav.ref(Object.class); this.nav = nav; }
private ID calcId() { if(seed.hasAnnotation(XmlID.class)) { // check the type if(!nav().isSameType(getIndividualType(), nav().ref(String.class))) parent.builder.reportError(new IllegalAnnotationException( Messages.ID_MUST_BE_STRING.format(getName()), seed ) ); return ID.ID; } else if(seed.hasAnnotation(XmlIDREF.class)) { return ID.IDREF; } else { return ID.NONE; } }
if (nav().isSameType(type, nav().ref(XmlElement.DEFAULT.class))) type = getIndividualType(); if((!nav().isPrimitive(type) || isCollection()) && !item.required())
if (nav().isSameType(nav().getFieldType(f), nav().ref(String.class))) { XmlSchemaType schemaTypeAnnotation = builder.reader.getFieldAnnotation(XmlSchemaType.class, f, this); if (schemaTypeAnnotation != null) {
public MapPropertyInfoImpl(ClassInfoImpl<T,C,F,M> ci, PropertySeed<T,C,F,M> seed) { super(ci, seed); XmlElementWrapper xe = seed.readAnnotation(XmlElementWrapper.class); xmlName = calcXmlName(xe); nil = xe!=null && xe.nillable(); T raw = getRawType(); T bt = nav().getBaseClass(raw, nav().asDecl(Map.class) ); assert bt!=null; // Map property is only for Maps if(nav().isParameterizedType(bt)) { keyType = nav().getTypeArgument(bt,0); valueType = nav().getTypeArgument(bt,1); } else { keyType = valueType = nav().ref(Object.class); } }
public T getIndividualType() { if(adapter!=null) return adapter.defaultType; T raw = getRawType(); if(!isCollection()) { return raw; } else { if(nav().isArrayButNotByteArray(raw)) return nav().getComponentType(raw); T bt = nav().getBaseClass(raw, nav().asDecl(Collection.class) ); if(nav().isParameterizedType(bt)) return nav().getTypeArgument(bt,0); else return nav().ref(Object.class); } }
if(nav().isSubClassOf( seed.getRawType(), nav().ref(Map.class) ) && !seed.hasAnnotation(XmlJavaTypeAdapter.class)) group = PropertyGroup.MAP; group = PropertyGroup.ELEMENT; } else if (group.equals(PropertyGroup.ELEMENT)) { // see issue 791 - make sure @XmlElement annotated map property is mapped to map if (nav().isSubClassOf( seed.getRawType(), nav().ref(Map.class)) && !seed.hasAnnotation(XmlJavaTypeAdapter.class)) { group = PropertyGroup.MAP; if(!nav().isSubClassOf(seed.getRawType(),nav().ref(Map.class))) { builder.reportError(new IllegalAnnotationException( Messages.INVALID_ATTRIBUTE_WILDCARD_TYPE.format(nav().getTypeName(seed.getRawType())),
T fClass = reader().getClassValue(t, "factoryClass"); if (method.length() > 0){ if(nav().isSameType(fClass, nav().ref(XmlType.DEFAULT.class))){ fClass = nav().use(clazz); Messages.NO_FACTORY_METHOD.format(nav().getClassName(nav().asDecl(fClass)), method), this )); } else if(!nav().isSameType(fClass, nav().ref(XmlType.DEFAULT.class))){ builder.reportError(new IllegalAnnotationException( Messages.FACTORY_CLASS_NEEDS_FACTORY_METHOD.format(nav().getClassName(nav().asDecl(fClass))), this ));
AnnotationReader<T,C,F,M> reader = reader(); final T defaultType = nav.ref(XmlElementRef.DEFAULT.class); final C je = nav.asDecl(JAXBElement.class); if(nav().isSameType(type, nav.ref(JAXBElement.class))) { AnnotationReader<T,C,F,M> reader = reader(); final T defaultType = nav.ref(XmlElementRef.DEFAULT.class); final C je = nav.asDecl(JAXBElement.class); if(nav().isSameType(type, nav.ref(JAXBElement.class))) {
public TypeInfoSetImpl(Navigator<T,C,F,M> nav, AnnotationReader<T,C,F,M> reader, Map<T,? extends BuiltinLeafInfoImpl<T,C>> leaves) { this.nav = nav; this.reader = reader; this.builtins.putAll(leaves); this.anyType = createAnyType(); // register primitive types. for (Map.Entry<Class, Class> e : RuntimeUtil.primitiveToBox.entrySet()) { this.builtins.put( nav.getPrimitive(e.getKey()), leaves.get(nav.ref(e.getValue())) ); } // make sure at lease we got a map for global ones. elementMappings.put(null,new LinkedHashMap<QName,ElementInfoImpl<T,C,F,M>>()); }
this.isCollection = nav().isSubClassOf(t, nav().ref(Collection.class)) || nav().isArrayButNotByteArray(t);
public Adapter(ClassDeclT adapterType,Navigator<TypeT,ClassDeclT,?,?> nav) { this.adapterType = adapterType; TypeT baseClass = nav.getBaseClass(nav.use(adapterType), nav.asDecl(XmlAdapter.class)); // because the parameterization of XmlJavaTypeAdapter requires that the class derives from XmlAdapter. assert baseClass!=null; if(nav.isParameterizedType(baseClass)) defaultType = nav.getTypeArgument(baseClass,0); else defaultType = nav.ref(Object.class); if(nav.isParameterizedType(baseClass)) customType = nav.getTypeArgument(baseClass,1); else customType = nav.ref(Object.class); } }
if(nav().isSameType(s, nav().ref(XmlElementDecl.GLOBAL.class))) scope = null; else {