@Override public void link() { // make sure we've computed constants getConstants(); super.link(); }
public void link() { getTransducer(); super.link(); } }
public NonElement<T,C> getTarget() { if(type==null) { assert parent.builder!=null : "this method must be called during the build stage"; type = parent.builder.getTypeInfo(getIndividualType(),this); } return type; }
public RuntimeReferencePropertyInfoImpl(RuntimeClassInfoImpl classInfo, PropertySeed<Type,Class,Field,Method> seed) { super(classInfo,seed); Accessor rawAcc = ((RuntimeClassInfoImpl.RuntimePropertySeed)seed).getAccessor(); if(getAdapter()!=null && !isCollection()) // adapter for a single-value property is handled by accessor. // adapter for a collection property is handled by lister. rawAcc = rawAcc.adapt(getAdapter()); this.acc = rawAcc; }
public NonElement<T,C> getTarget(T type) { assert parent.builder!=null : "this method must be called during the build stage"; return parent.builder.getTypeInfo(type,this); } }
public void link() { getTransducer(); super.link(); } }
public void link() { getTransducer(); // populate the transducer super.link(); }
protected TypeInfoSetImpl<T,C,F,M> createTypeInfoSet() { return new TypeInfoSetImpl<T,C,F,M>(nav,reader,BuiltinLeafInfoImpl.createLeaves(nav)); }
/** * {@inheritDoc} * * The substitution hierarchy is the same as the inheritance hierarchy. */ public final Element<T,C> getSubstitutionHead() { ClassInfoImpl<T,C,F,M> c = getBaseClass(); while(c!=null && !c.isElement()) c = c.getBaseClass(); return c; }
public Set<? extends Element<T,C>> getElements() { if(types==null) calcTypes(false); assert types!=null; return types; }
public Iterable<? extends EnumConstantImpl<T,C,F,M>> getConstants() { if(firstConstant==null) calcConstants(); return this; }
/** * Gets the {@link PropertySeed} object for the inherited attribute wildcard. */ private PropertySeed<T,C,F,M> getInheritedAttributeWildcard() { for( ClassInfoImpl<T,C,F,M> c=getBaseClass(); c!=null; c=c.getBaseClass() ) if(c.attributeWildcard!=null) return c.attributeWildcard; return null; }
/** * Used by {@link PropertyInfoImpl} to create new instances of {@link TypeRef} */ protected TypeRefImpl<TypeT,ClassDeclT> createTypeRef(QName name,TypeT type,boolean isNillable,String defaultValue) { return new TypeRefImpl<TypeT,ClassDeclT>(this,name,type,isNillable,defaultValue); }
private static Annotation getSomeJAXBAnnotation(Annotation[] annotations) { for( Annotation a : annotations ) if(isJAXBAnnotation(a)) return a; return null; }
public Transducer getTransducer() { if(!computedTransducer) { computedTransducer = true; xducer = calcTransducer(); } return xducer; }
public Element<T,C> asElement() { if(isElement()) return this; else return null; }
ElementPropertyInfoImpl( ClassInfoImpl<TypeT,ClassDeclT,FieldT,MethodT> parent, PropertySeed<TypeT,ClassDeclT,FieldT,MethodT> propertySeed) { super(parent, propertySeed); isValueList = seed.hasAnnotation(XmlList.class); }
private void calcRef() { // we can't do this eagerly because of a cyclic dependency ref = owner.parent.builder.getTypeInfo(type,owner); assert ref!=null; }
public boolean isRequired() { if(isRequired==null) calcTypes(false); return isRequired; }