Java ConstructorDoc类代码示例

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
/**
 * Returns the .
 *
 * @param constructors The constructors.
 * @param node The node to add the XML to.
 */
private static XMLNode toConstructorsNode(ConstructorDoc[] constructors) {
  if (constructors.length < 1) return null;

  // Create the <constructors> node
  XMLNode node = new XMLNode("constructors");

  // Add the <constructor> nodes
  for (ConstructorDoc  constructor : constructors) {
    XMLNode c = new XMLNode("constructor");
    updateExecutableMemberNode(constructor, c);
    node.child(c);
  }

  return node;
}
 

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
private String parseIdentifier(Doc doc) {
  if (doc instanceof ClassDoc) {
    ClassDoc classDoc = (ClassDoc) doc;

    return parseIdentifier((Doc) classDoc.containingPackage()) + classDoc.name() + "/";
  } else if (doc instanceof AnnotationTypeElementDoc) {
    AnnotationTypeElementDoc annotationTypeElementDoc = (AnnotationTypeElementDoc) doc;
    return parseIdentifier((Doc) annotationTypeElementDoc.containingClass()) + "#" + annotationTypeElementDoc.name();
  } else if (doc instanceof FieldDoc) {
    FieldDoc fieldDoc = (FieldDoc) doc;
    return parseIdentifier((Doc) fieldDoc.containingClass()) + "#" + fieldDoc.name();
  } else if (doc instanceof ConstructorDoc) {
    ConstructorDoc constructorDoc = (ConstructorDoc) doc;
    return parseIdentifier((Doc) constructorDoc.containingClass()) + "#" + constructorDoc.name() + URLEncoder.encode(constructorDoc.flatSignature());
  } else if (doc instanceof MethodDoc) {
    MethodDoc methodDoc = (MethodDoc) doc;
    return parseIdentifier((Doc) methodDoc.containingClass()) + "#" + methodDoc.name() + URLEncoder.encode(methodDoc.flatSignature());
  } else {
    return "/" + doc.name() + "/";
  }
}
 

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
/**
 * Returns the .
 *
 * @param constructors The constructors.
 * @param node The node to add the XML to.
 */
private static XMLNode toConstructorsNode(ConstructorDoc[] constructors) {
  if (constructors.length < 1) return null;

  // Create the <constructors> node
  XMLNode node = new XMLNode("constructors");

  // Add the <constructor> nodes
  for (ConstructorDoc  constructor : constructors) {
    XMLNode c = new XMLNode("constructor");
    updateExecutableMemberNode(constructor, c);
    // standard block tags
    c.child(toStandardTags(constructor));
    // deprecated
    toDeprecated(constructor, c);
    node.child(c);
  }

  return node;
}
 

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
private SignatureInformation constructorInfo(ExecutableElement method) {
    Optional<ConstructorDoc> doc = docs.constructorDoc(docs.methodKey(method));
    Optional<String> docText =
            doc.flatMap(constructor -> Optional.ofNullable(constructor.commentText()))
                    .map(Javadocs::htmlToMarkdown)
                    .map(Javadocs::firstSentence);

    return new SignatureInformation(
            Hovers.methodSignature(method, false, true),
            docText.orElse(null),
            paramInfo(method));
}
 

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
protected ConstructorDoc[] getSortedConstructors(ClassDoc classDoc)
{
   ConstructorDoc[] result = (ConstructorDoc[])sortedConstructorMap.get(classDoc);
   if (null == result) {
      ConstructorDoc[] constructors = classDoc.constructors();
      result = (ConstructorDoc[])constructors.clone();
      Arrays.sort(result);
      return result;
   }
   return result;
}
 

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
private boolean hasMethods(ClassDoc clz) {
  int countExportedMethods = 0;
  for (ConstructorDoc cd : clz.constructors()) {
    if (isExportable(cd)) {
      countExportedMethods++;
    }
  }
  for (MethodDoc md : clz.methods()) {
    if (isExportable(md)) {
      countExportedMethods++;
    }
  }
  return countExportedMethods > 0;
}
 

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
private boolean isExportable(ConstructorDoc cd) {
  boolean export = isExported(cd.containingClass());
  for (AnnotationDesc a : cd.annotations()) {
    if (a.annotationType().name().equals("Export")) {
      export = true;
    }
    if (a.annotationType().name().equals("NoExport")) {
      export = false;
    }
  }
  return export;
}
 

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
/**
 * @return full JSON objects for the given ConstructorDoc[]
 */
protected JSONArray processConstructorDocs(ConstructorDoc[] constructorDocs) {
    JSONArray retMe = new JSONArray();
    for (ConstructorDoc constructorDoc: constructorDocs) {
        retMe.add( processConstructorDoc( constructorDoc ) );
    }
    return retMe;
}
 

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
/**
 * @return JSON stubs for the given ConstructorDoc[].
 */
