jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/xml/internal/bind/v2/model/impl/ClassInfoImpl.java@9c07ef4934dd (annotated)

src/share/jaxws_classes/com/sun/xml/internal/bind/v2/model/impl/ClassInfoImpl.java@9c07ef4934dd (annotated)

src/share/jaxws_classes/com/sun/xml/internal/bind/v2/model/impl/ClassInfoImpl.java

Thu, 31 Aug 2017 15:18:52 +0800

author: aoqi
date: Thu, 31 Aug 2017 15:18:52 +0800
changeset 637: 9c07ef4934dd
parent 0: 373ffda63c9a
permissions: -rw-r--r--

merge

 /*
  * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package com.sun.xml.internal.bind.v2.model.impl;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.AbstractList;
 import javax.xml.bind.annotation.XmlAccessOrder;
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorOrder;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.XmlAnyAttribute;
 import javax.xml.bind.annotation.XmlAnyElement;
 import javax.xml.bind.annotation.XmlAttachmentRef;
 import javax.xml.bind.annotation.XmlAttribute;
 import javax.xml.bind.annotation.XmlElement;
 import javax.xml.bind.annotation.XmlElementRef;
 import javax.xml.bind.annotation.XmlElementRefs;
 import javax.xml.bind.annotation.XmlElementWrapper;
 import javax.xml.bind.annotation.XmlElements;
 import javax.xml.bind.annotation.XmlID;
 import javax.xml.bind.annotation.XmlIDREF;
 import javax.xml.bind.annotation.XmlInlineBinaryData;
 import javax.xml.bind.annotation.XmlList;
 import javax.xml.bind.annotation.XmlMimeType;
 import javax.xml.bind.annotation.XmlMixed;
 import javax.xml.bind.annotation.XmlRootElement;
 import javax.xml.bind.annotation.XmlSchemaType;
 import javax.xml.bind.annotation.XmlTransient;
 import javax.xml.bind.annotation.XmlType;
 import javax.xml.bind.annotation.XmlValue;
 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 import javax.xml.namespace.QName;
 import com.sun.istack.internal.FinalArrayList;
 import com.sun.xml.internal.bind.annotation.OverrideAnnotationOf;
 import com.sun.xml.internal.bind.v2.model.annotation.Locatable;
 import com.sun.xml.internal.bind.v2.model.annotation.MethodLocatable;
 import com.sun.xml.internal.bind.v2.model.core.ClassInfo;
 import com.sun.xml.internal.bind.v2.model.core.Element;
 import com.sun.xml.internal.bind.v2.model.core.ID;
 import com.sun.xml.internal.bind.v2.model.core.NonElement;
 import com.sun.xml.internal.bind.v2.model.core.PropertyInfo;
 import com.sun.xml.internal.bind.v2.model.core.PropertyKind;
 import com.sun.xml.internal.bind.v2.model.core.ValuePropertyInfo;
 import com.sun.xml.internal.bind.v2.runtime.IllegalAnnotationException;
 import com.sun.xml.internal.bind.v2.runtime.Location;
 import com.sun.xml.internal.bind.v2.util.EditDistance;
 /**
  * A part of the {@link ClassInfo} that doesn't depend on a particular
  * reflection library.
  *
  * @author Kohsuke Kawaguchi (kk@kohsuke.org)
  */
 public class ClassInfoImpl<T,C,F,M> extends TypeInfoImpl<T,C,F,M>
     implements ClassInfo<T,C>, Element<T,C> {
     protected final C clazz;
     /**
      * @see #getElementName()
      */
     private final QName elementName;
     /**
      * @see #getTypeName()
      */
     private final QName typeName;
     /**
      * Lazily created.
      *
      * @see #getProperties()
      */
     private FinalArrayList<PropertyInfoImpl<T,C,F,M>> properties;
     /**
      * The property order.
      *
      * null if unordered. {@link #DEFAULT_ORDER} if ordered but the order is defaulted
      *
      * @see #isOrdered()
      */
     private /*final*/ String[] propOrder;
     /**
      * Lazily computed.
      *
      * To avoid the cyclic references of the form C1 --base--> C2 --property--> C1.
      */
     private ClassInfoImpl<T,C,F,M> baseClass;
     private boolean baseClassComputed = false;
     private boolean hasSubClasses = false;
     /**
      * If this class has a declared (not inherited) attribute wildcard,  keep the reference
      * to it.
      *
      * This parameter is initialized at the construction time and never change.
      */
     protected /*final*/ PropertySeed<T,C,F,M> attributeWildcard;
     /**
      * @see #getFactoryMethod()
      */
     private M factoryMethod = null;
     ClassInfoImpl(ModelBuilder<T,C,F,M> builder, Locatable upstream, C clazz) {
         super(builder,upstream);
         this.clazz = clazz;
         assert clazz!=null;
         // compute the element name
         elementName = parseElementName(clazz);
         // compute the type name
         XmlType t = reader().getClassAnnotation(XmlType.class,clazz,this);
         typeName = parseTypeName(clazz,t);
         if(t!=null) {
             String[] propOrder = t.propOrder();
             if(propOrder.length==0)
                 this.propOrder = null;   // unordered
             else {
                 if(propOrder[0].length()==0)
                     this.propOrder = DEFAULT_ORDER;
                 else
                     this.propOrder = propOrder;
             }
         } else {
             propOrder = DEFAULT_ORDER;
         }
         // obtain XmlAccessorOrder and  set proporder (XmlAccessorOrder can be defined for whole package)
         // (<xs:all> vs <xs:sequence>)
         XmlAccessorOrder xao = reader().getPackageAnnotation(XmlAccessorOrder.class, clazz, this);
         if((xao != null) && (xao.value() == XmlAccessOrder.UNDEFINED)) {
             propOrder = null;
         }
         // obtain XmlAccessorOrder and  set proporder (<xs:all> vs <xs:sequence>)
         xao = reader().getClassAnnotation(XmlAccessorOrder.class, clazz, this);
         if((xao != null) && (xao.value() == XmlAccessOrder.UNDEFINED)) {
             propOrder = null;
         }
         if(nav().isInterface(clazz)) {
             builder.reportError(new IllegalAnnotationException(
                 Messages.CANT_HANDLE_INTERFACE.format(nav().getClassName(clazz)), this ));
         }
         // the class must have the default constructor
         if (!hasFactoryConstructor(t)){
             if(!nav().hasDefaultConstructor(clazz)){
                 if(nav().isInnerClass(clazz)) {
                     builder.reportError(new IllegalAnnotationException(
                         Messages.CANT_HANDLE_INNER_CLASS.format(nav().getClassName(clazz)), this ));
                 } else if (elementName != null) {
                     builder.reportError(new IllegalAnnotationException(
                         Messages.NO_DEFAULT_CONSTRUCTOR.format(nav().getClassName(clazz)), this ));
                 }
             }
         }
     }
     public ClassInfoImpl<T,C,F,M> getBaseClass() {
         if (!baseClassComputed) {
             // compute the base class
             C s = nav().getSuperClass(clazz);
             if(s==null || s==nav().asDecl(Object.class)) {
                 baseClass = null;
             } else {
                 NonElement<T,C> b = builder.getClassInfo(s, true, this);
                 if(b instanceof ClassInfoImpl) {
                     baseClass = (ClassInfoImpl<T,C,F,M>) b;
                     baseClass.hasSubClasses = true;
                 } else {
                     baseClass = null;
                 }
             }
             baseClassComputed = true;
         }
         return baseClass;
     }
     /**
      * {@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 final C getClazz() {
         return clazz;
     }
     /**
      * When a bean binds to an element, it's always through {@link XmlRootElement},
      * so this method always return null.
      *
      * @deprecated
      *      you shouldn't be invoking this method on {@link ClassInfoImpl}.
      */
     public ClassInfoImpl<T,C,F,M> getScope() {
         return null;
     }
     public final T getType() {
         return nav().use(clazz);
     }
     /**
      * A {@link ClassInfo} can be referenced by {@link XmlIDREF} if
      * it has an ID property.
      */
     public boolean canBeReferencedByIDREF() {
         for (PropertyInfo<T,C> p : getProperties()) {
             if(p.id()== ID.ID)
                 return true;
         }
         ClassInfoImpl<T,C,F,M> base = getBaseClass();
         if(base!=null)
             return base.canBeReferencedByIDREF();
         else
             return false;
     }
     public final String getName() {
         return nav().getClassName(clazz);
     }
     public <A extends Annotation> A readAnnotation(Class<A> a) {
         return reader().getClassAnnotation(a,clazz,this);
     }
     public Element<T,C> asElement() {
         if(isElement())
             return this;
         else
             return null;
     }
     public List<? extends PropertyInfo<T,C>> getProperties() {
         if(properties!=null)    return properties;
         // check the access type first
         XmlAccessType at = getAccessType();
         properties = new FinalArrayList<PropertyInfoImpl<T,C,F,M>>();
         findFieldProperties(clazz,at);
         findGetterSetterProperties(at);
         if(propOrder==DEFAULT_ORDER || propOrder==null) {
             XmlAccessOrder ao = getAccessorOrder();
             if(ao==XmlAccessOrder.ALPHABETICAL)
                 Collections.sort(properties);
         } else {
             //sort them as specified
             PropertySorter sorter = new PropertySorter();
             for (PropertyInfoImpl p : properties) {
                 sorter.checkedGet(p);   // have it check for errors
             }
             Collections.sort(properties,sorter);
             sorter.checkUnusedProperties();
         }
         {// additional error checks
             PropertyInfoImpl vp=null; // existing value property
             PropertyInfoImpl ep=null; // existing element property
             for (PropertyInfoImpl p : properties) {
                 switch(p.kind()) {
                 case ELEMENT:
                 case REFERENCE:
                 case MAP:
                     ep = p;
                     break;
                 case VALUE:
                     if(vp!=null) {
                         // can't have multiple value properties.
                         builder.reportError(new IllegalAnnotationException(
                             Messages.MULTIPLE_VALUE_PROPERTY.format(),
                             vp, p ));
                     }
                     if(getBaseClass()!=null) {
                         builder.reportError(new IllegalAnnotationException(
                             Messages.XMLVALUE_IN_DERIVED_TYPE.format(), p ));
                     }
                     vp = p;
                     break;
                 case ATTRIBUTE:
                     break;  // noop
                 default:
                     assert false;
                 }
             }
             if(ep!=null && vp!=null) {
                 // can't have element and value property at the same time
                 builder.reportError(new IllegalAnnotationException(
                     Messages.ELEMENT_AND_VALUE_PROPERTY.format(),
                     vp, ep
                 ));
             }
         }
         return properties;
     }
     private void findFieldProperties(C c, XmlAccessType at) {
         // always find properties from the super class first
         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) ) {
                 // it's an error for transient field to have any binding annotation
                 if(hasJAXBAnnotation(annotations))
                     builder.reportError(new IllegalAnnotationException(
                         Messages.TRANSIENT_FIELD_NOT_BINDABLE.format(nav().getFieldName(f)),
                             getSomeJAXBAnnotation(annotations)));
             } else
             if( nav().isStaticField(f) ) {
                 // static fields are bound only when there's explicit annotation.
                 if(hasJAXBAnnotation(annotations))
                     addProperty(createFieldSeed(f),annotations, false);
             } else {
                 if(at==XmlAccessType.FIELD
                 ||(at==XmlAccessType.PUBLIC_MEMBER && nav().isPublicField(f))
                 || hasJAXBAnnotation(annotations)) {
                     if (isDummy) {
                         ClassInfo<T, C> top = getBaseClass();
                         while ((top != null) && (top.getProperty("content") == null)) {
                             top = top.getBaseClass();
                         }
                         DummyPropertyInfo prop = (DummyPropertyInfo) top.getProperty("content");
                         PropertySeed seed = createFieldSeed(f);
                         ((DummyPropertyInfo)prop).addType(createReferenceProperty(seed));
                     } else {
                         addProperty(createFieldSeed(f), annotations, false);
                     }
                 }
                 checkFieldXmlLocation(f);
             }
         }
     }
     public final boolean hasValueProperty() {
         ClassInfoImpl<T, C, F, M> bc = getBaseClass();
         if(bc!=null && bc.hasValueProperty())
             return true;
         for (PropertyInfo p : getProperties()) {
             if (p instanceof ValuePropertyInfo) return true;
         }
         return false;
         }
     public PropertyInfo<T,C> getProperty(String name) {
         for( PropertyInfo<T,C> p: getProperties() ) {
             if(p.getName().equals(name))
                 return p;
         }
         return null;
     }
     /**
      * This hook is used by {@link RuntimeClassInfoImpl} to look for {@link XmlLocation}.
      */
     protected void checkFieldXmlLocation(F f) {
     }
     /**
      * 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);
     }
     /**
      * Computes the {@link XmlAccessType} on this class by looking at {@link XmlAccessorType}
      * annotations.
      */
     private XmlAccessType getAccessType() {
         XmlAccessorType xat = getClassOrPackageAnnotation(XmlAccessorType.class);
         if(xat!=null)
             return xat.value();
         else
             return XmlAccessType.PUBLIC_MEMBER;
     }
     /**
      * Gets the accessor order for this class by consulting {@link XmlAccessorOrder}.
      */
     private XmlAccessOrder getAccessorOrder() {
         XmlAccessorOrder xao = getClassOrPackageAnnotation(XmlAccessorOrder.class);
         if(xao!=null)
             return xao.value();
         else
             return XmlAccessOrder.UNDEFINED;
     }
     /**
      * Compares orders among {@link PropertyInfoImpl} according to {@link ClassInfoImpl#propOrder}.
      *
      * <p>
      * extends {@link HashMap} to save memory.
      */
     private final class PropertySorter extends HashMap<String,Integer> implements Comparator<PropertyInfoImpl> {
         /**
          * Mark property names that are used, so that we can report unused property names in the propOrder array.
          */
         PropertyInfoImpl[] used = new PropertyInfoImpl[propOrder.length];
         /**
          * If any name collides, it will be added to this set.
          * This is used to avoid repeating the same error message.
          */
         private Set<String> collidedNames;
         PropertySorter() {
             super(propOrder.length);
             for( String name : propOrder )
                 if(put(name,size())!=null) {
                     // two properties with the same name
                     builder.reportError(new IllegalAnnotationException(
                         Messages.DUPLICATE_ENTRY_IN_PROP_ORDER.format(name),ClassInfoImpl.this));
                 }
         }
         public int compare(PropertyInfoImpl o1, PropertyInfoImpl o2) {
             int lhs = checkedGet(o1);
             int rhs = checkedGet(o2);
             return lhs-rhs;
         }
         private int checkedGet(PropertyInfoImpl p) {
             Integer i = get(p.getName());
             if(i==null) {
                 // missing
                 if (p.kind().isOrdered)
                     builder.reportError(new IllegalAnnotationException(
                         Messages.PROPERTY_MISSING_FROM_ORDER.format(p.getName()),p));
                 // give it an order to recover from an error
                 i = size();
                 put(p.getName(),i);
             }
             // mark the used field
             int ii = i;
             if(ii<used.length) {
                 if(used[ii]!=null && used[ii]!=p) {
                     if(collidedNames==null) collidedNames = new HashSet<String>();
                     if(collidedNames.add(p.getName()))
                         // report the error only on the first time
                         builder.reportError(new IllegalAnnotationException(
                             Messages.DUPLICATE_PROPERTIES.format(p.getName()),p,used[ii]));
                 }
                 used[ii] = p;
             }
             return i;
         }
         /**
          * Report errors for unused propOrder entries.
          */
         public void checkUnusedProperties() {
             for( int i=0; i<used.length; i++ )
                 if(used[i]==null) {
                     String unusedName = propOrder[i];
                     String nearest = EditDistance.findNearest(unusedName, new AbstractList<String>() {
                         public String get(int index) {
                             return properties.get(index).getName();
                         }
                         public int size() {
                             return properties.size();
                         }
                     });
                     boolean isOverriding = (i > (properties.size()-1)) ? false : properties.get(i).hasAnnotation(OverrideAnnotationOf.class);
                     if (!isOverriding) {
                         builder.reportError(new IllegalAnnotationException(
                         Messages.PROPERTY_ORDER_CONTAINS_UNUSED_ENTRY.format(unusedName,nearest),ClassInfoImpl.this));
                     }
                 }
         }
     }
     public boolean hasProperties() {
         return !properties.isEmpty();
     }
     /**
      * Picks the first non-null argument, or null if all arguments are null.
      */
     private static <T> T pickOne( T... args ) {
         for( T arg : args )
             if(arg!=null)
                 return arg;
         return null;
     }
     private static <T> List<T> makeSet( T... args ) {
         List<T> l = new FinalArrayList<T>();
         for( T arg : args )
             if(arg!=null)   l.add(arg);
         return l;
     }
     private static final class ConflictException extends Exception {
         final List<Annotation> annotations;
         public ConflictException(List<Annotation> one) {
             this.annotations = one;
         }
     }
     private static final class DuplicateException extends Exception {
         final Annotation a1,a2;
         public DuplicateException(Annotation a1, Annotation a2) {
             this.a1 = a1;
             this.a2 = a2;
         }
     }
     /**
      * Represents 6 groups of secondary annotations
      */
     private static enum SecondaryAnnotation {
         JAVA_TYPE       (0x01, XmlJavaTypeAdapter.class),
         ID_IDREF        (0x02, XmlID.class, XmlIDREF.class),
         BINARY          (0x04, XmlInlineBinaryData.class, XmlMimeType.class, XmlAttachmentRef.class),
         ELEMENT_WRAPPER (0x08, XmlElementWrapper.class),
         LIST            (0x10, XmlList.class),
         SCHEMA_TYPE     (0x20, XmlSchemaType.class);
         /**
          * Each constant gets an unique bit mask so that the presence/absence
          * of them can be represented in a single byte.
          */
         final int bitMask;
         /**
          * List of annotations that belong to this member.
          */
         final Class<? extends Annotation>[] members;
         SecondaryAnnotation(int bitMask, Class<? extends Annotation>... members) {
             this.bitMask = bitMask;
             this.members = members;
         }
     }
     private static final SecondaryAnnotation[] SECONDARY_ANNOTATIONS = SecondaryAnnotation.values();
     /**
      * Represents 7 groups of properties.
      *
      * Each instance is also responsible for rejecting annotations
      * that are not allowed on that kind.
      */
     private static enum PropertyGroup {
         TRANSIENT       (false,false,false,false,false,false),
         ANY_ATTRIBUTE   (true, false,false,false,false,false),
         ATTRIBUTE       (true, true, true, false,true, true ),
         VALUE           (true, true, true, false,true, true ),
         ELEMENT         (true, true, true, true, true, true ),
         ELEMENT_REF     (true, false,false,true, false,false),
         MAP             (false,false,false,true, false,false);
         /**
          * Bit mask that represents secondary annotations that are allowed on this group.
          *
          * T = not allowed, F = allowed
          */
         final int allowedsecondaryAnnotations;
         PropertyGroup(boolean... bits) {
             int mask = 0;
             assert bits.length==SECONDARY_ANNOTATIONS.length;
             for( int i=0; i<bits.length; i++ ) {
                 if(bits[i])
                     mask |= SECONDARY_ANNOTATIONS[i].bitMask;
             }
             allowedsecondaryAnnotations = ~mask;
         }
         boolean allows(SecondaryAnnotation a) {
             return (allowedsecondaryAnnotations&a.bitMask)==0;
         }
     }
     private static final Annotation[] EMPTY_ANNOTATIONS = new Annotation[0];
     /**
      * All the annotations in JAXB to their internal index.
      */
     private static final HashMap<Class,Integer> ANNOTATION_NUMBER_MAP = new HashMap<Class,Integer>();
     static {
         Class[] annotations = {
             XmlTransient.class,     // 0
             XmlAnyAttribute.class,  // 1
             XmlAttribute.class,     // 2
             XmlValue.class,         // 3
             XmlElement.class,       // 4
             XmlElements.class,      // 5
             XmlElementRef.class,    // 6
             XmlElementRefs.class,   // 7
             XmlAnyElement.class,    // 8
             XmlMixed.class,         // 9
             OverrideAnnotationOf.class,// 10
         };
         HashMap<Class,Integer> m = ANNOTATION_NUMBER_MAP;
         // characterizing annotations
         for( Class c : annotations )
             m.put(c, m.size() );
         // secondary annotations
         int index = 20;
         for( SecondaryAnnotation sa : SECONDARY_ANNOTATIONS ) {
             for( Class member : sa.members )
                 m.put(member,index);
             index++;
         }
     }
     private void checkConflict(Annotation a, Annotation b) throws DuplicateException {
         assert b!=null;
         if(a!=null)
             throw new DuplicateException(a,b);
     }
     /**
      * Called only from {@link #getProperties()}.
      *
      * <p>
      * This is where we decide the type of the property and checks for annotations
      * that are not allowed.
      *
      * @param annotations
      *      all annotations on this property. It's the same as
      *      {@code seed.readAllAnnotation()}, but taken as a parameter
      *      because the caller should know it already.
      */
     private void addProperty( PropertySeed<T,C,F,M> seed, Annotation[] annotations, boolean dummy ) {
         // since typically there's a very few annotations on a method,
         // this runs faster than checking for each annotation via readAnnotation(A)
         // characterizing annotations. these annotations (or lack thereof) decides
         // the kind of the property it goes to.
         // I wish I could use an array...
         XmlTransient t = null;
         XmlAnyAttribute aa = null;
         XmlAttribute a = null;
         XmlValue v = null;
         XmlElement e1 = null;
         XmlElements e2 = null;
         XmlElementRef r1 = null;
         XmlElementRefs r2 = null;
         XmlAnyElement xae = null;
         XmlMixed mx = null;
         OverrideAnnotationOf ov = null;
         // encountered secondary annotations are accumulated into a bit mask
         int secondaryAnnotations = 0;
         try {
             for( Annotation ann : annotations ) {
                 Integer index = ANNOTATION_NUMBER_MAP.get(ann.annotationType());
                 if(index==null) continue;
                 switch(index) {
                 case 0:     checkConflict(t  ,ann); t   = (XmlTransient) ann; break;
                 case 1:     checkConflict(aa ,ann); aa  = (XmlAnyAttribute) ann; break;
                 case 2:     checkConflict(a  ,ann); a   = (XmlAttribute) ann; break;
                 case 3:     checkConflict(v  ,ann); v   = (XmlValue) ann; break;
                 case 4:     checkConflict(e1 ,ann); e1  = (XmlElement) ann; break;
                 case 5:     checkConflict(e2 ,ann); e2  = (XmlElements) ann; break;
                 case 6:     checkConflict(r1 ,ann); r1  = (XmlElementRef) ann; break;
                 case 7:     checkConflict(r2 ,ann); r2  = (XmlElementRefs) ann; break;
                 case 8:     checkConflict(xae,ann); xae = (XmlAnyElement) ann; break;
                 case 9:     checkConflict(mx, ann); mx  = (XmlMixed) ann; break;
                 case 10:    checkConflict(ov, ann); ov  = (OverrideAnnotationOf) ann; break;
                 default:
                     // secondary annotations
                     secondaryAnnotations |= (1<<(index-20));
                     break;
                 }
             }
             // determine the group kind, and also count the numbers, since
             // characterizing annotations are mutually exclusive.
             PropertyGroup group = null;
             int groupCount = 0;
             if(t!=null) {
                 group = PropertyGroup.TRANSIENT;
                 groupCount++;
             }
             if(aa!=null) {
                 group = PropertyGroup.ANY_ATTRIBUTE;
                 groupCount++;
             }
             if(a!=null) {
                 group = PropertyGroup.ATTRIBUTE;
                 groupCount++;
             }
             if(v!=null) {
                 group = PropertyGroup.VALUE;
                 groupCount++;
             }
             if(e1!=null || e2!=null) {
                 group = PropertyGroup.ELEMENT;
                 groupCount++;
             }
             if(r1!=null || r2!=null || xae!=null || mx!=null || ov != null) {
                 group = PropertyGroup.ELEMENT_REF;
                 groupCount++;
             }
             if(groupCount>1) {
                 // collision between groups
                 List<Annotation> err = makeSet(t,aa,a,v,pickOne(e1,e2),pickOne(r1,r2,xae));
                 throw new ConflictException(err);
             }
             if(group==null) {
                 // if no characterizing annotation was found, it's either element or map
                 // sniff the signature and then decide.
                 assert groupCount==0;
                 // UGLY: the presence of XmlJavaTypeAdapter makes it an element property. ARGH.
                 if(nav().isSubClassOf( seed.getRawType(), nav().ref(Map.class) )
                 && !seed.hasAnnotation(XmlJavaTypeAdapter.class))
                     group = PropertyGroup.MAP;
                 else
                     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;
                 }
             }
             // group determined by now
             // make sure that there are no prohibited secondary annotations
             if( (secondaryAnnotations&group.allowedsecondaryAnnotations)!=0 ) {
                 // uh oh. find the offending annotation
                 for( SecondaryAnnotation sa : SECONDARY_ANNOTATIONS ) {
                     if(group.allows(sa))
                         continue;
                     for( Class<? extends Annotation> m : sa.members ) {
                         Annotation offender = seed.readAnnotation(m);
                         if(offender!=null) {
                             // found it
                             builder.reportError(new IllegalAnnotationException(
                                 Messages.ANNOTATION_NOT_ALLOWED.format(m.getSimpleName()),offender));
                             return;
                         }
                     }
                 }
                 // there must have been an offender
                 assert false;
             }
             // actually create annotations
             switch(group) {
             case TRANSIENT:
                 return;
             case ANY_ATTRIBUTE:
                 // an attribute wildcard property
                 if(attributeWildcard!=null) {
                     builder.reportError(new IllegalAnnotationException(
                         Messages.TWO_ATTRIBUTE_WILDCARDS.format(
                             nav().getClassName(getClazz())),aa,attributeWildcard));
                     return; // recover by ignore
                 }
                 attributeWildcard = seed;
                 if(inheritsAttributeWildcard()) {
                     builder.reportError(new IllegalAnnotationException(
                         Messages.SUPER_CLASS_HAS_WILDCARD.format(),
                             aa,getInheritedAttributeWildcard()));
                     return;
                 }
                 // check the signature and make sure it's assignable to Map
                 if(!nav().isSubClassOf(seed.getRawType(),nav().ref(Map.class))) {
                     builder.reportError(new IllegalAnnotationException(
                         Messages.INVALID_ATTRIBUTE_WILDCARD_TYPE.format(nav().getTypeName(seed.getRawType())),
                             aa,getInheritedAttributeWildcard()));
                     return;
                 }
                 return;
             case ATTRIBUTE:
                 properties.add(createAttributeProperty(seed));
                 return;
             case VALUE:
                 properties.add(createValueProperty(seed));
                 return;
             case ELEMENT:
                 properties.add(createElementProperty(seed));
                 return;
             case ELEMENT_REF:
                 properties.add(createReferenceProperty(seed));
                 return;
             case MAP:
                 properties.add(createMapProperty(seed));
                 return;
             default:
                 assert false;
             }
         } catch( ConflictException x ) {
             // report a conflicting annotation
             List<Annotation> err = x.annotations;
             builder.reportError(new IllegalAnnotationException(
                 Messages.MUTUALLY_EXCLUSIVE_ANNOTATIONS.format(
                     nav().getClassName(getClazz())+'#'+seed.getName(),
                     err.get(0).annotationType().getName(), err.get(1).annotationType().getName()),
                     err.get(0), err.get(1) ));
             // recover by ignoring this property
         } catch( DuplicateException e ) {
             // both are present
             builder.reportError(new IllegalAnnotationException(
                 Messages.DUPLICATE_ANNOTATIONS.format(e.a1.annotationType().getName()),
                 e.a1, e.a2 ));
             // recover by ignoring this property
         }
     }
     protected ReferencePropertyInfoImpl<T,C,F,M> createReferenceProperty(PropertySeed<T,C,F,M> seed) {
         return new ReferencePropertyInfoImpl<T,C,F,M>(this,seed);
     }
     protected AttributePropertyInfoImpl<T,C,F,M> createAttributeProperty(PropertySeed<T,C,F,M> seed) {
         return new AttributePropertyInfoImpl<T,C,F,M>(this,seed);
     }
     protected ValuePropertyInfoImpl<T,C,F,M> createValueProperty(PropertySeed<T,C,F,M> seed) {
         return new ValuePropertyInfoImpl<T,C,F,M>(this,seed);
     }
     protected ElementPropertyInfoImpl<T,C,F,M> createElementProperty(PropertySeed<T,C,F,M> seed) {
         return new ElementPropertyInfoImpl<T,C,F,M>(this,seed);
     }
     protected MapPropertyInfoImpl<T,C,F,M> createMapProperty(PropertySeed<T,C,F,M> seed) {
         return new MapPropertyInfoImpl<T,C,F,M>(this,seed);
     }
     /**
      * Adds properties that consists of accessors.
      */
     private void findGetterSetterProperties(XmlAccessType at) {
         // in the first step we accumulate getters and setters
         // into this map keyed by the property name.
         Map<String,M> getters = new LinkedHashMap<String,M>();
         Map<String,M> setters = new LinkedHashMap<String,M>();
         C c = clazz;
         do {
             collectGetterSetters(clazz, getters, setters);
             // take super classes into account if they have @XmlTransient
             c = nav().getSuperClass(c);
         } while(shouldRecurseSuperClass(c));
         // compute the intersection
         Set<String> complete = new TreeSet<String>(getters.keySet());
         complete.retainAll(setters.keySet());
         resurrect(getters, complete);
         resurrect(setters, complete);
         // then look for read/write properties.
         for (String name : complete) {
             M getter = getters.get(name);
             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;
             boolean hasAnnotation = hasJAXBAnnotation(ga) || hasJAXBAnnotation(sa);
             boolean isOverriding = false;
             if(!hasAnnotation) {
                 // checking if the method is overriding others isn't free,
                 // so we don't compute it if it's not necessary.
                 isOverriding = (getter!=null && nav().isOverriding(getter,c))
                             && (setter!=null && nav().isOverriding(setter,c));
             }
             if((at==XmlAccessType.PROPERTY && !isOverriding)
                 || (at==XmlAccessType.PUBLIC_MEMBER && isConsideredPublic(getter) && isConsideredPublic(setter) && !isOverriding)
             || hasAnnotation) {
                 // make sure that the type is consistent
                 if(getter!=null && setter!=null
                 && !nav().isSameType(nav().getReturnType(getter), nav().getMethodParameters(setter)[0])) {
                     // inconsistent
                     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()),
                         new MethodLocatable<M>( this, setter, nav())));
                     continue;
                 }
                 // merge annotations from two list
                 Annotation[] r;
                 if(ga.length==0) {
                     r = sa;
                 } else
                 if(sa.length==0) {
                     r = ga;
                 } else {
                     r = new Annotation[ga.length+sa.length];
                     System.arraycopy(ga,0,r,0,ga.length);
                     System.arraycopy(sa,0,r,ga.length,sa.length);
                 }
                 addProperty(createAccessorSeed(getter, setter), r, false);
             }
         }
         // done with complete pairs
         getters.keySet().removeAll(complete);
         setters.keySet().removeAll(complete);
         // TODO: think about
         // class Foo {
         //   int getFoo();
         // }
         // class Bar extends Foo {
         //   void setFoo(int x);
         // }
         // and how it will be XML-ized.
     }
     private void collectGetterSetters(C c, Map<String,M> getters, Map<String,M> setters) {
         // take super classes into account if they have @XmlTransient.
         // always visit them first so that
         //   1) order is right
         //   2) overriden properties are handled accordingly
         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;
             }
             // is this a get method?
             String propName = getPropertyNameFromGetMethod(name);
             if(propName!=null && arity==0) {
                     getters.put(propName,method);
                 used = true;
             }
             // is this a set method?
             propName = getPropertyNameFromSetMethod(name);
             if(propName!=null && arity==1) {
                     List<M> propSetters = allSetters.get(propName);
                     if(null == propSetters){
                         propSetters = new ArrayList<M>();
                         allSetters.put(propName, propSetters);
                     }
                     propSetters.add(method);
                 used = true; // used check performed later
             }
             if(!used)
                 ensureNoAnnotation(method);
         }
         // Match getter with setters by comparing getter return type to setter param
         for (Map.Entry<String,M> entry : getters.entrySet()) {
             String propName = entry.getKey();
             M getter = entry.getValue();
             List<M> propSetters = allSetters.remove(propName);
             if (null == propSetters) {
                 //no matching setter
                 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;
                 }
             }
         }
         // also allow set-only properties
         for (Map.Entry<String,List<M>> e : allSetters.entrySet()) {
             setters.put(e.getKey(),e.getValue().get(0));
         }
     }
     /**
      * Checks if the properties in this given super class should be aggregated into this class.
      */
     private boolean shouldRecurseSuperClass(C sc) {
         return sc!=null
             && (builder.isReplaced(sc) || reader().hasClassAnnotation(sc, XmlTransient.class));
     }
     /**
      * Returns true if the method is considered 'public'.
      */
     private boolean isConsideredPublic(M m) {
         return m ==null || nav().isPublicMethod(m);
     }
     /**
      * If the method has an explicit annotation, allow it to participate
      * to the processing even if it lacks the setter or the getter.
      */
     private void resurrect(Map<String, M> methods, Set<String> complete) {
         for (Map.Entry<String, M> e : methods.entrySet()) {
             if(complete.contains(e.getKey()))
                 continue;
             if(hasJAXBAnnotation(reader().getAllMethodAnnotations(e.getValue(),this)))
                 complete.add(e.getKey());
         }
     }
     /**
      * Makes sure that the method doesn't have any annotation, if it does,
      * report it as an error
      */
     private void ensureNoAnnotation(M method) {
         Annotation[] annotations = reader().getAllMethodAnnotations(method,this);
         for( Annotation a : annotations ) {
             if(isJAXBAnnotation(a)) {
                 builder.reportError(new IllegalAnnotationException(
                     Messages.ANNOTATION_ON_WRONG_METHOD.format(),
                     a));
                 return;
             }
         }
     }
     /**
      * Returns true if a given annotation is a JAXB annotation.
      */
     private static boolean isJAXBAnnotation(Annotation a) {
         return ANNOTATION_NUMBER_MAP.containsKey(a.annotationType());
     }
     /**
      * Returns true if the array contains a JAXB annotation.
      */
     private static boolean hasJAXBAnnotation(Annotation[] annotations) {
         return getSomeJAXBAnnotation(annotations)!=null;
     }
     private static Annotation getSomeJAXBAnnotation(Annotation[] annotations) {
         for( Annotation a : annotations )
             if(isJAXBAnnotation(a))
                 return a;
         return null;
     }
     /**
      * Returns "Foo" from "getFoo" or "isFoo".
      *
      * @return null
      *      if the method name doesn't look like a getter.
      */
     private static String getPropertyNameFromGetMethod(String name) {
         if(name.startsWith("get") && name.length()>3)
             return name.substring(3);
         if(name.startsWith("is") && name.length()>2)
             return name.substring(2);
         return null;
     }
     /**
      * Returns "Foo" from "setFoo".
      *
      * @return null
      *      if the method name doesn't look like a setter.
      */
     private static String getPropertyNameFromSetMethod(String name) {
         if(name.startsWith("set") && name.length()>3)
             return name.substring(3);
         return null;
     }
     /**
      * Creates a new {@link FieldPropertySeed} object.
      *
      * <p>
      * Derived class can override this method to create a sub-class.
      */
     protected PropertySeed<T,C,F,M> createFieldSeed(F f) {
         return new FieldPropertySeed<T,C,F,M>(this, f);
     }
     /**
      * Creates a new {@link GetterSetterPropertySeed} object.
      */
     protected PropertySeed<T,C,F,M> createAccessorSeed(M getter, M setter) {
         return new GetterSetterPropertySeed<T,C,F,M>(this, getter,setter);
     }
     public final boolean isElement() {
         return elementName!=null;
     }
     public boolean isAbstract() {
         return nav().isAbstract(clazz);
     }
     public boolean isOrdered() {
         return propOrder!=null;
     }
     public final boolean isFinal() {
         return nav().isFinal(clazz);
     }
     public final boolean hasSubClasses() {
         return hasSubClasses;
     }
     public final boolean hasAttributeWildcard() {
         return declaresAttributeWildcard() || inheritsAttributeWildcard();
     }
     public final boolean inheritsAttributeWildcard() {
         return getInheritedAttributeWildcard()!=null;
     }
     public final boolean declaresAttributeWildcard() {
         return attributeWildcard!=null;
     }
     /**
      * 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;
     }
     public final QName getElementName() {
         return elementName;
     }
     public final QName getTypeName() {
         return typeName;
     }
     public final boolean isSimpleType() {
         List<? extends PropertyInfo> props = getProperties();
         if(props.size()!=1)     return false;
         return props.get(0).kind()==PropertyKind.VALUE;
     }
     /**
      * Called after all the {@link TypeInfo}s are collected into the {@link #owner}.
      */
     @Override
     /*package*/ void link() {
         getProperties();    // make sure properties!=null
         // property name collision cehck
         Map<String,PropertyInfoImpl> names = new HashMap<String,PropertyInfoImpl>();
         for( PropertyInfoImpl<T,C,F,M> p : properties ) {
             p.link();
             PropertyInfoImpl old = names.put(p.getName(),p);
             if(old!=null) {
                 builder.reportError(new IllegalAnnotationException(
                     Messages.PROPERTY_COLLISION.format(p.getName()),
                     p, old ));
             }
         }
         super.link();
     }
     public Location getLocation() {
         return nav().getClassLocation(clazz);
     }
     /**
      *  XmlType allows specification of factoryClass and
      *  factoryMethod.  There are to be used if no default
      *  constructor is found.
      *
      * @return
      *      true if the factory method was found. False if not.
      */
     private  boolean hasFactoryConstructor(XmlType t){
         if (t == null) return false;
         String method = t.factoryMethod();
         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))){
                 //- Find the zero-arg public static method with the required return type
                 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;
                 }
             }
             if (factoryMethod == null){
                 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 ));
         }
         return factoryMethod != null;
     }
     public Method getFactoryMethod(){
         return (Method) factoryMethod;
     }
     @Override
     public String toString() {
         return "ClassInfo("+clazz+')';
     }
     private static final String[] DEFAULT_ORDER = new String[0];
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaxws_classes/com/sun/xml/internal/bind/v2/model/impl/ClassInfoImpl.java@9c07ef4934dd (annotated)

src/share/jaxws_classes/com/sun/xml/internal/bind/v2/model/impl/ClassInfoImpl.java