<% def title = classDoc.name() + (props.docTitle ? " (${props.docTitle})" : "") def isVisible = { it.isPublic() || (it.isProtected() && props.protectedScope == 'true') || (!it.isProtected() && !it.isPrivate() && props.packageScope == 'true') || props.privateScope == 'true' } def isVisibleExt = { t -> java.lang.reflect.Modifier.isPublic(t.modifiers) || java.lang.reflect.Modifier.isProtected(t.modifiers) } def visibleFields = classDoc.fields().findAll(isVisible) def visibleProperties = classDoc.properties() // props visible be defn def visibleMethods = classDoc.methods().findAll(isVisible) def visibleConstructors = classDoc.constructors().findAll(isVisible) def visibleNested = classDoc.innerClasses().findAll(isVisible) boolean hasFields = !classDoc.isAnnotationType() && visibleFields boolean hasProperties = !classDoc.isAnnotationType() && visibleProperties boolean hasElements = classDoc.isAnnotationType() && visibleFields boolean methodSummaryShown = visibleMethods boolean fieldSummaryShown = hasFields boolean hasEnumConstants = classDoc.enumConstants() def dolink = { t, boolean b -> boolean isArray = false if (!t || t instanceof String) { return classDoc.getDocUrl(t, b) } if (t instanceof org.codehaus.groovy.tools.groovydoc.ArrayClassDocWrapper) { t = t.delegate isArray = true } if (t instanceof org.codehaus.groovy.tools.groovydoc.SimpleGroovyClassDoc) { if (t.fullPathName == 'def') return classDoc.getDocUrl("java.lang.Object def", b) if (!t.qualifiedTypeName().contains("<") && t.name().size() > 1) return "" + (b ? t.qualifiedTypeName() : t.name()) + "" + (isArray ? "[]" : "") } return classDoc.getDocUrl(t.qualifiedTypeName(), b) + (isArray ? "[]" : "") } def linkfull = { t -> dolink(t, true) } def linkable = { t -> dolink(t, false) } def modifiersWithOptions = { t, boolean ignorePublic, boolean ignoreAbstract -> (t.isPrivate()?"private ":"") + (t.isPublic() && !ignorePublic?"public ":"") + (t.isProtected()?"protected ":"") + (t.isStatic()?"static ":"") + (t.isFinal()?"final ":"") + (!ignoreAbstract && t.respondsTo('isAbstract') && t.isAbstract()?"abstract ":"") } def modifiers = { t -> modifiersWithOptions(t, classDoc.isGroovy(), false) } def modifiersBrief = { t -> (t.isPrivate()?"private ":"") + (t.isProtected()?"protected ":"") + (t.isStatic()?"static ":"") } def annotations = { t, sepChar -> t.annotations() ? t.annotations().collect{ it.isTypeAvailable()?'@'+linkable(it.type().typeName())+it.description():it.description()}.join(sepChar) + sepChar : '' } def elementTypes = [ "required":"true", "optional":"false" ] def isRequired = { f, v -> def req = f.constantValueExpression() == null; req.toString() == v } def upcase = { n -> n[0].toUpperCase() + n[1..-1] } def paramsOf = { n, boolean brief -> n.parameters().collect{ param -> (brief?'':annotations(param, ' ')) + linkable(param.isTypeAvailable()?param.type():param.typeName()) + (param.vararg()?'... ':' ') + param.name() + (param.defaultValue() ? " = " + param.defaultValue():"") }.join(", ") } def rawType = { n -> def g = n.indexOf("<"); g >= 0 ? n.substring(0, g) : n } def nameFromParams = { n -> n.name() + '(' + n.parameters().collect{ param -> rawType(param.isTypeAvailable()?param.type().qualifiedTypeName():param.typeName()) }.join(', ') + ')' } def nameFromJavaParams = { n -> n.getName() + '(' + n.parameterTypes.collect{ param -> param.getName() }.join(', ') + ')' } %> ${title} <% if (props.timestamp != 'false') { %><% } %>
<% def pkg = classDoc.containingPackage().nameWithDots() def name = classDoc.getNameWithTypeArgs() ?: classDoc.name() final nameEncoded = org.codehaus.groovy.tools.groovydoc.SimpleGroovyClassDoc.encodeAngleBrackets(name) String classDesc = "${classDoc.isGroovy() ? "[Groovy]" : "[Java]"} ${classDoc.typeDescription} $nameEncoded" if (pkg != "DefaultPackage") { %>
Package: ${pkg}
<%}%>

${classDesc}