protected JSONArray processConstructorDocStubs(ConstructorDoc[] constructorDocs) {
    JSONArray retMe = new JSONArray();
    for (ConstructorDoc constructorDoc: constructorDocs) {
        retMe.add( processConstructorDocStub( constructorDoc ) );
    }
    return retMe;
}
 

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
int process(Parser parser, char[] source, int startIndex, int endIndex) throws IOException, ParseException {

         //ctx.fieldList.add(FieldDocImpl.createFromSource(source, startIndex, endIndex));

         //System.out.println("function match '"+new String(source,startIndex,endIndex-startIndex)+"'");
         ExecutableMemberDocImpl execDoc=MethodDocImpl.createFromSource(parser.ctx.classDoc,
                                                                        parser.ctx.classDoc.containingPackage(),
                                                                        source, startIndex, endIndex);

         if (parser.getAddComments())
            execDoc.setRawCommentText(parser.getLastComment());

         parser.setLastComment(null);

         if (execDoc.isMethod()) {
            MethodDoc methDoc = (MethodDoc) execDoc;
            parser.ctx.methodList.add(methDoc);
            if (methDoc.isIncluded()) {
               parser.ctx.filteredMethodList.add(methDoc);
            }
            if (methDoc.name().equals("readObject")
                      || methDoc.name().equals("writeObject")
                      || methDoc.name().equals("readExternal")
                      || methDoc.name().equals("writeExternal")
                      || methDoc.name().equals("readResolve")) {
           // FIXME: add readExternal here?

            parser.ctx.maybeSerMethodList.add(methDoc);
           }
         } else {
             ConstructorDoc constDoc = (ConstructorDoc) execDoc;
             parser.ctx.constructorList.add(constDoc);
             if (constDoc.isIncluded()) {
               parser.ctx.filteredConstructorList.add(constDoc);
             }
         }

         return endIndex;
      }
 

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
void classClosed() throws ParseException, IOException {
   ctx.classDoc.setFields(toArray(ctx.fieldList,new FieldDoc[ctx.fieldList.size()]));
   ctx.classDoc.setFilteredFields(toArray(ctx.filteredFieldList,new FieldDoc[ctx.filteredFieldList.size()]));
   ctx.classDoc.setSerializableFields(toArray(ctx.sfieldList, new FieldDoc[ctx.sfieldList.size()]));
   ctx.classDoc.setMethods(toArray(ctx.methodList, new MethodDoc[ctx.methodList.size()]));
   ctx.classDoc.setFilteredMethods(toArray(ctx.filteredMethodList, new MethodDoc[ctx.filteredMethodList.size()]));
   ctx.classDoc.setMaybeSerMethodList(ctx.maybeSerMethodList);
   ctx.classDoc.setConstructors(toArray(ctx.constructorList, new ConstructorDoc[ctx.constructorList.size()]));
   ctx.classDoc.setFilteredConstructors(toArray(ctx.filteredConstructorList,
                                                new ConstructorDoc[ctx.filteredConstructorList.size()]));
   ctx.classDoc.setInnerClasses(toArray(ctx.innerClassesList, new ClassDocImpl[ctx.innerClassesList.size()]));
   ctx.classDoc.setFilteredInnerClasses(toArray(ctx.filteredInnerClassesList,
                                                new ClassDocImpl[ctx.filteredInnerClassesList.size()]));
   ctx.classDoc.setBoilerplateComment(boilerplateComment);

   Main.getRootDoc().addClassDoc(ctx.classDoc);

   if (Main.DESCEND_INTERFACES) {
      for (int i=0; i<ctx.classDoc.interfaces().length; ++i) {
         Main.getRootDoc().scheduleClass(ctx.classDoc, ctx.classDoc.interfaces()[i].qualifiedName());
      }
   }

   Debug.log(1,"classClosed: "+ctx.classDoc);

   ctx=(Context)contextStack.pop();
   Debug.log(1, "Popping " + ctx);
   ClassDoc[] referencedClasses=(ClassDoc[])referencedClassesList.toArray(new ClassDoc[0]);

   if (Main.DESCEND_SUPERCLASS) {
      for (int i=0; i<referencedClasses.length; ++i) {
         Main.getRootDoc().scheduleClass(currentClass, referencedClasses[i].qualifiedName());
      }
   }
}
 

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
public String getSignature(Doc doc)
{
    if (doc instanceof MethodDoc)
    {
        return doc.name() + ((MethodDoc) doc).signature();
    } else if (doc instanceof FieldDoc)
    {
        return doc.name();
    } else if (doc instanceof ConstructorDoc)
    {
        return doc.name() + ((ConstructorDoc) doc).signature();
    }
    return doc.name();
}
 

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
public String getSignature(Doc doc)
{
    if (doc instanceof MethodDoc)
    {
        return doc.name() + ((MethodDoc) doc).signature();
    } else if (doc instanceof FieldDoc)
    {
        return doc.name();
    } else if (doc instanceof ConstructorDoc)
    {
        return doc.name() + ((ConstructorDoc) doc).signature();
    }
    return "";
}
 

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
public ConstructorDoc[] getConstructors()
{
    ClassDoc doc = (ClassDoc) getVariables().get("curitem");
    ConstructorDoc[] docs = doc.constructors(false);
    // constructors are not inherited.
    // we show private constructors as this is useful info.
    Arrays.sort(docs);
    return docs;
}
 

import com.sun.javadoc.ConstructorDoc; //导入依赖的package包/类
public String getParamString(ConstructorDoc doc)
{
    String str = "(";
    Parameter[] params = doc.parameters();
    str = str + processParams(params);
    str += ")";
    return str;
}