Mercurial > jdk8-mips64-public > langtools / file revision

 /*

  * Copyright (c) 1999, 2016, 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.tools.doclets.internal.toolkit.util;

 import java.util.*;

 import java.util.regex.Pattern;

 import com.sun.javadoc.*;

 import com.sun.tools.doclets.internal.toolkit.*;

 /**

  * A data structure that encapsulates the visible members of a particular

  * type for a given class tree.  To use this data structor, you must specify

  * the type of member you are interested in (nested class, field, constructor

  * or method) and the leaf of the class tree.  The data structure will map

  * all visible members in the leaf and classes above the leaf in the tree.

  *

  *  <p><b>This is NOT part of any supported API.

  *  If you write code that depends on this, you do so at your own risk.

  *  This code and its internal interfaces are subject to change or

  *  deletion without notice.</b>

  *

  * @author Atul M Dambalkar

  * @author Jamie Ho (rewrite)

  */

 public class VisibleMemberMap {

     private boolean noVisibleMembers = true;

     public static final int INNERCLASSES    = 0;

     public static final int ENUM_CONSTANTS  = 1;

     public static final int FIELDS          = 2;

     public static final int CONSTRUCTORS    = 3;

     public static final int METHODS         = 4;

     public static final int ANNOTATION_TYPE_FIELDS = 5;

     public static final int ANNOTATION_TYPE_MEMBER_OPTIONAL = 6;

     public static final int ANNOTATION_TYPE_MEMBER_REQUIRED = 7;

     public static final int PROPERTIES      = 8;

     /**

      * The total number of member types is {@value}.

      */

     public static final int NUM_MEMBER_TYPES = 9;

     public static final String STARTLEVEL = "start";

     /**

      * List of ClassDoc objects for which ClassMembers objects are built.

      */

     private final List<ClassDoc> visibleClasses = new ArrayList<ClassDoc>();

     /**

      * Map for each member name on to a map which contains members with same

      * name-signature. The mapped map will contain mapping for each MemberDoc

      * onto it's respecive level string.

      */

     private final Map<Object,Map<ProgramElementDoc,String>> memberNameMap = new HashMap<Object,Map<ProgramElementDoc,String>>();

     /**

      * Map of class and it's ClassMembers object.

      */

     private final Map<ClassDoc,ClassMembers> classMap = new HashMap<ClassDoc,ClassMembers>();

     /**

      * Type whose visible members are requested.  This is the leaf of

      * the class tree being mapped.

      */

     private final ClassDoc classdoc;

     /**

      * Member kind: InnerClasses/Fields/Methods?

      */

     private final int kind;

     /**

      * The configuration this VisibleMemberMap was created with.

      */

     private final Configuration configuration;

     private static final Map<ClassDoc, ProgramElementDoc[]> propertiesCache =

             new HashMap<ClassDoc, ProgramElementDoc[]>();

     private static final Map<ProgramElementDoc, ProgramElementDoc> classPropertiesMap =

             new HashMap<ProgramElementDoc, ProgramElementDoc>();

     private static final Map<ProgramElementDoc, GetterSetter> getterSetterMap =

             new HashMap<ProgramElementDoc, GetterSetter>();

     /**

      * Construct a VisibleMemberMap of the given type for the given

      * class.

      *

      * @param classdoc the class whose members are being mapped.

      * @param kind the kind of member that is being mapped.

      * @param configuration the configuration to use to construct this

      * VisibleMemberMap. If the field configuration.nodeprecated is true the

      * deprecated members are excluded from the map. If the field

      * configuration.javafx is true the JavaFX features are used.

      */

     public VisibleMemberMap(ClassDoc classdoc,

                             int kind,

                             Configuration configuration) {

         this.classdoc = classdoc;

         this.kind = kind;

         this.configuration = configuration;

         new ClassMembers(classdoc, STARTLEVEL).build();

     }

     /**

      * Return the list of visible classes in this map.

      *

      * @return the list of visible classes in this map.

      */

     public List<ClassDoc> getVisibleClassesList() {

         sort(visibleClasses);

         return visibleClasses;

     }

     /**

      * Returns the property field documentation belonging to the given member.

      * @param ped the member for which the property documentation is needed.

      * @return the property field documentation, null if there is none.

      */

     public ProgramElementDoc getPropertyMemberDoc(ProgramElementDoc ped) {

         return classPropertiesMap.get(ped);

     }

     /**

      * Returns the getter documentation belonging to the given property method.

      * @param propertyMethod the method for which the getter is needed.

      * @return the getter documentation, null if there is none.

      */

     public ProgramElementDoc getGetterForProperty(ProgramElementDoc propertyMethod) {

         return getterSetterMap.get(propertyMethod).getGetter();

     }

     /**

      * Returns the setter documentation belonging to the given property method.

      * @param propertyMethod the method for which the setter is needed.

      * @return the setter documentation, null if there is none.

      */

     public ProgramElementDoc getSetterForProperty(ProgramElementDoc propertyMethod) {

         return getterSetterMap.get(propertyMethod).getSetter();

     }

     /**

      * Return the package private members inherited by the class.  Only return

      * if parent is package private and not documented.

      *

      * @param configuration the current configuration of the doclet.

      * @return the package private members inherited by the class.

      */

     private List<ProgramElementDoc> getInheritedPackagePrivateMethods(Configuration configuration) {

         List<ProgramElementDoc> results = new ArrayList<ProgramElementDoc>();

         for (Iterator<ClassDoc> iter = visibleClasses.iterator(); iter.hasNext(); ) {

             ClassDoc currentClass = iter.next();

             if (currentClass != classdoc &&

                 currentClass.isPackagePrivate() &&

                 !Util.isLinkable(currentClass, configuration)) {

                 // Document these members in the child class because

                 // the parent is inaccessible.

                 results.addAll(getMembersFor(currentClass));

             }

         }

         return results;

     }

     /**

      * Return the visible members of the class being mapped.  Also append at the

      * end of the list members that are inherited by inaccessible parents. We

      * document these members in the child because the parent is not documented.

      *

      * @param configuration the current configuration of the doclet.

      */

     public List<ProgramElementDoc> getLeafClassMembers(Configuration configuration) {

         List<ProgramElementDoc> result = getMembersFor(classdoc);

         result.addAll(getInheritedPackagePrivateMethods(configuration));

         return result;

     }

     /**

      * Retrn the list of members for the given class.

      *

      * @param cd the class to retrieve the list of visible members for.

      *

      * @return the list of members for the given class.

      */

     public List<ProgramElementDoc> getMembersFor(ClassDoc cd) {

         ClassMembers clmembers = classMap.get(cd);

         if (clmembers == null) {

             return new ArrayList<ProgramElementDoc>();

         }

         return clmembers.getMembers();

     }

     /**

      * Sort the given mixed list of classes and interfaces to a list of

      * classes followed by interfaces traversed. Don't sort alphabetically.

      */

     private void sort(List<ClassDoc> list) {

         List<ClassDoc> classes = new ArrayList<ClassDoc>();

         List<ClassDoc> interfaces = new ArrayList<ClassDoc>();

         for (int i = 0; i < list.size(); i++) {

             ClassDoc cd = list.get(i);

             if (cd.isClass()) {

                 classes.add(cd);

             } else {

                 interfaces.add(cd);

             }

         }

         list.clear();

         list.addAll(classes);

         list.addAll(interfaces);

     }

     private void fillMemberLevelMap(List<ProgramElementDoc> list, String level) {

         for (int i = 0; i < list.size(); i++) {

             Object key = getMemberKey(list.get(i));

             Map<ProgramElementDoc,String> memberLevelMap = memberNameMap.get(key);

             if (memberLevelMap == null) {

                 memberLevelMap = new HashMap<ProgramElementDoc,String>();

                 memberNameMap.put(key, memberLevelMap);

             }

             memberLevelMap.put(list.get(i), level);

         }

     }

     private void purgeMemberLevelMap(List<ProgramElementDoc> list, String level) {

         for (int i = 0; i < list.size(); i++) {

             Object key = getMemberKey(list.get(i));

             Map<ProgramElementDoc, String> memberLevelMap = memberNameMap.get(key);

             if (memberLevelMap != null && level.equals(memberLevelMap.get(list.get(i))))

                 memberLevelMap.remove(list.get(i));

         }

     }

     /**

      * Represents a class member.  We should be able to just use a

      * ProgramElementDoc instead of this class, but that doesn't take

      * type variables in consideration when comparing.

      */

     private class ClassMember {

         private Set<ProgramElementDoc> members;

         public ClassMember(ProgramElementDoc programElementDoc) {

             members = new HashSet<ProgramElementDoc>();

             members.add(programElementDoc);

         }

         public void addMember(ProgramElementDoc programElementDoc) {

             members.add(programElementDoc);

         }

         public boolean isEqual(MethodDoc member) {

             for (Iterator<ProgramElementDoc> iter = members.iterator(); iter.hasNext(); ) {

                 MethodDoc member2 = (MethodDoc) iter.next();

                 if (Util.executableMembersEqual(member, member2)) {

                     members.add(member);

                         return true;

                 }

             }

             return false;

         }

     }

     /**

      * A data structure that represents the class members for

      * a visible class.

      */

     private class ClassMembers {

         /**

          * The mapping class, whose inherited members are put in the

          * {@link #members} list.

          */

         private ClassDoc mappingClass;

         /**

          * List of inherited members from the mapping class.

          */

         private List<ProgramElementDoc> members = new ArrayList<ProgramElementDoc>();

         /**

          * Level/Depth of inheritance.

          */

         private String level;

         /**

          * Return list of inherited members from mapping class.

          *

          * @return List Inherited members.

          */

         public List<ProgramElementDoc> getMembers() {

             return members;

         }

         private ClassMembers(ClassDoc mappingClass, String level) {

             this.mappingClass = mappingClass;

             this.level = level;

             if (classMap.containsKey(mappingClass) &&

                         level.startsWith(classMap.get(mappingClass).level)) {

                 //Remove lower level class so that it can be replaced with

                 //same class found at higher level.

                 purgeMemberLevelMap(getClassMembers(mappingClass, false),

                     classMap.get(mappingClass).level);

                 classMap.remove(mappingClass);

                 visibleClasses.remove(mappingClass);

             }

             if (!classMap.containsKey(mappingClass)) {

                 classMap.put(mappingClass, this);

                 visibleClasses.add(mappingClass);

             }

         }

         private void build() {

             if (kind == CONSTRUCTORS) {

                 addMembers(mappingClass);

             } else {

                 mapClass();

             }

         }

         private void mapClass() {

             addMembers(mappingClass);

             ClassDoc[] interfaces = mappingClass.interfaces();

             for (int i = 0; i < interfaces.length; i++) {

                 String locallevel = level + 1;

                 ClassMembers cm = new ClassMembers(interfaces[i], locallevel);

                 cm.mapClass();

             }

             if (mappingClass.isClass()) {

                 ClassDoc superclass = mappingClass.superclass();

                 if (!(superclass == null || mappingClass.equals(superclass))) {

                     ClassMembers cm = new ClassMembers(superclass,

                                                        level + "c");

                     cm.mapClass();

                 }

             }

         }

         /**

          * Get all the valid members from the mapping class. Get the list of

          * members for the class to be included into(ctii), also get the level

          * string for ctii. If mapping class member is not already in the

          * inherited member list and if it is visible in the ctii and not

          * overridden, put such a member in the inherited member list.

          * Adjust member-level-map, class-map.

          */

         private void addMembers(ClassDoc fromClass) {

             List<ProgramElementDoc> cdmembers = getClassMembers(fromClass, true);

             List<ProgramElementDoc> incllist = new ArrayList<ProgramElementDoc>();

             for (int i = 0; i < cdmembers.size(); i++) {

                 ProgramElementDoc pgmelem = cdmembers.get(i);

                 if (!found(members, pgmelem) &&

                     memberIsVisible(pgmelem) &&

                     !isOverridden(pgmelem, level) &&

                     !isTreatedAsPrivate(pgmelem)) {

                         incllist.add(pgmelem);

                 }

             }

             if (incllist.size() > 0) {

                 noVisibleMembers = false;

             }

             members.addAll(incllist);

             fillMemberLevelMap(getClassMembers(fromClass, false), level);

         }

         private boolean isTreatedAsPrivate(ProgramElementDoc pgmelem) {

             if (!configuration.javafx) {

                 return false;

             }

             Tag[] aspTags = pgmelem.tags("@treatAsPrivate");

             boolean result = (aspTags != null) && (aspTags.length > 0);

             return result;

         }

         /**

          * Is given doc item visible in given classdoc in terms fo inheritance?

          * The given doc item is visible in the given classdoc if it is public

          * or protected and if it is package-private if it's containing class

          * is in the same package as the given classdoc.

          */

         private boolean memberIsVisible(ProgramElementDoc pgmdoc) {

             if (pgmdoc.containingClass().equals(classdoc)) {

                 //Member is in class that we are finding visible members for.

                 //Of course it is visible.

                 return true;

             } else if (pgmdoc.isPrivate()) {

                 //Member is in super class or implemented interface.

                 //Private, so not inherited.

                 return false;

             } else if (pgmdoc.isPackagePrivate()) {

                 //Member is package private.  Only return true if its class is in

                 //same package.

                 return pgmdoc.containingClass().containingPackage().equals(

                     classdoc.containingPackage());

             } else {

                 //Public members are always inherited.

                 return true;

             }

         }

         /**

          * Return all available class members.

          */

         private List<ProgramElementDoc> getClassMembers(ClassDoc cd, boolean filter) {

             if (cd.isEnum() && kind == CONSTRUCTORS) {

                 //If any of these rules are hit, return empty array because

                 //we don't document these members ever.

                 return Arrays.asList(new ProgramElementDoc[] {});

             }

             ProgramElementDoc[] members = null;

             switch (kind) {

                 case ANNOTATION_TYPE_FIELDS:

                     members = cd.fields(filter);

                     break;

                 case ANNOTATION_TYPE_MEMBER_OPTIONAL:

                     members = cd.isAnnotationType() ?

                         filter((AnnotationTypeDoc) cd, false) :

                         new AnnotationTypeElementDoc[] {};

                     break;

                 case ANNOTATION_TYPE_MEMBER_REQUIRED:

                     members = cd.isAnnotationType() ?

                         filter((AnnotationTypeDoc) cd, true) :

                         new AnnotationTypeElementDoc[] {};

                     break;

                 case INNERCLASSES:

                     members = cd.innerClasses(filter);

                     break;

                 case ENUM_CONSTANTS:

                     members = cd.enumConstants();

                     break;

                 case FIELDS:

                     members = cd.fields(filter);

                     break;

                 case CONSTRUCTORS:

                     members = cd.constructors();

                     break;

                 case METHODS:

                     members = cd.methods(filter);

                     checkOnPropertiesTags((MethodDoc[])members);

                     break;

                 case PROPERTIES:

                     members = properties(cd, filter);

                     break;

                 default:

                     members = new ProgramElementDoc[0];

             }

             // Deprected members should be excluded or not?

             if (configuration.nodeprecated) {

                 return Util.excludeDeprecatedMembersAsList(members);

             }

             return Arrays.asList(members);

         }

         /**

          * Filter the annotation type members and return either the required

          * members or the optional members, depending on the value of the

          * required parameter.

          *

          * @param doc The annotation type to process.

          * @param required

          * @return the annotation type members and return either the required

          * members or the optional members, depending on the value of the

          * required parameter.

          */

         private AnnotationTypeElementDoc[] filter(AnnotationTypeDoc doc,

             boolean required) {

             AnnotationTypeElementDoc[] members = doc.elements();

             List<AnnotationTypeElementDoc> targetMembers = new ArrayList<AnnotationTypeElementDoc>();

             for (int i = 0; i < members.length; i++) {

                 if ((required && members[i].defaultValue() == null) ||

                      ((!required) && members[i].defaultValue() != null)){

                     targetMembers.add(members[i]);

                 }

             }

             return targetMembers.toArray(new AnnotationTypeElementDoc[]{});

         }

         private boolean found(List<ProgramElementDoc> list, ProgramElementDoc elem) {

             for (int i = 0; i < list.size(); i++) {

                 ProgramElementDoc pgmelem = list.get(i);

                 if (Util.matches(pgmelem, elem)) {

                     return true;

                 }

             }

             return false;

         }

         /**

          * Is member overridden? The member is overridden if it is found in the

          * same level hierarchy e.g. member at level "11" overrides member at

          * level "111".

          */

         private boolean isOverridden(ProgramElementDoc pgmdoc, String level) {

             Map<?,String> memberLevelMap = (Map<?,String>) memberNameMap.get(getMemberKey(pgmdoc));

             if (memberLevelMap == null)

                 return false;

             String mappedlevel = null;

             Iterator<String> iterator = memberLevelMap.values().iterator();

             while (iterator.hasNext()) {

                 mappedlevel = iterator.next();

                 if (mappedlevel.equals(STARTLEVEL) ||

                     (level.startsWith(mappedlevel) &&

                      !level.equals(mappedlevel))) {

                     return true;

                 }

             }

             return false;

         }

         private ProgramElementDoc[] properties(final ClassDoc cd, final boolean filter) {

             final MethodDoc[] allMethods = cd.methods(filter);

             final FieldDoc[] allFields = cd.fields(false);

             if (propertiesCache.containsKey(cd)) {

                 return propertiesCache.get(cd);

             }

             final List<MethodDoc> result = new ArrayList<MethodDoc>();

             for (final MethodDoc propertyMethod : allMethods) {

                 if (!isPropertyMethod(propertyMethod)) {

                     continue;

                 }

                 final MethodDoc getter = getterForField(allMethods, propertyMethod);

                 final MethodDoc setter = setterForField(allMethods, propertyMethod);

                 final FieldDoc field = fieldForProperty(allFields, propertyMethod);

                 addToPropertiesMap(setter, getter, propertyMethod, field);

                 getterSetterMap.put(propertyMethod, new GetterSetter(getter, setter));

                 result.add(propertyMethod);

             }

             final ProgramElementDoc[] resultAray =

                     result.toArray(new ProgramElementDoc[result.size()]);

             propertiesCache.put(cd, resultAray);

             return resultAray;

         }

         private void addToPropertiesMap(MethodDoc setter,

                                         MethodDoc getter,

                                         MethodDoc propertyMethod,

                                         FieldDoc field) {

             if ((field == null)

                     || (field.getRawCommentText() == null)

                     || field.getRawCommentText().length() == 0) {

                 addToPropertiesMap(setter, propertyMethod);

                 addToPropertiesMap(getter, propertyMethod);

                 addToPropertiesMap(propertyMethod, propertyMethod);

             } else {

                 addToPropertiesMap(getter, field);

                 addToPropertiesMap(setter, field);

                 addToPropertiesMap(propertyMethod, field);

             }

         }

         private void addToPropertiesMap(ProgramElementDoc propertyMethod,

                                         ProgramElementDoc commentSource) {

             if (null == propertyMethod || null == commentSource) {

                 return;

             }

             final String methodRawCommentText = propertyMethod.getRawCommentText();

             /* The second condition is required for the property buckets. In

              * this case the comment is at the property method (not at the field)

              * and it needs to be listed in the map.

              */

             if ((null == methodRawCommentText || 0 == methodRawCommentText.length())

                     || propertyMethod.equals(commentSource)) {

                 classPropertiesMap.put(propertyMethod, commentSource);

             }

         }

         private MethodDoc getterForField(MethodDoc[] methods,

                                          MethodDoc propertyMethod) {

             final String propertyMethodName = propertyMethod.name();

             final String fieldName =

                     propertyMethodName.substring(0,

                             propertyMethodName.lastIndexOf("Property"));

             final String fieldNameUppercased =

                     "" + Character.toUpperCase(fieldName.charAt(0))

                                             + fieldName.substring(1);

             final String getterNamePattern;

             final String fieldTypeName = propertyMethod.returnType().toString();

             if ("boolean".equals(fieldTypeName)

                     || fieldTypeName.endsWith("BooleanProperty")) {

                 getterNamePattern = "(is|get)" + fieldNameUppercased;

             } else {

                 getterNamePattern = "get" + fieldNameUppercased;

             }

             for (MethodDoc methodDoc : methods) {

                 if (Pattern.matches(getterNamePattern, methodDoc.name())) {

                     if (0 == methodDoc.parameters().length

                             && (methodDoc.isPublic() || methodDoc.isProtected())) {

                         return methodDoc;

                     }

                 }

             }

             return null;

         }

         private MethodDoc setterForField(MethodDoc[] methods,

                                          MethodDoc propertyMethod) {

             final String propertyMethodName = propertyMethod.name();

             final String fieldName =

                     propertyMethodName.substring(0,

                             propertyMethodName.lastIndexOf("Property"));

             final String fieldNameUppercased =

                     "" + Character.toUpperCase(fieldName.charAt(0))

                                              + fieldName.substring(1);

             final String setter = "set" + fieldNameUppercased;

             for (MethodDoc methodDoc : methods) {

                 if (setter.equals(methodDoc.name())) {

                     if (1 == methodDoc.parameters().length

                             && "void".equals(methodDoc.returnType().simpleTypeName())

                             && (methodDoc.isPublic() || methodDoc.isProtected())) {

                         return methodDoc;

                     }

                 }

             }

             return null;

         }

         private FieldDoc fieldForProperty(FieldDoc[] fields, MethodDoc property) {

             for (FieldDoc field : fields) {

                 final String fieldName = field.name();

                 final String propertyName = fieldName + "Property";

                 if (propertyName.equals(property.name())) {

                     return field;

                 }

             }

             return null;

         }

         // properties aren't named setA* or getA*

         private final Pattern pattern = Pattern.compile("[sg]et\\p{Upper}.*");

         private boolean isPropertyMethod(MethodDoc method) {

             if (!method.name().endsWith("Property")) {

                 return false;

             }

             if (! memberIsVisible(method)) {

                 return false;

             }

             if (pattern.matcher(method.name()).matches()) {

                 return false;

             }

             return 0 == method.parameters().length

                     && !"void".equals(method.returnType().simpleTypeName());

         }

         private void checkOnPropertiesTags(MethodDoc[] members) {

             for (MethodDoc methodDoc: members) {

                 if (methodDoc.isIncluded()) {

                     for (Tag tag: methodDoc.tags()) {

                         String tagName = tag.name();

                         if (tagName.equals("@propertySetter")

                                 || tagName.equals("@propertyGetter")

                                 || tagName.equals("@propertyDescription")) {

                             if (!isPropertyGetterOrSetter(members, methodDoc)) {

                                 configuration.message.warning(tag.position(),

                                         "doclet.javafx_tag_misuse");

                             }

                             break;

                         }

                     }

                 }

             }

         }

         private boolean isPropertyGetterOrSetter(MethodDoc[] members,

                                                  MethodDoc methodDoc) {

             boolean found = false;

             String propertyName = Util.propertyNameFromMethodName(configuration, methodDoc.name());

             if (!propertyName.isEmpty()) {

                 String propertyMethodName = propertyName + "Property";

                 for (MethodDoc member: members) {

                     if (member.name().equals(propertyMethodName)) {

                         found = true;

                         break;

                     }

                 }

             }

             return found;

         }

     }

     private class GetterSetter {

         private final ProgramElementDoc getter;

         private final ProgramElementDoc setter;

         public GetterSetter(ProgramElementDoc getter, ProgramElementDoc setter) {

             this.getter = getter;

             this.setter = setter;

         }

         public ProgramElementDoc getGetter() {

             return getter;

         }

         public ProgramElementDoc getSetter() {

             return setter;

         }

     }

     /**

      * Return true if this map has no visible members.

      *

      * @return true if this map has no visible members.

      */

     public boolean noVisibleMembers() {

         return noVisibleMembers;

     }

     private ClassMember getClassMember(MethodDoc member) {

         for (Iterator<?> iter = memberNameMap.keySet().iterator(); iter.hasNext();) {

             Object key = iter.next();

             if (key instanceof String) {

                 continue;

             } else if (((ClassMember) key).isEqual(member)) {

                 return (ClassMember) key;

             }

         }

         return new ClassMember(member);

     }

     /**

      * Return the key to the member map for the given member.

      */

     private Object getMemberKey(ProgramElementDoc doc) {

         if (doc.isConstructor()) {

             return doc.name() + ((ExecutableMemberDoc)doc).signature();

         } else if (doc.isMethod()) {

             return getClassMember((MethodDoc) doc);

         } else if (doc.isField() || doc.isEnumConstant() || doc.isAnnotationTypeElement()) {

             return doc.name();

         } else { // it's a class or interface

             String classOrIntName = doc.name();

             //Strip off the containing class name because we only want the member name.

             classOrIntName = classOrIntName.indexOf('.') != 0 ? classOrIntName.substring(classOrIntName.lastIndexOf('.'), classOrIntName.length()) : classOrIntName;

             return "clint" + classOrIntName;

         }

     }

 }