static <T,C,F,M> QName calcSchemaType( AnnotationReader<T,C,F,M> reader, AnnotationSource primarySource, C enclosingClass, T individualType, Locatable src ) { XmlSchemaType xst = primarySource.readAnnotation(XmlSchemaType.class); if(xst!=null) { return new QName(xst.namespace(),xst.name()); } // check the defaulted annotation XmlSchemaTypes xsts = reader.getPackageAnnotation(XmlSchemaTypes.class,enclosingClass,src); XmlSchemaType[] values = null; if(xsts!=null) values = xsts.value(); else { xst = reader.getPackageAnnotation(XmlSchemaType.class,enclosingClass,src); if(xst!=null) { values = new XmlSchemaType[1]; values[0] = xst; } } if(values!=null) { for( XmlSchemaType item : values ) { if(reader.getClassValue(item,"type").equals(individualType)) { return new QName(item.namespace(),item.name()); } } } return null; }
/** * Parses an {@link XmlRootElement} annotation on a class * and determine the element name. * * @return null * if none was found. */ protected final QName parseElementName(ClassDeclT clazz) { XmlRootElement e = reader().getClassAnnotation(XmlRootElement.class,clazz,this); if(e==null) return null; String local = e.name(); if(local.equals("##default")) { // if defaulted... local = NameConverter.standard.toVariableName(nav().getClassShortName(clazz)); } String nsUri = e.namespace(); if(nsUri.equals("##default")) { // if defaulted ... XmlSchema xs = reader().getPackageAnnotation(XmlSchema.class,clazz,this); if(xs!=null) nsUri = xs.namespace(); else { nsUri = builder.defaultNsUri; } } return new QName(nsUri.intern(),local.intern()); }
anno = reader().getMethodAnnotation( XmlElementDecl.class, m, this ); assert anno!=null; // the caller should check this assert anno instanceof Locatable; elementType = nav().getReturnType(m); T baseClass = nav().getBaseClass(elementType,nav().asDecl(JAXBElement.class)); if(baseClass==null) throw new IllegalAnnotationException( 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"); contentType = builder.getTypeInfo(this.adapter.defaultType,this); isCollection = false; T s = reader().getClassValue(anno,"scope"); throw new IllegalAnnotationException( this.inlineBinary = reader().hasMethodAnnotation(XmlInlineBinaryData.class,method); this.schemaType = Util.calcSchemaType(reader(),property,registry.registryClass, getContentInMemoryType(),this);
/** * Gets an annotation that are allowed on both class and type. */ private <T extends Annotation> T getClassOrPackageAnnotation(Class<T> type) { T t = reader().getClassAnnotation(type,clazz,this); if(t!=null) return t; // defaults to the package level return reader().getPackageAnnotation(type,clazz,this); }
/** * @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); } }
private QName calcXmlName(String uri,String local) { // compute the default TODO.checkSpec(); if(local.length()==0 || local.equals("##default")) local = seed.getName(); if(uri.equals("##default")) { XmlSchema xs = reader().getPackageAnnotation( XmlSchema.class, parent.getClazz(), this ); // JAX-RPC doesn't want the default namespace URI swapping to take effect to // local "unqualified" elements. UGLY. if(xs!=null) { switch(xs.elementFormDefault()) { case QUALIFIED: QName typeName = parent.getTypeName(); if(typeName!=null) uri = typeName.getNamespaceURI(); else uri = xs.namespace(); if(uri.length()==0) uri = parent.builder.defaultNsUri; break; case UNQUALIFIED: case UNSET: uri = ""; } } else { uri = ""; } } return new QName(uri.intern(),local.intern()); }
private QName calcXmlName(XmlAttribute att) { String uri; String local; uri = att.namespace(); local = att.name(); // compute the default if(local.equals("##default")) local = NameConverter.standard.toVariableName(getName()); if(uri.equals("##default")) { XmlSchema xs = reader().getPackageAnnotation( XmlSchema.class, parent.getClazz(), this ); // JAX-RPC doesn't want the default namespace URI swapping to take effect to // local "unqualified" elements. UGLY. if(xs!=null) { switch(xs.attributeFormDefault()) { case QUALIFIED: uri = parent.getTypeName().getNamespaceURI(); if(uri.length()==0) uri = parent.builder.defaultNsUri; break; case UNQUALIFIED: case UNSET: uri = ""; } } else uri = ""; } return new QName(uri.intern(),local.intern()); }
final QName parseElementName(XmlElementDecl e) { String local = e.name(); String nsUri = e.namespace(); if(nsUri.equals("##default")) { // if defaulted ... XmlSchema xs = reader().getPackageAnnotation(XmlSchema.class, nav().getDeclaringClassForMethod(method),this); if(xs!=null) nsUri = xs.namespace(); else { nsUri = builder.defaultNsUri; } } return new QName(nsUri.intern(),local.intern()); }
return r; if(nav.isEnum(clazz)) { EnumLeafInfoImpl<T,C,F,M> li = createEnumLeafInfo(clazz,upstream); typeInfoSet.add(li); r = li; addTypeName(r); } else { boolean isReplaced = subclassReplacements.containsKey(clazz); if(isReplaced && !searchForSuperClass) { r = getClassInfo(subclassReplacements.get(clazz),upstream); } else if(reader.hasClassAnnotation(clazz,XmlTransient.class) || isReplaced) { r = getClassInfo( nav.getSuperClass(clazz), searchForSuperClass, new ClassLocatable<C>(upstream,clazz,nav) ); } else { XmlSeeAlso sa = reader.getClassAnnotation(XmlSeeAlso.class, clazz, upstream); if(sa!=null) { for( T t : reader.getClassArrayValue(sa,"value") ) { getTypeInfo(t,(Locatable)sa);
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))){ 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 ));
public final XmlNsForm getElementFormDefault(String nsUri) { for (ClassInfoImpl<T, C, F, M> ci : beans().values()) { XmlSchema xs = reader.getPackageAnnotation( XmlSchema.class, ci.getClazz(), null ); if(xs==null) continue; if(!xs.namespace().equals(nsUri)) continue; XmlNsForm xnf = xs.elementFormDefault(); if(xnf!=XmlNsForm.UNSET) return xnf; } return XmlNsForm.UNSET; }
public Map<String,String> getXmlNs(String namespaceUri) { if(xmlNsCache==null) { xmlNsCache = new HashMap<String,Map<String,String>>(); for (ClassInfoImpl<T, C, F, M> ci : beans().values()) { XmlSchema xs = reader.getPackageAnnotation( XmlSchema.class, ci.getClazz(), null ); if(xs==null) continue; String uri = xs.namespace(); Map<String,String> m = xmlNsCache.get(uri); if(m==null) xmlNsCache.put(uri,m=new HashMap<String, String>()); for( XmlNs xns : xs.xmlns() ) { m.put(xns.prefix(),xns.namespaceURI()); } } } Map<String,String> r = xmlNsCache.get(namespaceUri); if(r!=null) return r; else return Collections.emptyMap(); }
public final XmlNsForm getAttributeFormDefault(String nsUri) { for (ClassInfoImpl<T,C,F,M> ci : beans().values()) { XmlSchema xs = reader.getPackageAnnotation( XmlSchema.class, ci.getClazz(), null ); if(xs==null) continue; if(!xs.namespace().equals(nsUri)) continue; XmlNsForm xnf = xs.attributeFormDefault(); if(xnf!=XmlNsForm.UNSET) return xnf; } return XmlNsForm.UNSET; }
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);
public Map<String,String> getSchemaLocations() { Map<String, String> r = new HashMap<String,String>(); for (ClassInfoImpl<T, C, F, M> ci : beans().values()) { XmlSchema xs = reader.getPackageAnnotation( XmlSchema.class, ci.getClazz(), null ); if(xs==null) continue; String loc = xs.location(); if(loc.equals(XmlSchema.NO_LOCATION)) continue; // unspecified r.put(xs.namespace(),loc); } return r; }
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)),
private void findFieldProperties(C c, XmlAccessType at) { C sc = nav().getSuperClass(c); if (shouldRecurseSuperClass(sc)) { findFieldProperties(sc,at); for( F f : nav().getDeclaredFields(c) ) { Annotation[] annotations = reader().getAllFieldAnnotations(f,this); boolean isDummy = reader().hasFieldAnnotation(OverrideAnnotationOf.class, f); if( nav().isTransient(f) ) { builder.reportError(new IllegalAnnotationException( Messages.TRANSIENT_FIELD_NOT_BINDABLE.format(nav().getFieldName(f)), getSomeJAXBAnnotation(annotations)));
/** * 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); }
AnnotationReader<T,C,F,M> reader = reader(); 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().isSameType(type, nav.ref(JAXBElement.class))) { parent.builder.reportError(new IllegalAnnotationException( Messages.NO_XML_ELEMENT_DECL.format( getEffectiveNamespaceFor(r), r.name()), )); } else { parent.builder.reportError(new IllegalAnnotationException( Messages.INVALID_XML_ELEMENT_REF.format(type),this)); T type = reader.getClassValue(r,"type"); if (nav().isSameType(type, defaultType)) { type = nav.erasure(getIndividualType());
Collection<? extends F> fields = nav().getDeclaredFields(clazz); for (F f : fields) { if (nav().isSameType(nav().getFieldType(f), nav().ref(String.class))) { XmlSchemaType schemaTypeAnnotation = builder.reader.getFieldAnnotation(XmlSchemaType.class, f, this); if (schemaTypeAnnotation != null) { if ("token".equals(schemaTypeAnnotation.name())) { F constant = constants[i]; String name = nav().getFieldName(constant); XmlEnumValue xev = builder.reader.getFieldAnnotation(XmlEnumValue.class, constant, this);