T fClass = reader().getClassValue(t, "factoryClass"); if (method.length() > 0){ if(nav().isSameType(fClass, nav().ref(XmlType.DEFAULT.class))){ fClass = nav().use(clazz); for(M m: nav().getDeclaredMethods(nav().asDecl(fClass))){ if (nav().getMethodName(m).equals(method) && nav().isSameType(nav().getReturnType(m), nav().use(clazz)) && nav().getMethodParameters(m).length == 0 && nav().isStaticMethod(m)){ factoryMethod = m; break; builder.reportError(new IllegalAnnotationException( 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 ));
elementType = nav().getReturnType(m); T baseClass = nav().getBaseClass(elementType,nav().asDecl(JAXBElement.class)); if(baseClass==null) throw new IllegalAnnotationException( Messages.XML_ELEMENT_MAPPING_ON_NON_IXMLELEMENT_METHOD.format(nav().getMethodName(m)), anno ); T[] methodParams = nav().getMethodParameters(m); XmlJavaTypeAdapter adapter = reader().getMethodAnnotation(XmlJavaTypeAdapter.class,m,this); if(adapter!=null) a = new Adapter<T,C>(adapter,reader(),nav()); else { XmlAttachmentRef xsa = reader().getMethodAnnotation(XmlAttachmentRef.class,m,this); if(xsa!=null) { TODO.prototype("in Annotation Processing swaRefAdapter isn't avaialble, so this returns null"); a = new Adapter<T,C>(owner.nav.asDecl(SwaRefAdapter.class),owner.nav); : nav().getTypeArgument(baseClass,0); // fall back to infer from the return type if no parameter. T list = nav().getBaseClass(tOfJAXBElementT,nav().asDecl(List.class)); if(list==null) { isCollection = false; contentType = builder.getTypeInfo(tOfJAXBElementT,this); // suck this type into the current set. } else { isCollection = true; contentType = builder.getTypeInfo(nav().getTypeArgument(list,0),this); if(nav().isSameType(s, nav().ref(XmlElementDecl.GLOBAL.class)))
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 Location getLocation() { return nav.getClassLocation(nav.asDecl(Object.class)); }
/** * This method is used to add a root reference to a model. */ public NonElement<T,C> getTypeInfo(Ref<T,C> ref) { // TODO: handle XmlValueList assert !ref.valueList; C c = nav.asDecl(ref.type); if(c!=null && reader.getClassAnnotation(XmlRegistry.class,c,null/*TODO: is this right?*/)!=null) { if(!registries.containsKey(nav.getPackageName(c))) addRegistry(c,null); return null; // TODO: is this correct? } else return getTypeInfo(ref.type,null); }
/** * 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 ArrayInfoImpl(ModelBuilder<TypeT,ClassDeclT,FieldT,MethodT> builder, Locatable upstream, TypeT arrayType) { super(builder, upstream); this.arrayType = arrayType; TypeT componentType = nav().getComponentType(arrayType); this.itemType = builder.getTypeInfo(componentType, this); QName n = itemType.getTypeName(); if(n==null) { builder.reportError(new IllegalAnnotationException(Messages.ANONYMOUS_ARRAY_ITEM.format( nav().getTypeName(componentType)),this)); n = new QName("#dummy"); // for error recovery } this.typeName = ArrayInfoUtil.calcArrayTypeName(n); }
if(clazz.getClazz()==navigator.asDecl(CompositeStructure.class)) return; // this is a special class we introduced for JAX-WS that we *don't* want in the schema if(clazz.isElement()) { nsUri = clazz.getElementName().getNamespaceURI(); Namespace ns = getNamespace(nsUri); ns.classes.add(clazz); QName tn = clazz.getTypeName(); if(tn!=null) { nsUri = tn.getNamespaceURI(); } else { if (p instanceof AttributePropertyInfo) { AttributePropertyInfo<T,C> ap = (AttributePropertyInfo<T,C>) p; String aUri = ap.getXmlName().getNamespaceURI(); if(aUri.length()>0) {
classList.add(i.getName()); String javaName = navigator.getTypeName(a.getType()); classList.add(javaName); QName tn = l.getTypeName(); if(tn!=null) { String javaName = navigator.getTypeName(l.getType()); classList.add(javaName); if(xt instanceof ClassInfo) { ClassInfo<TypeMirror,TypeDeclaration> xct = (ClassInfo<TypeMirror,TypeDeclaration>) xt; Element<TypeMirror,TypeDeclaration> elem = xct.asElement(); if(elem!=null && elem.getElementName().equals(entry.getKey())) { itr.remove(); continue;
builder.registries.put(getPackageName(),this); if(nav.getDeclaredField(registryClass,ContextFactory.USE_JAXB_PROPERTIES)!=null) { builder.reportError(new IllegalAnnotationException( Messages.MISSING_JAXB_PROPERTIES.format(getPackageName()), this for( M m : nav.getDeclaredMethods(registryClass) ) { XmlElementDecl em = builder.reader.getMethodAnnotation( XmlElementDecl.class, m, this ); if(nav.getMethodName(m).startsWith("create")) { builder.getTypeInfo(nav.getReturnType(m), new MethodLocatable<M>(this,m,nav))); ei = builder.createElementInfo(this,m); } catch (IllegalAnnotationException e) { builder.reportError(e);
/** * Checks if the given adapter is applicable to the declared property type. */ private boolean isApplicable(XmlJavaTypeAdapter jta, T declaredType ) { if(jta==null) return false; T type = reader().getClassValue(jta,"type"); if(nav().isSameType(declaredType, type)) return true; // for types explicitly marked in XmlJavaTypeAdapter.type() T ad = reader().getClassValue(jta,"value"); T ba = nav().getBaseClass(ad, nav().asDecl(XmlAdapter.class)); if(!nav().isParameterizedType(ba)) return true; // can't check type applicability. assume Object, which means applicable to any. T inMemType = nav().getTypeArgument(ba, 1); return nav().isSubClassOf(declaredType,inMemType); }
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); } }
parent.builder.reportError(new IllegalAnnotationException( Messages.ILLEGAL_ANNOTATION.format(XmlMimeType.class.getName()), seed.readAnnotation(XmlMimeType.class) this.isCollection = nav().isSubClassOf(t, nav().ref(Collection.class)) || nav().isArrayButNotByteArray(t); if(xsa!=null) { parent.builder.hasSwaRef = true; adapter = new Adapter<T,C>(nav().asDecl(SwaRefAdapter.class),nav()); } else { adapter = null; T ad = reader().getClassValue(xjta,"value"); parent.builder.reportError(new IllegalAnnotationException( Messages.UNMATCHABLE_ADAPTER.format( nav().getTypeName(ad), nav().getTypeName(t)), xjta ));
private boolean addAllSubtypes(T type) { Navigator<T,C,F,M> nav = nav(); // this allows the explicitly referenced type to be sucked in to the model NonElement<T,C> t = parent.builder.getClassInfo(nav.asDecl(type),this); if(!(t instanceof ClassInfo)) // this is leaf. return false; boolean result = false; ClassInfo<T,C> c = (ClassInfo<T,C>) t; if(c.isElement()) { types.add(c.asElement()); result = true; } // look for other possible types for( ClassInfo<T,C> ci : parent.owner.beans().values() ) { if(ci.isElement() && nav.isSubClassOf(ci.getType(),type)) { types.add(ci.asElement()); result = true; } } // don't allow local elements to substitute. for( ElementInfo<T,C> ei : parent.owner.getElementMappings(null).values()) { if(nav.isSubClassOf(ei.getType(),type)) { types.add(ei); result = true; } } return result; }
parent.builder.reportError(new IllegalAnnotationException( Messages.MUTUALLY_EXCLUSIVE_ANNOTATIONS.format( nav().getClassName(parent.getClazz())+'#'+seed.getName(), ref.annotationType().getName(), refs.annotationType().getName()), ref, refs )); final T defaultType = nav.ref(XmlElementRef.DEFAULT.class); final C je = nav.asDecl(JAXBElement.class); T type = reader.getClassValue(r,"type"); if(nav().isSameType(type, defaultType)) type = nav.erasure(getIndividualType()); if(nav.getBaseClass(type,je)!=null) yield = addGenericElement(r); else if(nav().isSameType(type, nav.ref(JAXBElement.class))) { nav().getClassName(parent.getClazz())+'#'+seed.getName(), ref.annotationType().getName(), refs.annotationType().getName()), ref, refs )); final T defaultType = nav.ref(XmlElementRef.DEFAULT.class); final C je = nav.asDecl(JAXBElement.class); T type = reader.getClassValue(r,"type"); if (nav().isSameType(type, defaultType)) { type = nav.erasure(getIndividualType());
C sc = nav().getSuperClass(c); if(shouldRecurseSuperClass(sc)) collectGetterSetters(sc,getters,setters); Collection<? extends M> methods = nav().getDeclaredMethods(c); Map<String,List<M>> allSetters = new LinkedHashMap<String,List<M>>(); for( M method : methods ) { boolean used = false; // if this method is added to getters or setters if(nav().isBridgeMethod(method)) continue; // ignore String name = nav().getMethodName(method); int arity = nav().getMethodParameters(method).length; if(nav().isStaticMethod(method)) { ensureNoAnnotation(method); continue; T getterType = nav().getReturnType(getter); for (M setter : propSetters) { T setterType = nav().getMethodParameters(setter)[0]; if (nav().isSameType(setterType, getterType)) { setters.put(propName, setter); break;
private void getExceptionProperties(C exception, TreeMap<String, A> fields, boolean decapitalize) { C sc = nav.getSuperClass(exception); if (sc != null) { getExceptionProperties(sc, fields, decapitalize); } Collection<? extends M> methods = nav.getDeclaredMethods(exception); for (M method : methods) { // 2.1.x is doing the following: no final static, transient, non-public // transient cannot used as modifier for method, so not doing it now if (!nav.isPublicMethod(method) || (nav.isStaticMethod(method) && nav.isFinalMethod(method))) { continue; } if (!nav.isPublicMethod(method)) { continue; } String name = nav.getMethodName(method); if (!(name.startsWith("get") || name.startsWith("is")) || skipProperties.contains(name) || name.equals("get") || name.equals("is")) { // Don't bother with invalid propertyNames. continue; } T returnType = getSafeType(nav.getReturnType(method)); if (nav.getMethodParameters(method).length == 0) { String fieldName = name.startsWith("get") ? name.substring(3) : name.substring(2); if (decapitalize) fieldName = StringUtils.decapitalize(fieldName); fields.put(fieldName, factory.createWrapperBeanMember(returnType, fieldName, Collections.<Annotation>emptyList())); } } }
c = nav().getSuperClass(c); } while(shouldRecurseSuperClass(c)); M setter = setters.get(name); Annotation[] ga = getter!=null ? reader().getAllMethodAnnotations(getter,new MethodLocatable<M>(this,getter,nav())) : EMPTY_ANNOTATIONS; Annotation[] sa = setter!=null ? reader().getAllMethodAnnotations(setter,new MethodLocatable<M>(this,setter,nav())) : EMPTY_ANNOTATIONS; isOverriding = (getter!=null && nav().isOverriding(getter,c)) && (setter!=null && nav().isOverriding(setter,c)); && !nav().isSameType(nav().getReturnType(getter), nav().getMethodParameters(setter)[0])) { builder.reportError(new IllegalAnnotationException( Messages.GETTER_SETTER_INCOMPATIBLE_TYPE.format( nav().getTypeName(nav().getReturnType(getter)), nav().getTypeName(nav().getMethodParameters(setter)[0]) ), new MethodLocatable<M>( this, getter, nav()),
parent.builder.reportError(new IllegalAnnotationException( Messages.MUTUALLY_EXCLUSIVE_ANNOTATIONS.format( nav().getClassName(parent.getClazz())+'#'+seed.getName(), xe.annotationType().getName(), xes.annotationType().getName()), xe, xes )); if(!nav().isPrimitive(t) || isCollection()) isRequired = false; TypeT type = reader().getClassValue(item, "type"); if (nav().isSameType(type, nav().ref(XmlElement.DEFAULT.class))) type = getIndividualType(); if((!nav().isPrimitive(type) || isCollection()) && !item.required()) isRequired = false; types.add(createTypeRef(name, type, item.nillable(), getDefaultValue(item.defaultValue()) ));
/** * @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); } }