1 /* gnu.classpath.tools.gjdoc.ClassDocReflectedImpl 2 Copyright (C) 2001, 2012 Free Software Foundation, Inc. 3 4 This file is part of GNU Classpath. 5 6 GNU Classpath is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2, or (at your option) 9 any later version. 10 11 GNU Classpath is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GNU Classpath; see the file COPYING. If not, write to the 18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 19 02111-1307 USA. 20 21 Linking this library statically or dynamically with other modules is 22 making a combined work based on this library. Thus, the terms and 23 conditions of the GNU General Public License cover the whole 24 combination. 25 26 As a special exception, the copyright holders of this library give you 27 permission to link this library with independent modules to produce an 28 executable, regardless of the license terms of these independent 29 modules, and to copy and distribute the resulting executable under 30 terms of your choice, provided that you also meet, for each linked 31 independent module, the terms and conditions of the license of that 32 module. An independent module is a module which is not derived from 33 or based on this library. If you modify this library, you may extend 34 this exception to your version of the library, but you are not 35 obligated to do so. If you do not wish to do so, delete this 36 exception statement from your version. */ 37 38 package gnu.classpath.tools.gjdoc; 39 40 import com.sun.javadoc.Doc; 41 import com.sun.javadoc.ClassDoc; 42 import com.sun.javadoc.ConstructorDoc; 43 import com.sun.javadoc.FieldDoc; 44 import com.sun.javadoc.MethodDoc; 45 import com.sun.javadoc.PackageDoc; 46 import com.sun.javadoc.SeeTag; 47 import com.sun.javadoc.SourcePosition; 48 import com.sun.javadoc.Tag; 49 import com.sun.javadoc.TypeVariable; 50 51 import java.util.Map; 52 import java.util.HashMap; 53 54 public class ClassDocReflectedImpl 55 implements ClassDoc, WritableType 56 { 57 private Class clazz; 58 private String name; 59 private ClassDoc superclassDoc; 60 private ClassDoc[] unfilteredInnerClasses; 61 private String dimension = ""; 62 63 private static Map reflectionCache = new HashMap(); 64 newInstance(Class clazz)65 public static ClassDocReflectedImpl newInstance(Class clazz) 66 { 67 ClassDocReflectedImpl result 68 = (ClassDocReflectedImpl)reflectionCache.get(clazz); 69 if (null != result) { 70 return result; 71 } 72 else { 73 return new ClassDocReflectedImpl(clazz); 74 } 75 } 76 ClassDocReflectedImpl(Class clazz)77 public ClassDocReflectedImpl(Class clazz) 78 { 79 reflectionCache.put(clazz, this); 80 81 //System.err.println("ClassDocReflectedImpl: " + clazz); 82 83 this.clazz = clazz; 84 String className = clazz.getName(); 85 int ndx = className.lastIndexOf('.'); 86 if (ndx >= 0) { 87 this.name = className.substring(ndx + 1); 88 } 89 else { 90 this.name = className; 91 } 92 93 Class superclass = clazz.getSuperclass(); 94 if (null != superclass && !clazz.getName().equals("java.lang.Object")) { 95 this.superclassDoc = (ClassDocReflectedImpl)reflectionCache.get(superclass); 96 if (null == this.superclassDoc) { 97 this.superclassDoc = new ClassDocReflectedImpl(superclass); 98 } 99 } 100 101 Class[] innerclasses = clazz.getDeclaredClasses(); 102 this.unfilteredInnerClasses = new ClassDoc[innerclasses.length]; 103 for (int i=0; i<innerclasses.length; ++i) { 104 this.unfilteredInnerClasses[i] = (ClassDocReflectedImpl)reflectionCache.get(innerclasses[i]); 105 if (null == this.unfilteredInnerClasses[i]) { 106 this.unfilteredInnerClasses[i] = new ClassDocReflectedImpl(innerclasses[i]); 107 //System.err.println("adding " + this.unfilteredInnerClasses[i] + " [" + innerclasses[i] + "] as inner class of " + this + " [" + clazz + "]"); 108 } 109 } 110 } 111 constructors()112 public ConstructorDoc[] constructors() { return new ConstructorDoc[0]; } constructors(boolean filtered)113 public ConstructorDoc[] constructors(boolean filtered) { return new ConstructorDoc[0]; } definesSerializableFields()114 public boolean definesSerializableFields() { return false; } fields()115 public FieldDoc[] fields() { return new FieldDoc[0]; } fields(boolean filtered)116 public FieldDoc[] fields(boolean filtered) { return new FieldDoc[0]; } findClass(String className)117 public ClassDoc findClass(String className) { return null; } importedClasses()118 public ClassDoc[] importedClasses() { return new ClassDoc[0]; } importedPackages()119 public PackageDoc[] importedPackages() { return new PackageDoc[0]; } innerClasses()120 public ClassDoc[] innerClasses() { return new ClassDoc[0]; } innerClasses(boolean filtered)121 public ClassDoc[] innerClasses(boolean filtered) 122 { 123 if (filtered) { 124 return new ClassDoc[0]; 125 } 126 else { 127 return unfilteredInnerClasses; 128 } 129 } 130 interfaces()131 public ClassDoc[] interfaces() { return new ClassDoc[0]; } isAbstract()132 public boolean isAbstract() { return false; } isExternalizable()133 public boolean isExternalizable() { return false; } isSerializable()134 public boolean isSerializable() { return false; } methods()135 public MethodDoc[] methods() { return new MethodDoc[0]; } methods(boolean filtered)136 public MethodDoc[] methods(boolean filtered) { return new MethodDoc[0]; } serializableFields()137 public FieldDoc[] serializableFields() { return new FieldDoc[0]; } serializationMethods()138 public MethodDoc[] serializationMethods() { return new MethodDoc[0]; } subclassOf(ClassDoc cd)139 public boolean subclassOf(ClassDoc cd) { return false; } superclass()140 public ClassDoc superclass() { 141 return superclassDoc; 142 } containingClass()143 public ClassDoc containingClass() 144 { 145 Class declaringClass = clazz.getDeclaringClass(); 146 if (null != declaringClass) { 147 return new ClassDocReflectedImpl(declaringClass); 148 } 149 else { 150 return null; 151 } 152 } containingPackage()153 public PackageDoc containingPackage() 154 { 155 Class outerClass = clazz; 156 while (null != outerClass.getDeclaringClass()) { 157 outerClass = outerClass.getDeclaringClass(); 158 } 159 160 String packageName = outerClass.getName(); 161 int ndx = packageName.lastIndexOf('.'); 162 if (ndx > 0) { 163 packageName = packageName.substring(0, ndx); 164 } 165 else { 166 packageName = ""; 167 } 168 PackageDoc result = Main.getRootDoc().findOrCreatePackageDoc(packageName); 169 return result; 170 } 171 isFinal()172 public boolean isFinal() { return false; } isPackagePrivate()173 public boolean isPackagePrivate() { return false; } isPrivate()174 public boolean isPrivate() { return false; } isProtected()175 public boolean isProtected() { return false; } isPublic()176 public boolean isPublic() { return false; } isStatic()177 public boolean isStatic() { return false; } modifiers()178 public String modifiers() { return ""; } modifierSpecifier()179 public int modifierSpecifier() { return 0; } qualifiedName()180 public String qualifiedName() { return clazz.getName().replace('$', '.'); } commentText()181 public String commentText() { return null; } firstSentenceTags()182 public Tag[] firstSentenceTags() { return new Tag[0]; } getRawCommentText()183 public String getRawCommentText() { return null; } inlineTags()184 public Tag[] inlineTags() { return new Tag[0]; } isClass()185 public boolean isClass() { return false; } isConstructor()186 public boolean isConstructor() { return false; } isError()187 public boolean isError() { return false; } isException()188 public boolean isException() { return false; } isField()189 public boolean isField() { return false; } isIncluded()190 public boolean isIncluded() { return false; } isInterface()191 public boolean isInterface() { return false; } isMethod()192 public boolean isMethod() { return false; } isOrdinaryClass()193 public boolean isOrdinaryClass() { return false; } name()194 public String name() { return name; } position()195 public SourcePosition position() { return null; } seeTags()196 public SeeTag[] seeTags() { return new SeeTag[0]; } setRawCommentText(java.lang.String rawDocumentation)197 public void setRawCommentText(java.lang.String rawDocumentation) {} tags()198 public Tag[] tags() { return new Tag[0]; } tags(java.lang.String tagname)199 public Tag[] tags(java.lang.String tagname) { return new Tag[0]; } typeName()200 public String typeName() { return name; } qualifiedTypeName()201 public String qualifiedTypeName() { return qualifiedName(); } asClassDoc()202 public ClassDoc asClassDoc() { return this; } asTypeVariable()203 public TypeVariable asTypeVariable() { return null; } isPrimitive()204 public boolean isPrimitive() { return false; } 205 toString()206 public String toString() { return "ClassDocReflectedImpl{"+qualifiedName()+"}"; } 207 compareTo(Doc d)208 public int compareTo(Doc d) { 209 return Main.getInstance().getCollator().compare(name(), d.name()); 210 } 211 dimension()212 public String dimension() { return dimension; } 213 setDimension(String dimension)214 public void setDimension(String dimension) { 215 this.dimension = dimension; 216 } 217 clone()218 public Object clone() throws CloneNotSupportedException { 219 return super.clone(); 220 } 221 typeParameters()222 public TypeVariable[] typeParameters() { return new TypeVariable[0]; } 223 224 } 225