Groovy API Manual

Method

• addProperty(String, int, ClassNode, Expression, Statement, Statement)
• assertStatement(Closure)
• accept_v_AllChildren_v(GroovySourceAST)
• actionPerformed(ActionEvent)
• alignGenericTypes(GenericsType, GenericsType, GenericsType)
• addObjectInitializerStatements(Statement)
• asUnwrappedArray(Object)
• beforeMethodCall(MethodCall)
• addStaticImport(String, String, String)
• asList(Iterable<T>)
• addAttributeDelegate(Closure)
• addPropertyChangeListener(String, PropertyChangeListener)
• and(Boolean, Boolean)
• accept_FirstChild_v_RestOfTheChildren_v_LastChild(GroovySourceAST)
• add(GroovyParameter)
• addCell(TableLayoutCell)
• addString(ConstantExpression)
• addChar(char)
• assertNodeType(int, AST)
• addGroovyObjectInterfaceAndMethods(ClassNode, String)
• addNewPhaseOperation(CompilationUnit.SourceUnitOperation, int)
• beforeVisitClass(ClassNode)
• annotationField()
• addLoggerFieldToClass(ClassNode, String, String)
• asBoolean(Matcher)
• addError(String, ASTNode)
• asConstantString()
• addFireMethods(SourceUnit, AnnotationNode, ClassNode, FieldNode, GenericsType, boolean, MethodNode)
• addCompilationCustomizers(CompilationCustomizer)
• addBigDecimal(BigDecimal)
• bigDecimalValue()
• addNull()
• addTextToNode()
• addClosureColumn(Object, Closure, Closure, Class)
• addInnerClass(ClassNode)
• beforeVisitClass(ClassNode)
• additiveExpression()
• addResolver(Map<String, Object>)
• addLoggerFieldToClass(ClassNode, String, String)
• addMethod$$bridge(ClassNode, boolean, String, int, ClassNode, Parameter, ClassNode, Statement)
• beforeSet(Object, String, Object)
• addCollectorContents(ErrorCollector)
• addPropertyColumn(Object, String, Class, boolean)
• addMapProperties(Map, String, Set<CharSequence>)
• addReturnIfNeeded(MethodNode)
• arrayAsCollection(T)
• any(Object)
• addPropertyChangeListener(PropertyChangeListener)
• addInt(Integer)
• bitwiseNegateImpl(Number)
• addNewStaticMethod(Method)
• addExpression(Expression)
• addMethod(String, int, ClassNode, Parameter, ClassNode, Statement)
• applyToAllMembers()
• addAll(List)
• bind(def)
• available()
• afterMethodCall(MethodCall)
• addCell(TableLayoutCell)
• annotationMemberValueInitializer()
• addCompletions(Object, String, Set<CharSequence>)
• addInterfaceName(String)
• addPreInstantiateDelegate(Closure)
• add(Object)
• add(String)
• afterVisitMethod(MethodNode)
• addPropertyChangeListener(String, PropertyChangeListener)
• addURL(URL)
• annotationMemberArrayValueInitializer()
• annotation()
• addImpl(Number, Number)
• addStaticImport(ClassNode, String, String, List<AnnotationNode>)
• bindResults()
• appendNode(Object)
• bitwiseNegate(Object)
• binaryExpression(int, AST)
• addImports(String)
• addValue(Expression)
• addArgumentExpression(AST, List<Expression>)
• accept(ServerSocket, boolean, Closure)
• bind(def)
• assertTypeNotNull(ClassNode, AST)
• asExpression(AST)
• addDouble(Double)
• applyBlockRecorder()
• addNotify()
• allClasses(boolean)
• addMethod(ClassNode, boolean, String, int, ClassNode, Parameter, ClassNode, Statement)
• addTransform(Class<? extends ASTTransformation>, ASTNode)
• asBoolean(GroovyResultSet)
• addClassPath(String)
• asExpression(ClassNode, Expression)
• between(Period, YearMonth, YearMonth)
• addURL(URL)
• addTypeCheckingInfoAnnotation(MethodNode)
• addDisposalClosure(Closure)
• add(MapItemValue)
• asBoolean()
• afterVisitMethod(MethodNode)
• allClasses(boolean)
• accept(GroovySourceAST)
• addProperty(GroovyFieldDoc)
• afterInvoke(Object, String, Object, Object)
• addChild(Object)
• add(Map)
• appendNode(Object, GPathResult)
• addLong(Long)
• addStaticStarImport(ClassNode, String, List<AnnotationNode>)
• asPrimitiveArray(List, Class)
• absImpl(Number)
• appendNode(Object)
• addTypeCheckingExtension(TypeCheckingExtension)
• arrayGet(int, boolean)
• bitwiseNegation(Closure)
• addImpl(Number, Number)
• asArray(Object)
• appendNode(Object)
• addJsonFieldName(char[], boolean)
• annotations()
• bArrayGet(byte[], int)
• add(TextNode)
• addDefaultParameters(Verifier.DefaultArgsAction, MethodNode)
• addGeneratedMethod(ClassNode, MethodNode)
• and(Number, Number)
• assignmentExpression()
• addLoggerFieldToClass(ClassNode, String, String)
• attributes()
• addMetaClassRegistryChangeEventListener(MetaClassRegistryChangeEventListener)
• asImmutable(Collection<T>)
• addAll(int, Collection<? extends E>)
• annotations()
• addDefaultParameterMethods(ClassNode)
• acceptGetProperty(Object)
• applyUnsharpFilter(MethodHandle, int, MethodHandle)
• addAll(Collection<? extends T>)
• appendOutputNl(def, def)
• annotationDefinition(AST)
• asBoolean()
• autoboxType(Class)
• addVetoableChangeSupport(ClassNode)
• addClosureReturnType(ClassNode)
• askToSaveFile()
• acceptSiblings(GroovySourceAST)
• addNodeChildren(Node, String, Set<CharSequence>)
• absImpl(Number)
• addMetaBeanProperty(MetaBeanProperty)
• addStatements(List<Statement>)
• annotationMemberValuePair()
• addMetaMethod(MetaMethod)
• absImpl(Number)
• addClosureCode(InnerClassNode)
• addErrorAndContinue(Message)
• andExpression(int)
• bitwiseNegate(Object)
• ascendingKeySet()
• asReduction()
• bind()
• assertValidIdentifier(String, String, ASTNode)
• addError(String, ASTNode)
• bindingAttributeDelegate(FactoryBuilderSupport, def, def)
• asBoolean(Matcher)
• addShutdownHook(Object, Closure)
• addGeneratedInnerClass(ClassNode, ClassNode)
• addTypeCheckingExtensions(StaticTypeCheckingVisitor, Expression)
• addError(String, ASTNode)
• annotationsInternal()
• argList()
• asWritable(File, String)
• addBigInteger(BigInteger)
• argList()
• argumentList(Closure)
• ascendingMap()
• asType(String, Class<T>)
• addNewStaticMethod(Method)
• asBoolean(GroovyResultSet)
• asBoolean(Optional<?>)
• beforeGet(Object, String)
• andImpl(Number, Number)
• addStaticStars(String)
• addStarImports(String)
• accept(ServerSocket, boolean, Closure)
• assertContains(int, int[])
• assignS(Expression, Expression)
• addMetaBeanProperty(MetaBeanProperty)
• addLayoutProperties(def)
• addToHistory(def)
• addException(Exception)
• acceptClass(ClassNode)
• assertNoLabelsMissed()
• arraySizeExpression(AST)
• addResolver(Map<String, Object>)
• bitwiseNegate(String)
• addMixinClass(MixinInMetaClass)
• asSynchronized(SortedSet<T>)
• addFieldInit(Parameter, FieldNode, BlockStatement)
• addStaticInitializerStatements(List<Statement>, boolean)
• addShort(short)
• addDeclaredMethodMapsFromSuperInterfaces(ClassNode, Map<String, MethodNode>)
• bind(Closure)
• append(CharSequence, int, int)
• addError(SyntaxException)
• areCategoryMethodCalls(List<MethodNode>, String, ClassNode)
• argTypesMatches(MethodCall, Class)
• addFatalError(Message)
• addAnnotationRef(GroovyAnnotationRef)
• bigIntegerValue()
• balancedBrackets()
• acceptGroovyObjectGetProperty(Object)
• addSorter(def)
• appendNamespaceAttributes(Element, Map<Object, Object>)
• addClasspathJar(EventObject)
• addPostNodeCompletionDelegate(Closure)
• args(String)
• add(T)
• actionPerformed(ActionEvent)
• addBatch(String)
• addClasspath(String)
• acceptGetProperty(Object)
• append(char)
• assertNoArguments(List<String>)
• addChangeListener(PreferenceChangeListener)
• accept(File)
• assignToArray(Expression, Expression, Expression, Expression)
• block(Closure)
• addMetaMethodToIndex(MetaMethod, Header)
• applyToAllMembers()
• addResolver(Map<String, Object>)
• addMethodGenerics(MethodNode, Map<String, ClassNode>)
• addRemoveListener(SourceUnit, AnnotationNode, ClassNode, FieldNode, ClassNode, String, def)
• append(File, Reader, String, boolean)
• arrayInitializer()
• addInterface(ClassNode)
• asUnmodifiable(Collection<T>)
• absImpl(Number)
• addAll(Collection<? extends E>)
• addMethod(MethodNode)
• addToCompileList(File)
• acceptExtension(String)
• addPropertyChangeSupport(ClassNode)
• afterVisitClass(ClassNode)
• addStatement(Statement)
• assignStatement(Expression, Expression)
• addError(String, ASTNode)
• assertLength(int, Object)
• allParametersAndArgumentsMatch(Parameter, ClassNode)
• bitwiseNegateImpl(Number)
• afterVisitClass(ClassNode)
• BinaryExpressionMultiTypeDispatcher(WriterController)
• arraySet(boolean)
• add(CSTNode)
• annotationMemberValuePairs()
• asList()
• addReturnType(ClassNode)
• applyToGeneratedGroovyClasses(CompilationUnit.GroovyClassOperation)
• bindNode(def)
• add(Object)
• AssertionWriter(WriterController)
• accept_FirstSecondAndThirdChild_v_v_ForthChild(GroovySourceAST)
• addPhaseOperation(CompilationUnit.GroovyClassOperation)
• andImpl(Number, Number)
• addException(Exception, SourceUnit)
• addBatch(List<Object>)
• add(MapItemValue)
• bigIntegerValue()
• addBinding(BindingUpdatable)
• addFirstPhaseOperation(CompilationUnit.PrimaryClassNodeOperation, int)
• addWarning(String, String)
• addUnsupportedPreOrPostfixExpressionError(Expression)
• annotationsOpt()
• assertScript(String)
• addMethod(String, Closure)
• annotationDefinition(AST)
• addInterfaceMethods(ClassNode, Map<String, MethodNode>)
• addStaticTypeError(String, ASTNode)
• addTimeStamp(ClassNode)
• applyToAllMembers()
• addMetaMethod(MetaMethod)
• accept_FirstChild_v_RestOfTheChildren(GroovySourceAST)
• annotationArguments()
• assertFailed(Object, Object)
• addClass(ClassNode)
• absImpl(Number)
• bitAndImpl(Number, Number)
• add(CSTNode)
• addSource(SourceUnit)
• acceptGetProperty(Object)
• addPropertyChangeListener(PropertyChangeListener)
• addMetaBeanProperty(MetaBeanProperty)
• asCollection(Object)
• addReturnIfNeeded(MethodNode)
• addClassNodeToCompile(ClassNode, SourceUnit)
• addMetaMethod(MetaMethod)
• addListener(Console)
• and(long, long)
• appendOutputLines(def, def)
• applyToPrimaryClassNodes(CompilationUnit.PrimaryClassNodeOperation)
• addClassNodeToResolve(CompileUnit.ConstructedOuterNestedClassNode)
• addExpression(Expression)
• addString(String)
• asReduction(CSTNode, CSTNode, CSTNode)
• addGlobalTransforms(ASTTransformationsContext)
• addCovariantMethods(ClassNode)
• argumentClassIsParameterClass(Class, Class)
• addEnumConstant(GroovyFieldDoc)
• applyPropertyDescriptors(PropertyDescriptor)
• actionPerformed(ActionEvent)
• add(Object)
• addClass(ClassNode)
• asWritable(Path, String)
• addComponent(Component)
• add(Object)
• addNewStaticMethod(Method)
• annotations()
• addMetaBeanProperty(MetaBeanProperty)
• additiveExpression(int)
• addStaticImport(ClassNode, String, String, List<AnnotationNode>)
• addError(String, CSTNode, SourceUnit)
• and(long, long)
• addSources(File)
• beforeVisitMethod(MethodNode)
• beforeMethodCall(MethodCall)
• bigDecimalValue()
• annotationDef(AST)
• addAllListeners(PropertyChangeListener, Object, Set)
• binX(Expression, Token, Expression)
• attrX(Expression, Expression)
• blockExpression(AST)
• assignX(Expression, Expression)
• beforeMethodCall(MethodCall)
• accept_v_Siblings_v(GroovySourceAST)
• accept_v_FirstChild_v_RestOfTheChildren_v(GroovySourceAST)
• asReduction()
• addText(String)
• addImport(ClassNode, String, String, List<AnnotationNode>)
• bitwiseNegateImpl(Number)
• annotationBlock()
• asWritable(File, String)
• acceptSource(SourceUnit)
• assertArrayEquals(Object, Object)
• ascendingMapWithLimit(int)
• addImpl(Number, Number)
• afterMethodCall(MethodCall)
• asList(String, ResultSet, int, int, Closure)
• accept_v_FirstChild_v_RestOfTheChildren(GroovySourceAST)
• addError(String, ASTNode, SourceUnit)
• addOptionsFromAnnotations(Class, boolean)
• addExpressionCheckers(SecureASTCustomizer.ExpressionChecker)
• accept_FirstChild_v_RestOfTheChildren_v(GroovySourceAST)
• apply(Token)
• addCategoryMethodCallError(Expression)
• addTextListener(TextListener)
• annotations()
• addCatch(CatchStatement)
• array(char)
• appendNode(Element, Object, Map, String)
• add(T)
• beep()
• addNewInstanceMethod(Method)
• addStatementCheckers(SecureASTCustomizer.StatementChecker)
• aCase()
• annotationMemberArrayInitializer()
• addAll(Collection<T>, Iterable<? extends T>)
• add(int, T)
• addColumn(DefaultTableColumn)
• addStatement(Statement)
• accept_FirstChild_v_SecondChild(GroovySourceAST)
• assertToString(Object, String)
• anyToken()
• beforeInvoke(Object, String, Object)
• afterVisitClass(ClassNode)
• addStylesToDocument(JTextPane)
• addPseudoProperties(ClassNode, ClassNode, List<PropertyNode>, Set<String>, boolean, boolean, boolean)
• accept(GroovySourceAST)
• autoClearOutput(EventObject)
• add(List<String>)
• adjustPropertyModifiersForMethod(PropertyNode)
• beforeVisitMethod(MethodNode)
• addExpression(Expression)
• andImpl(Number, Number)
• annotation(Class, Closure)
• asArray(Object, Class)
• addNewInstanceMethod(Method)
• afterMethodCall(MethodCall)
• accept_FirstChild_v_SecondChild_v_ThirdChild_v(GroovySourceAST)
• assertInspect(Object, String)
• addCandidateString(String)
• applyResourceNameMatcher(String)
• add(Command)
• beforeInvoke(Object, String, Object)
• assignToArray(Expression, Expression, Expression, Expression)
• argumentSize(Expression)
• addModel(String, Object)
• addFloat(Float)
• addLoggerFieldToClass(ClassNode, String, String)
• bigDecimalValue()
• addChars(char[])
• asEntryWeigher(Weigher<? super V>)
• acceptGroovyObjectGetProperty(Object)
• afterVisit(Closure<?>)
• assignmentLessExpression()
• asType(Path, Class<T>)
• afterInvoke(Object, String, Object, Object)
• block(Statement)
• asIterator(Object)
• addURL(URL)
• bArraySet(byte[], int, byte)
• addAddListener(SourceUnit, AnnotationNode, ClassNode, FieldNode, ClassNode, String, def)
• applyPropertyDescriptors(PropertyDescriptor)
• addLoggerFieldToClass(ClassNode, String, String)
• accept(GroovySourceAST)
• appendStacktrace(def)
• attributes(Element)
• add(Map<String, Object>)
• addOperationCallListeners(Map<String, Map<String, Map<String, Object>>>)
• acceptGroovyObjectGetProperty(Object)
• addTransformer(MethodHandle, int, Object, Class)
• asString(Throwable)
• addMetaClassRegistryChangeEventListener(MetaClassRegistryChangeEventListener)
• add(E)
• acceptGetProperty(Object)
• asType(File, Class<T>)
• assignmentExpression(int)
• afterVisitMethod(MethodNode)
• asWritable()
• assertScript(String)
• bigDecimalValue()
• addModule(ModuleNode)
• addJsonEscapedString(char[], boolean)
• addCase(CaseStatement)
• asType(File, Class<T>)
• addExpression(Expression)
• addAll(int, Collection<? extends T>)
• assertStatement(AST)
• accept(String)
• addMixin(MixinNode)
• append(File, Object, String)
• alias(String, String)
• annotation()
• annotations(Closure)
• addGlobalTransformsAfterGrab(ASTTransformationsContext)
• addNonRemovableMetaClassRegistryChangeEventListener(MetaClassRegistryChangeEventListener)
• accept_SecondChild_v_ThirdChild_v(GroovySourceAST)
• bitwiseNegate(Number)
• appendNode(Object)
• addNodeListEntries(NodeList, String, Set<CharSequence>)
• addMapEntryExpression(Expression, Expression)
• addNewInstanceMethod(Method)
• addStarImport(String, List<AnnotationNode>)
• annotations()
• addErrorAndContinue(SyntaxException)
• accept_FirstChild_v_SecondChild_v(GroovySourceAST)
• asType(Class)
• appendNode(Object)
• add(Map)
• add(CategoryMethod)
• accept_v_FirstChild_2ndv_SecondChild_v___LastChild_v(GroovySourceAST)
• addGetListeners(SourceUnit, AnnotationNode, ClassNode, FieldNode, ClassNode, String, def)
• assertMultilineStringsEqual(String, String)
• addImpl(Number, Number)
• annotations()
• add(MapItemValue)
• addImport(String, ClassNode, List<AnnotationNode>)
• addImpl(Number, Number)
• addModule(ExtensionModule)
• addMouseListenerToHeaderInTable(JTable)
• accept(GroovySourceAST)
• attribute(Object)
• addError(String, ASTNode)
• addAnnotations(List<AnnotationNode>)
• addClassPathes(GroovyClassLoader)
• addField(String, int, ClassNode, Expression)
• addStaticStarImport(String, ClassNode, List<AnnotationNode>)
• add(GroovyMethodDoc)
• addLookAndFeelAttributeHandler(String, String, Closure)
• attribute(Closure)
• addMember(String, Expression)
• addImpl(Number, Number)
• balancedTokens()
• addListeners(PropertyChangeListener, Object, Set)
• ascendingKeySetWithLimit(int)
• applyToAllClasses()
• bigIntegerValue()
• addEventListeners(MBeanServer, Map<String, Map<String, Object>>)
• addReceivers(List<Receiver<String>>, Collection<Receiver<String>>, boolean)
• annotationIdent()
• annotationField()
• add(char)
• addClassTest(Closure)
• addExceptionBlock(Label, Label, Label, String)
• addLayoutProperties(def)
• addClasspathDir(EventObject)
• beforeGet(Object, String)
• addLine(CharSequence)
• arraySet(MethodType)
• addAmbiguousErrorMessage(List<MethodNode>, String, ClassNode, Expression)
• accept_v_FirstChildsFirstChild_v_RestOfTheChildren(GroovySourceAST)
• addAll(int, Collection)
• addClasspath(String)
• acceptGroovyObjectGetProperty(Object)
• attributes()
• apply(T)
• beforeVisitMethod(MethodNode)
• addNoMatchingMethodError(ClassNode, String, ClassNode, Expression)
• add(char[])
• beforeInvoke(Object, String, Object)
• addGeneratedInnerClass(InnerClassNode)
• addMetaMethod(MetaMethod)
• addPropertyMethod(MethodNode)
• argumentLabel()
• accept_FirstChild_v_SecondChildsChildren_v(GroovySourceAST)
• addNewMopMethods(List<MetaMethod>)
• annotationMemberValuePair()
• accept_v_FirstChild_SecondChild_v_ThirdChild_v(GroovySourceAST)
• addQuoted(String)
• annotationMemberValuePairs()
• addDeclaredMethodsFromAllInterfaces(ClassNode, Map<String, MethodNode>)
• addError(String, ASTNode)
• andExpression()
• bind()
• asList(Object)
• afterInvoke(Object, String, Object, Object)
• bind()
• addFieldFirst(String, int, ClassNode, Expression)
• addStarImport(String, List<AnnotationNode>)
• applyFinallyBlocks(Label, boolean)
• bitwiseNegate(String)
• acceptGetProperty(Object)
• annotationMemberValueInitializer()
• askToInterruptScript()
• addAnnotationRef(GroovyAnnotationRef)
• addNonRemovableMetaClassRegistryChangeEventListener(MetaClassRegistryChangeEventListener)
• autoRegisterNodes()
• add(T)
• arguments()
• addSyntheticMethod(String, int, ClassNode, Parameter, ClassNode, Statement)
• addNewInstanceMethod(Method)
• assertEquals(String, String)
• addStaticTypeError(String, ASTNode)
• asType(Object, Class)
• bind()
• addPropertyChangeListener(String, PropertyChangeListener)
• blockBody(int)
• argTypeMatches(MethodCall, int, Class)
• addConverter(Class<T>, Closure<?>)
• accept_v_FirstChild_v(GroovySourceAST)
• apply(String, int, int, Object, Vector, Vector)
• afterReferenceCreation(Reference)
• addFileset(FileSet)
• acceptGetProperty(Object)
• bind(def)
• addMetaMethod(MetaMethod)
• asCollection(Iterable<T>)
• anonymousInnerClassDef(AST)
• afterInvoke(Object, String, Object, Object)
• addHandler(TypeCheckingExtension)
• accept_v_FirstChildsFirstChild_v_Child2_Child3_v_Child4_v___v_LastChild(GroovySourceAST)
• addImport(String, String)
• addNewStaticMethod(Method)
• bind(Closure)
• beforeInvoke(Object, String, Object)
• addClassNode(ClassNode)
• array(Class, Closure)
• argument()
• applyToAllClasses()
• annotationBlock()
• annotationConstant(Closure)
• addMethodToList(Object, MetaMethod)
• absImpl(Number)
• addComponentsForRow()
• addSources(File)
• applyToAllClasses()
• append(Path, Reader, String, boolean)
• addWarning(int, String, Object, CSTNode, SourceUnit)
• asSql(GString, List<Object>)
• accept_v_FirstChild_v_SecondChild_v___LastChild_v(GroovySourceAST)
• bind()
• addByte(byte)
• addError(String, ASTNode)
• arguments(AST)
• acceptChildren(GroovySourceAST)
• addEnumConstant(ClassNode, String, Expression)
• addDeclaredMethodsFromInterfaces(ClassNode, Map<String, MethodNode>)
• bigIntegerValue()
• appendedBlock(AST)
• applyGenericsContextToPlaceHolders(Map<String, ClassNode>, GenericsType)
• addBoolean(boolean)
• bitwiseNegateImpl(Number)
• addFileset(FileSet)
• accept_v_AllChildren_v_Siblings(GroovySourceAST)
• addNewInstanceMethod(Method)
• assignToArray(Expression, Expression, Expression, Expression)
• acceptBaseName(String)
• addAnnotation(AnnotationNode)
• addFile(String)
• addAll(int, Collection)
• asWrapperArray(Object, Class)
• beforeVisitClass(ClassNode)
• annotations()
• add(Closure)
• apply(T)
• abs(Number)
• annotationArguments()
• addMetaBeanProperty(MetaBeanProperty)
• addPhaseOperations(CompilationUnit)
• add(Object)
• addAssignmentError(ClassNode, ClassNode, Expression)
• andImpl(Number, Number)
• addLoggerFieldToClass(ClassNode, String, String)
• add(E)
• addConfiguredJavac(Javac)
• appendOutput(Icon, AttributeSet)
• addFieldInitialization(List, List, FieldNode, boolean, List, Set)
• addSource(URL)
• andX(Expression, Expression)
• bind()
• aCase()
• beforeSet(Object, String, Object)
• add(Number, Number)
• addNested(GroovyClassDoc)
• addIndirectObjectMembers(Object, String, Set<CharSequence>)
• annotation(AST)
• acceptName(String, String)
• autoboxType(Class)
• addPostInstantiateDelegate(Closure)
• adjustDetails(Map)
• binary(Closure)
• abs(Double)
• arrayGet(MethodType)
• argumentLabelStart()
• append(Node)
• addLookAndFeelAlias(String, String)
• addError(String, ASTNode)
• addStatementLabel(String)
• addNewStaticMethod(Method)
• assertFailed(Object, Object)
• applyToSourceUnits(CompilationUnit.SourceUnitOperation)
• addChildrenOf(CSTNode)
• append(Appendable, Object)
• call(String, Writable)
• caseStatement(Closure)
• caseSList()
• chooseMathMethod(Selector, MetaMethod)
• boolX(Expression)
• closeResources(Connection)
• clone()
• clear()
• buildSubstitutions(SourceUnit, ASTNode)
• clear()
• castToVargsArray(Object, int, Class<?>)
• collectReplacements(String, Closure<String>)
• compareTo(Object)
• compareLessThan(Object, Object)
• build(GroovyObject)
• builtInType()
• compareToImpl(Number, Number)
• childNodes()
• build(GroovyObject)
• commit()
• checkMethod(Method)
• castToBoolean(Object)
• closeOutputPrintWriter()
• checkValueIsType(Object, Object, Class)
• booleanExpression(AST)
• castToBool(int, boolean)
• buildClassLoaderFor()
• compareTo(Object)
• checkEquals(Entry, Object)
• canReopenSource()
• catchS(Parameter, Statement)
• buildTest(String, String)
• callGetPropertySafe(Object)
• coerceArgument(Object)
• call(SourceUnit, GeneratorContext, ClassNode)
• compareTo(Number, Number)
• call(String, Object)
• compareTo(Object)
• compareTo(Comparable, Comparable)
• call(Object)
• bufferedIterator(List<T>)
• checkForbiddenSpreadArgument(ArgumentListExpression)
• buildAST(SourceUnit, ClassLoader, Reduction)
• box(double)
• buildMethod(BuilderASTTransformation, MethodNode, AnnotationNode)
• compile(String, String)
• breadthFirst(Element)
• charDescription(int)
• buildObjectMapFrom(def, def)
• by(T)
• characters(char[], int, int)
• checkExit(int)
• checkIfStdMethod(MetaMethod)
• byteArray()
• buildFromString(CompilePhase, boolean, String)
• call(Object, Object)
• coerceArgument(Object)
• compareToImpl(Number, Number)
• checkPropertyList(ClassNode, List<String>, String, AnnotationNode, String, boolean, boolean, boolean, boolean, boolean)
• close()
• compareLessThanEqual(Object, Object)
• capitalize(String)
• call(ArgumentListExpression, Parameter, MethodNode)
• compilePojoMethod(CachedMethod)
• commentText()
• call(Object, Object)
• comment(Object)
• callCurrent(GroovyObject, Object, Object, Object, Object)
• buildTokenTypeASTClassMap()
• compatibleBodyStatement()
• call(Closure)
• closure(Closure)
• compilePogoMethod(CachedMethod)
• capitalize(String)
• callCurrent(GroovyObject, Object, Object, Object, Object)
• commandLineCompileWithErrorHandling(String, boolean)
• compareArrayEqual(Object, Object)
• closableBlockParam()
• coerceArgument(Object)
• childNodes()
• collect(MethodNode)
• checkIncludeExclude(AnnotationNode, List<String>, List<String>, List<ClassNode>, List<ClassNode>, String)
• clearContext(EventObject)
• compile(List<String>, CompilationUnit)
• call(SourceUnit, GeneratorContext, ClassNode)
• coerce(ClassNode, ClassNode)
• checkForNamedParams(String, List<Object>)
• clear()
• compileFinishNormal()
• cArrayGet(char[], int)
• booleanValue()
• characters(char[], int, int)
• call(SourceUnit, GeneratorContext, ClassNode)
• buildMapType(ClassNode, ClassNode)
• build(GroovyObject)
• collectEntries(E)
• cast(Class, Closure)
• buildMemoizeFunction(MemoizeCache<Object, Object>, Closure<V>)
• classX(Class)
• cmpX(Expression, Expression)
• cleanUpNullReferences()
• commentText()
• callStatic(Class, Object)
• build()
• buildListType(ClassNode)
• call(MethodVisitor, int, boolean, boolean)
• checkOnMethodStart()
• call(String, Map, Closure)
• checkMethod(Method)
• call(Object, Object, Object, Object, Object)
• clearTime(Calendar)
• call(Object, Object)
• capitalize(String)
• builtInTypeArraySpec(boolean)
• callGroovyObjectGetProperty(Object)
• callStatic(Class, Object, Object, Object, Object)
• booleanExpression(Closure)
• clearInvocationCaches()
• chooseMethod(String, Object, Class)
• children(Element)
• booleanUnbox(Object)
• clear()
• childNodes()
• castToEnum(Object, Class<? extends Enum>)
• chop()
• clearAll()
• chop(Iterator<T>, int)
• build(BuilderASTTransformation, AnnotatedNode, AnnotationNode)
• buildTokenTypeASTClassMap()
• checkEquals(Entry, Object, Object, Object)
• childNodes()
• clean()
• clear()
• compile(String)
• compareTo(Object, Object)
• cleanUpNullReferences()
• children()
• classField()
• close()
• checkFiles(String)
• call(Object, Object)
• capacity()
• checkCircularReference(ClassNode, ClassNode, Expression)
• checkInitalised()
• clone()
• collectAllInterfacesReverseOrder(ClassNode, LinkedHashSet<ClassNode>)
• browseWithAWT(List)
• cloneDateExpr(Expression)
• build(GroovyObject)
• charAt(int)
• classField()
• chooseEmptyMethodParams(FastArray)
• clone()
• close()
• childrenOfType(int)
• close()
• clear()
• castNonPrimitiveToBool(ClassNode)
• center(String, Number, String)
• checkCompatibleAssignmentTypes(ClassNode, ClassNode, Expression, boolean)
• build(GroovyObject)
• collectAllInterfaceMethodsByName(ClassNode, String, List<MethodNode>)
• children()
• close()
• buildDefaultObjectName(String, String, def)
• checkCollectionType(Collection)
• classNamed(GroovyClassDoc, String)
• checkValueIsTypeNotString(Object, Object, Class)
• buildClass(BuilderASTTransformation, ClassNode, AnnotationNode)
• clear()
• charValue()
• clear()
• compile()
• cloneSimilarCollection(Collection<T>, int)
• compile(List<String>, CompilationUnit)
• classNamed(GroovyClassDoc, String)
• cloneDelegateAndGetContent(Writer, Closure, boolean)
• by(T)
• clone()
• callGroovyObjectGetPropertySafe(Object)
• compile(String, int, boolean)
• buildWildcardType(ClassNode)
• commentText()
• checkFinalArgNotOverridden(ClassNode, FieldNode)
• coerceArgument(Object)
• clearTime(ZonedDateTime)
• callClosureForMapEntry(Closure<T>, Entry<K, V>)
• boxVar(Class)
• classDef(AST)
• close()
• canRun(Class<?>, GroovyClassLoader)
• compareRowsByColumn(int, int, int)
• compareTo(Object)
• builtInTypeArraySpec(boolean)
• callGetProperty(Object)
• checkPermission(Permission)
• closableBlockParamsOpt(boolean)
• compare(Object, Object)
• castToNonPrimitiveIfNecessary(ClassNode, ClassNode)
• children()
• call(Object, Object)
• callGetProperty(Object)
• commit()
• close()
• build(GroovyObject)
• browse(List)
• call(SourceUnit, GeneratorContext, ClassNode)
• compile(String)
• checkBoundaryCompatibility()
• booleanValue()
• compare(Object, Object)
• buildSoftReferenceMemoizeFunction(int, MemoizeCache<Object, SoftReference<Object>>, Closure<V>)
• call(SourceUnit, GeneratorContext, ClassNode)
• clear()
• classDefinition(AST)
• call(Object, Object)
• callGetPropertySafe(Object)
• close()
• cleanup()
• callWithAllRows(String, List<Object>, Closure)
• chop()
• compareTo(Number, Number)
• charValue()
• clear()
• castToChar(Object)
• booleanValue()
• closeRange(Label)
• collate(List<T>, int, int, boolean)
• clearOutput(EventObject)
• castToString(Object)
• childOfType(int)
• compile(File)
• close()
• childAt(int)
• closeWithWarning(Closeable)
• build(Closure)
• collectAll(Collection, Collection, Closure)
• compareIdentical(Object, Object)
• callThisX(String)
• closureX(Statement)
• callClosureForLine(Closure<T>, String, int)
• coerceToSAM(Closure, Method, Class, boolean)
• collectNested(Iterable, Collection, Closure)
• checkIfGroovyObjectMethod(MetaMethod)
• ClosureMetaClass(MetaClassRegistry, Class)
• build(GroovyObject)
• compareTo(Object)
• compare(T, T)
• buildAttributeMapFrom(def, def)
• classes()
• callSuperX(String)
• checkOnMethodStart()
• clearCache()
• clone()
• box()
• close()
• build(BuilderASTTransformation, AnnotatedNode, AnnotationNode)
• combinations(Iterable)
• classBlock()
• clear()
• coerceArgumentsToClasses(Object)
• clear()
• buildOperationMapFrom(def, def)
• center(String, Number, String)
• buildFromSpec(Closure)
• coerce(ClassNode, ClassNode)
• checkReturnType(ClassNode, ASTNode)
• callGroovyObjectGetProperty(Object)
• compareToImpl(Number, Number)
• castExpression(AST)
• clear()
• compile(Reader)
• builtinOrMarkedImmutableClass(Class<?>)
• chopList()
• cleanUpNullReferences()
• capitalize(String)
• checkImmutable(Class<?>, String, Object, List<String>, List<Class>)
• capacity()
• buildTree(List<String>)
• castToType(Object, Class)
• callCurrent(GroovyObject, Object)
• casesGroup()
• combinations(Iterable, Closure<?>)
• closingVisit(GroovySourceAST)
• captureStdErr(EventObject)
• commandArgumentsGreedy(AST)
• commandArgument()
• canRun(Class<?>, GroovyClassLoader)
• checkCall(Object, Object, Object, Object, Object)
• build(Closure)
• compile()
• checkKnownProperty(BuilderASTTransformation, AnnotationNode, String, List<PropertyInfo>)
• canReopenSource()
• checkCast(ClassNode, Expression)
• call(ClassVisitor, ClassNode)
• bootstrapSafe(Lookup, String, MethodType)
• clear()
• checkValueIsNull(Object, Object)
• checkCall(Object, Object, Object, Object, Object)
• compareNotIdentical(Object, Object)
• coerceArgument(Object)
• closureList()
• collectSelfTypes(ClassNode, LinkedHashSet<ClassNode>, boolean, boolean)
• castNonPrimitiveToBool(ClassNode)
• commandArguments(AST)
• cloneToken(Token)
• builtInTypeSpec(boolean)
• collectImportedSymbols(String, Collection<String>)
• call(SourceUnit, GeneratorContext, ClassNode)
• castToType(Object, Class)
• call(Object)
• compareGreaterThan(Object, Object)
• compareToImpl(Number, Number)
• breadthFirst()
• coerceArgument(Object)
• cloneParams(Parameter)
• clear()
• clear()
• byteValue()
• callGroovyObjectGetPropertySafe(Object)
• buildAttributes(Map)
• checkType(Object)
• clear(JTabbedPane)
• call(ProcessingUnit, int)
• compareTo(BaseDuration)
• checkIncludeExcludeUndefinedAware(AnnotationNode, List<String>, List<String>, List<ClassNode>, List<ClassNode>, String)
• byteValue()
• checkModel()
• closableBlock()
• commands()
• classOrInterfaceType(boolean)
• builtInType()
• closureExpression(AST)
• checkParameters()
• compareTo(Object)
• compareGreaterThanEqual(Object, Object)
• clear()
• callForMap(Entry<K, V>)
• checkPojoMetaClass()
• call(Object, Object)
• clipBoardAvailable()
• coerceArgument(Object)
• bootstrapCurrent(Lookup, String, MethodType)
• clearBatch()
• compile()
• buildAST(SourceUnit, ClassLoader, Reduction)
• cloneSimilarMap(Map<K, V>)
• call(SourceUnit)
• buffered(Iterator<T>)
• clearSelected()
• castToChar(Object)
• chars(String)
• call(Object, Object)
• buildSqlWithIndexedProps(String)
• characters(char[], int, int)
• call(GroovyClass)
• checkCall(Object)
• closureList(Closure)
• callStatic(Class, Object, Object, Object, Object)
• clientPropertyAttributeDelegate(def, def, def)
• clearBytecodeTable()
• charAt(int)
• classBlock()
• compile(int)
• breadthFirst(Map<String, Object>, Closure)
• coerceArgument(Object)
• checkEscaping(String)
• closeQuietly(Closeable)
• compilationUnit()
• call(MethodVisitor)
• charUnbox(Object)
• build(String, GroovyClassLoader)
• build(BuilderASTTransformation, AnnotatedNode, AnnotationNode)
• callCurrent(GroovyObject, Object)
• calculateFirstSentence(String)
• build(GroovyObject)
• call(TreeContext)
• cleanUpNullReferences()
• bootstrapCurrentSafe(Lookup, String, MethodType)
• canReopenSource()
• closeResources(Connection, Statement)
• browseWithNativeBrowser(String, List)
• byteValue()
• compareEqual(Object, Object)
• captureStdOut(EventObject)
• clear()
• call(Object, Object)
• builtInTypeSpec(boolean)
• comment(EventObject)
• chooseMostGeneralMethodWith1NullParam(FastArray)
• classNode(String, int, Closure)
• coerceArgument(Object)
• call(SourceUnit, GeneratorContext, ClassNode)
• booleanValue()
• close()
• castToNumber(Object, Class)
• compare(T, T)
• buildName(AST)
• call(Object, Object, Object, Object, Object)
• chop()
• compareToImpl(Number, Number)
• clear()
• checkOnMethodStart()
• cacheConnection(Closure)
• callWithRows(String, List<Object>, int, Closure)
• collectAllInterfaces(ClassNode)
• cloneCollectionExpr(Expression, ClassNode)
• capitalize(String)
• clear()
• checkReturnType(ReturnStatement)
• collectMany(Iterator<E>, Closure<Collection<? extends T>>)
• build(BuilderASTTransformation, AnnotatedNode, AnnotationNode)
• buttonGroupAttributeDelegate(def, def, def)
• coerceArgument(Object)
• call(Object)
• clone()
• charAt(int)
• classExpression(Class)
• commentText()
• checkPropNames(Object, Map<String, Object>)
• callStatic(Class, Object)
• clone()
• call()
• clearAll()
• close()
• compareTo(Object, Object)
• closeResources(ResultSet)
• callCurrent(GroovyObject, Object)
• compareTo(Object)
• coerceArgument(Object)
• classList2args(List<String>)
• bootstrap(Lookup, String, MethodType)
• call(Closure)
• charAt(int)
• checkClosureParameters(Expression, ClassNode)
• classes()
• childNodes()
• chainInvolvedTypes(OptimizingStatementWriter.OptimizeFlagsCollector)
• close()
• clone()
• clearAll()
• buildParameterMapFrom(def, def)
• clearAll()
• classTypeSpec(boolean)
• checkCall(Object)
• callSafe(Object, Object, Object, Object, Object)
• chooseClassLoader(Map)
• checkParameters(Class)
• chop()
• canRun(Class<?>, GroovyClassLoader)
• clear()
• close()
• clear()
• cacheConnection(Closure)
• classNodeFor(String)
• close()
• checkInitalised()
• comment(String)
• buildListenerMapFrom(def)
• clearTime(Calendar)
• collectPackageNamesFromFolderRecursive(File, String, Set<String>)
• cacheClass(String, ClassNode)
• coerceArgument(Object)
• catchStatement(Closure)
• box(MethodVisitor, Class)
• byteUnbox(Object)
• compileScript(EventObject)
• callClosureForMapEntryAndCounter(Closure<T>, Entry<K, V>, int)
• clear()
• call(ClassVisitor, ClassNode)
• caretUpdate(CaretEvent)
• classOrInterfaceType(boolean)
• classDefinition(AST)
• call(GString, Closure)
• close()
• compareToImpl(Number, Number)
• caseStatements(AST, List)
• build(GroovyObject)
• clone()
• checkNotInterface(ClassNode, String)
• classTypeSpec(boolean)
• classNode(String)
• compile()
• calculateParameterDistance(Class, ParameterTypes)
• compareNotEqual(Object, Object)
• cloneArrayOrCloneableExpr(Expression, ClassNode)
• chooseBestMethod(ClassNode, Collection<MethodNode>, ClassNode)
• caseSList()
• branchStatement()
• cleanup()
• callX(ClassNode, String)
• castToNonPrimitiveIfNecessary(ClassNode, ClassNode)
• compile(def, String, int)
• callGetProperty(Object)
• commentText()
• capitalize(String)
• clone()
• catchStatement(AST)
• castToMixedType(Object, Class)
• call(Object, String, Object)
• checkKnownField(BuilderASTTransformation, AnnotationNode, String, List<FieldNode>)
• checkExplicitMethod(String, Object, Reference)
• clear()
• compile()
• compare(int, int)
• casesGroup()
• commandLineCompile(String, boolean)
• callGroovyObjectGetProperty(Object)
• cleanup()
• cArraySet(char[], int, char)
• cloneDelegateAndGetContent(Closure<?>)
• buildParamInfosFromMaps(Map)
• callGetProperty(Object)
• call(SourceUnit, GeneratorContext, ClassNode)
• castToClass(Object)
• compareEqual(Object, Object)
• clear()
• compare(Object, Object)
• castArgumentsToClassArray(Object)
• canMean(int)
• cleanup()
• breakStatement(AST)
• clearCache()
• cacheStatements(Closure)
• closeStreams(Process)
• compilationUnit()
• clearAndCopy()
• byteValue()
• childNodes()
• checkSuspiciousExpressionStatement(int)
• cleanUpNullReferences()
• clearModifiedExpandos()
• collectSourceFileNames(List<String>, String, List<String>)
• clone()
• commentText()
• buildFromCode(CompilePhase, boolean, Closure)
• clearCaches(String)
• build()
• canMean(int, int)
• compare(T, T)
• clear()
• classNamedExact(String)
• collection()
• childNodes()
• breakStatement(String)
• clear()
• callSafe(Object, Object, Object, Object, Object)
• castX(ClassNode, Expression, boolean)
• clear()
• collect(Map<K, V>, Closure<T>)
• build(GroovyObject, Map, Map<String, String>)
• build(BuilderASTTransformation, AnnotatedNode, AnnotationNode)
• clearParameterizedTypeCache()
• checkCall(Object, Object, Object, Object, Object)
• closableBlockParamsStart()
• call(SourceUnit, GeneratorContext, ClassNode)
• clear()
• chopMap()
• compareTo(ReflectionCompletionCandidate)
• compareTo(Path)
• charValue()
• byteValue()
• ClassNode(String, int, ClassNode, ClassNode, MixinNode)
• charValue()
• constantValue()
• createIntegerFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• depthFirst(Map<String, Object>, Closure)
• createPropertyHandler(AbstractASTTransformation, GroovyClassLoader, ClassNode)
• decodeNull()
• declareBean(BSFDeclaredBean)
• configureTypeVariableDefinition(ClassNode, ClassNode)
• conditionalExpression(int)
• createPropSetter(PropertyNode)
• delegatingProxy(Object, Map<Object, Object>, Object)
• defaultCase(Closure)
• constant(Object)
• createConstrainedStatement(PropertyNode, Expression)
• createBindings()
• createIntegerInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• configureClassNode(CompileUnit, ClassNode)
• differentPropertyExpr(PropertyNode, Expression)
• createSegment(Object, int)
• createDoubleFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• containsKey(Object)
• completePhase()
• copy(Reader, Writer)
• create(WriterController)
• configureAnnotationNodeFromDefinition(AnnotationNode, AnnotationNode)
• createTemplate(URL)
• debugCharDescription(int)
• createCompleters()
• consumeProcessErrorStream(Process, Appendable)
• contains(Object)
• convertValue(V)
• createLongDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createSetterOperationInfoFromProperty(MetaProperty)
• createCompleters()
• componentMoved(ComponentEvent)
• convert(Object, String)
• constX(Object, boolean)
• convertToBoolean(Object)
• createCondition()
• createStringWriter(String)
• dateValue()
• consumeIfMatch(char[])
• declarationExpression(AST)
• createPogoCallCurrentSite(CallSite, Class, Object)
• defineClass(String, byte[])
• createSimilarArray(T, int)
• defaultValue(String)
• decodeJsonArray()
• curryDelegateAndGetContent(Writer, Closure, Object, boolean)
• create(SyntaxException, SourceUnit)
• defineNamespaces(Element, Map)
• createPogoCallSite(CallSite, Object)
• createCondition()
• convertToBooleanArray(Object)
• createListenerMap(def)
• copy(Object)
• ctorThisS()
• declareNamespace(Map)
• currentChar()
• createSimilarSet(Set<T>)
• createIntegerLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createCompleters()
• createDoubleDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• currentTimeSeconds(System)
• declaratorBrackets(AST)
• convert(ReturnStatement, Map<Integer, Map>)
• containsKey(Object)
• consumeProcessOutputStream(Process, OutputStream)
• createGroovyObjectWrapper(GroovyObject, Class)
• copyStatementsWithSuperAdjustment(ClosureExpression, BlockStatement)
• configureParser(FileSystemCompiler.CompilationOptions)
• convertToTypeArray(Object)
• createIntegerLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• countTestCases()
• containsKey(Object)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• copy(SingleKeyHashMap, SingleKeyHashMap, SingleKeyHashMap.Copier)
• convertASTToSource(ReaderSource, ASTNode)
• containsAll(Collection, Object)
• complete(String, int, List<CharSequence>)
• containingClass()
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• convertValue(SoftReference<V>)
• declaration(Closure)
• containsAll(Collection)
• declStatement(Expression, Expression)
• createNode(Object, Map)
• createLongFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createDoubleInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• decodeJsonObject()
• createSetterMethod(ClassNode, PropertyNode, String, Statement)
• containsValue(Object)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• create(boolean)
• createLongFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• consumeIfMatch(char[])
• contents(Closure)
• createLongDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createStatementsClass()
• createTransformMetaMethod(MetaMethod)
• createConstraints()
• descendingMapWithLimit(int)
• createDoubleFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• configureAnnotationFromDefinition(AnnotationNode, AnnotationNode)
• decodeTrue()
• createBinding(SourceBinding, TargetBinding)
• createTemplate(Reader)
• decode(char[], int, int)
• constraintsAttributeDelegate(def, def, def)
• createLink()
• createClosureClass(ClosureExpression, int)
• contains(Object)
• constantValueExpression()
• containingClass()
• copyAnnotatedNodeAnnotations(AnnotatedNode, List<AnnotationNode>, List<AnnotationNode>)
• createSetterBlock(PropertyNode, FieldNode)
• createTemplate(Reader)
• complete(String, int, List<CharSequence>)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• containsMatchingMethod(List, MetaMethod)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• dateValue()
• computeValue(Class<?>)
• copyNodeMetaData(ASTNode)
• createIntegerFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• defineTemporaryVariable(String, ClassNode, boolean)
• componentShown(ComponentEvent)
• createInterruptStatement()
• detachedOutput(EventObject)
• createLexerNode()
• createMopMethods()
• createLongInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createFloatDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• digest(byte[], String)
• createMap()
• createIntegerInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createGeneratestubs()
• dataSet(Class<?>)
• continueStatement(Closure)
• create(String, String, int)
• createCachedMethodSite(CallSite, MetaClassImpl, CachedMethod, Class, Object)
• createTextifier()
• deemedInternalName(String)
• containingClass()
• createThresholdedIdlingManager(ReferenceQueue, ReferenceManager, int)
• dispatch(Throwable, boolean)
• decodeJsonObject()
• convertToIntArray(Object)
• createOutputPrintWriter(File)
• containsValue(Object)
• createGenericsSpec(ClassNode, Map<String, ClassNode>)
• contains(Object)
• containingPackage()
• createCachedMethodSite(CallSite, MetaClassImpl, CachedMethod, Class, Object)
• createDoubleFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createCompiler(CompilerConfiguration)
• decodeFromChars(char[])
• createProject()
• dir(String, Closure)
• createClass(byte[], ClassNode)
• continueStatement(AST)
• complete(String, int, List<CharSequence>)
• decodeTrue()
• depthFirst()
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createPogoCallCurrentSite(CallSite, Class, String, Object)
• copy(ClosureMetaMethod)
• containsValue(Object)
• createSaxParserFactory()
• createVariableDefinition(String, ClassNode, Expression, boolean)
• containsAll(Collection<?>)
• decodeFalse()
• decodeValue()
• configureAnnotation(AnnotationNode)
• createGetterBlock(PropertyNode, FieldNode)
• definesSerializableFields()
• declaratorBrackets(AST)
• createSegment(Object, int)
• despreadList(List, boolean)
• createLongLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createPropInit(AbstractASTTransformation, AnnotationNode, ClassNode, PropertyNode, Parameter)
• deleteRecursive(File)
• ctorSuperS()
• createClassLoader()
• convert(String, String, boolean, boolean)
• createFloatInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• declS(Expression, Expression)
• complete(String, int, List)
• createCompiler(CompilerConfiguration)
• createIntegerLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• derivesFromDate(ClassNode)
• createLongLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• defaultValue()
• createEntry()
• decrement(Object)
• containsKey(String)
• createErrorMessageForAmbiguity(String, String, Class, LinkedList)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• convertPropertyName(String)
• convert(ReturnStatement)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• create(Class, String)
• disabledStandardMetaClass()
• createPojoCallSite(CallSite, Object, Object)
• createGrabRecord(Map)
• directories()
• createSrc()
• createStaticMetaMethodSite(CallSite, MetaClassImpl, MetaMethod, Class, Object)
• createLongFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• complete(List<GroovySourceToken>, List<CharSequence>)
• containsValue(Object)
• createArray(Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Obje
• createGroovyScriptEngine()
• dArraySet(double[], int, double)
• createSimilarQueue(Queue<T>)
• createJavac()
• containsValue(Object)
• createBinding(SourceBinding, TargetBinding)
• debug(String)
• configure(Properties)
• descendingKeySetWithLimit(int)
• createDoubleLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createExact(int)
• ConsoleTextEditor()
• directorySize(File)
• createInterfaceSyntheticStaticFields()
• createBindableStatement(PropertyNode, Expression)
• delDistance(CharSequence, CharSequence)
• complain(String)
• createPropInit(AbstractASTTransformation, AnnotationNode, ClassNode, PropertyNode, Parameter)
• decrementIndent()
• createPropGetter(PropertyNode)
• createLongInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• copyRange(char[], int, int)
• contains(Object)
• describeOperation(MBeanOperationInfo)
• createFloatLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• containsVariable(String)
• contains(Object)
• createPojoCallSite(CallSite, Object, Object)
• decodeJsonString(char[], int, int)
• createMap(Object)
• containsKey(Object)
• completeIdentifier(List<GroovySourceToken>, List<CharSequence>)
• createDoubleFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• dispatchNodeCall(Object, Object)
• containsKey(Object)
• declaration()
• createGetterOperationInfoFromProperty(MetaProperty)
• decode(String)
• containsKey(Object)
• concurrencyLevel(int)
• copyLarge(Reader, Writer, char[])
• ConcurrentReaderHashMap(Map)
• containsAll(Collection)
• decodeValue()
• decodeForSure(char[], int, int)
• createClasspath()
• createDoubleInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createPojoCallSite(CallSite, Object, Object)
• decompile(def, def)
• createReference(T, V, ReferenceQueue)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createEntry(K, int, V)
• createPropInit(AbstractASTTransformation, AnnotationNode, ClassNode, PropertyNode, Parameter)
• createCollector(CompilationUnit, SourceUnit)
• createClosureClass(ClosureExpression, int)
• descendingMap()
• convertGroovy(AST)
• createFloatInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• deepSanitize(Throwable)
• createIterator(Object)
• definesSerializableFields()
• createNumberNumber(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createPojoWrapper(Object, Class)
• configure(CompilerConfiguration)
• decodeHex(String)
• createNode(def, Map, def)
• declareNamespace(Map)
• contains(Object)
• copyWith(Date, Map<Object, Integer>)
• containsValue(Object)
• currentChar()
• delete(int)
• createStaticSite(CallSite, Object)
• create(int, String, Token, Token)
• componentResized(ComponentEvent)
• createNode(Object, Map, Object)
• createScript(String, Binding)
• copy()
• createDoubleDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createDoubleInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• convertToByteArray(Object)
• constantValue()
• containsValue(Object)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• die()
• constantNumber()
• createNode(Object, Map, Object)
• decodeNull()
• decodeBase64(String)
• createRange(Object, Object, boolean)
• containsWithinBounds(Object)
• configure(CompilerConfiguration)
• createIntegerDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• complete(List<GroovySourceToken>, List<CharSequence>)
• decodeSpecialSymbols(String)
• createCompilationUnit(CompilerConfiguration, CodeSource)
• createPojoMetaMethodSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createIntegerDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createLongLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• defaultValue()
• createSimilarMap(Map<K, V>)
• createClasspath()
• contains(String, String)
• containingPackage()
• createNumberNumber(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createGroovyLexer(String)
• createNode(Object, Map, Object)
• definesSerializableFields()
• createSrc()
• denormalize(String)
• createCallBackedManager(ReferenceQueue)
• createView(Closure)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createIntegerDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createNumberNumber(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• complete(List<GroovySourceToken>, List<CharSequence>)
• configure(CompilerConfiguration)
• decodeFromChars(char[])
• createTempDir()
• declarationStart()
• createIntegerFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createFloatLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• complete(List<GroovySourceToken>, List<CharSequence>)
• containsValue(Object)
• createFloatInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createFloatLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• correctToGenericsSpec(Map<String, ClassNode>, ClassNode)
• discardAllEdits()
• compileToScript(String, int, ClassLoader, boolean, boolean, CompilerConfiguration)
• createVariableReference(Map)
• createScript(Class, Binding)
• createDoubleInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createClasspath()
• createKeyStrokeAction(Map, JComponent)
• createDoubleLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createToString(ClassNode, boolean, boolean, List<String>, List<String>, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean)
• componentHidden(ComponentEvent)
• createDoubleDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createTuple(Object)
• decodeValue()
• configureAST(ASTNode, AST)
• controlExpressionList()
• createCompleters()
• createFloatFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• containingClass()
• createCompleters()
• createPogoCallSite(CallSite, Object)
• createDoubleDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createStringBufferWriter(StringBuffer)
• createIntegerInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• define(byte[], String)
• createLongDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• containsKey(Object)
• disableGlobally()
• createDoubleLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createIntegerInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• configure(InputStream)
• createCompilationOptions()
• complete(String, int, List<CharSequence>)
• createFloatDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createLongDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createBinding(SourceBinding, TargetBinding)
• createMap(Object)
• createDoubleInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• descendingKeySet()
• copy(EventObject)
• createTypeCheckedModelTemplateByPath(String, Map<String, String>)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• conditionalExpression()
• createPreparedQueryCommand(String, List<Object>)
• containsValue(Object)
• dateValue()
• convertValue(V)
• description()
• deleteSelected()
• consumeProcessOutput(Process, OutputStream, OutputStream)
• createBinding(SourceBinding, TargetBinding)
• createIntegerLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• containsWithinBounds(Object)
• containsAll(Collection<?>)
• createSignature(MBeanOperationInfo)
• createGroovyc()
• constant()
• containsKey(Object)
• description()
• createOperationKey(String, int)
• createFloatInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createClasspath()
• createIdlingManager(ReferenceQueue)
• count(String, String)
• createLongFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• complain(String)
• createGroovyObjectGetPropertySite(Object)
• copyBinaryResource(String, String)
• createNode(Node, Object, Map)
• createErrorMessage(String, String, String, String)
• createTemplate(Reader)
• compileStaticMethod(CachedMethod)
• compoundStatement()
• die(Class<T>, String)
• createIntegerDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createFloatFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• cut(EventObject)
• createConnection()
• decodeJsonArray()
• copyNonPrivateMethodsDown(Class, Class)
• copyNonPrivateNonNewMetaMethods(MetaMethodIndex.Header, MetaMethodIndex.Header)
• createNumberNumber(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• copyAnnotatedNodeAnnotations(AnnotatedNode, String)
• createIntegerFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• containsValue(Object)
• count(String, String)
• createTemplateByPath(String)
• createNode(Object, Map, Object)
• containsWithinBounds(Object)
• createAsImmutableX(Expression, ClassNode)
• containingPackage()
• decomposeSuperCallName(String)
• createQueryCommand(String)
• createExceptionText(String, MetaMethod, Object, Object, Throwable, boolean)
• createMethodList(String, Class, Closure)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• differentExpr(Expression, Expression)
• createNewShell()
• defineNamespace(Map, String, String)
• curry(Object)
• createLocalLabel(String)
• deleteDir(Path)
• createStaticVersion()
• contentsChanged(ListDataEvent)
• decode(String)
• createSourcepath()
• damerauLevenshteinDistance(Object, Object)
• contains(char[], char, int, int)
• containsKey(Object)
• createSimilarCollection(Collection<T>, int)
• createLongInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• copyWith()
• createFloatDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createParserPlugin()
• createTemplate(Reader)
• copyAllMethodsToSuper(MetaMethodIndex.Header, MetaMethodIndex.Header)
• decimalExpression(AST)
• convertValue(V1)
• createPropSetter(PropertyNode)
• configure(ClassLoader, TemplateConfiguration)
• copyWith(Date, Map<Object, Integer>)
• convertPrimitiveToBoolean(MethodVisitor, ClassNode)
• currentChar()
• createLongInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• depthFirst(Element)
• curryDelegateAndGetContent(Closure<?>, Object)
• disjoint(Collection, Collection)
• createMopMethods()
• create(char[])
• createNode(Object, Map)
• computeValue(Class<?>)
• containsWithinBounds(Object)
• createCompleters()
• copyNonPrivateMethods(MetaMethodIndex.Header, MetaMethodIndex.Header)
• convertClosureToSource(ReaderSource, ClosureExpression)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createPropInit(AbstractASTTransformation, AnnotationNode, ClassNode, PropertyNode, Parameter)
• createIntegerInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createDocument()
• createConnection()
• createDocumentBuilderFactory()
• containsValue(Object)
• createParserPlugin()
• delegatesTo(ClassNode, int, DelegationMetadata)
• createThreadedManager(ReferenceQueue)
• createLongDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createPogoCallCurrentSite(CallSite, Class, Object)
• createArg()
• createIntegerLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createDoubleDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• configure(ClassLoader, TemplateConfiguration)
• createCondition()
• deleteDir(File)
• createCompleters()
• despreadList(Object, Object, int[])
• containsValue(Object)
• createCompleters()
• defineVariable(Variable, ClassNode, boolean)
• createCompleters()
• createSrc()
• constant()
• createSimilarOrDefaultCollection(Object)
• containsKey(Object)
• createCompilationUnit(CompilerConfiguration, CodeSource)
• dispathNodeCall(Object, Object)
• containsKey(Object)
• description()
• containsKey(Object)
• dequeued()
• debug(Object, Throwable)
• createLongFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createFloatLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createLongLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createCopy()
• createClass(byte[], ClassNode)
• correctToGenericsSpecRecurse(Map<String, ClassNode>, ClassNode, List<String>)
• define(String, byte[])
• createStaticMetaMethodSite(CallSite, MetaClassImpl, Class)
• convertToCharArray(Object)
• decodeJsonObjectLazyFinalParse()
• complete(List<GroovySourceToken>, List<CharSequence>)
• createNode(Object, Map)
• create(Class, MetaClassRegistry)
• CompileStack(WriterController)
• denormalize(String)
• convert(Object, String)
• configure(ClassLoader, TemplateConfiguration)
• createPogoMetaMethodSite(CallSite, MetaClassImpl, MetaMethod, Class, Object)
• convertClosureToSource(ClosureExpression)
• createHashCode(ClassNode, boolean, boolean, boolean, List<String>, List<String>, boolean, boolean)
• createFloatInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• convert()
• dateValue()
• createDoubleLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createDoubleFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createEquals(ClassNode, boolean, boolean, boolean, List<String>, List<String>, boolean, boolean)
• configureAnnotation(AnnotationNode)
• createFloatDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• convertToLongArray(Object)
• containsAll(Collection<?>)
• createHashCode()
• createFloatFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• current()
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createPogoCallSite(CallSite, Object)
• complete(String, int, List<CharSequence>)
• containsKey(Object)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createTempDir(File, String, String)
• createFloatFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createList(Object)
• decodeBase64Url(String)
• createRange(Object, Object, boolean)
• definesSerializableFields()
• createTypeCheckedModelTemplate(URL, Map<String, String>)
• convertToPrimitiveArray(Object, Class)
• containsWithinBounds(Object)
• contains(String, String)
• disabledStandardMetaClass()
• createPropGetter(PropertyNode)
• createCompleters()
• createBinding(SourceBinding, TargetBinding)
• disable()
• contains(Object)
• ComplexKeyHashMap(int)
• createClassVisitor()
• defineClass(String, byte[], ProtectionDomain)
• defaultCall(CallSite, Object, Object)
• description()
• createFloatDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createConfiguration()
• containsKey(Object)
• create(int, String, AST, AST)
• configureTypeVariableReference(String)
• createSyntheticStaticFields()
• createSimilarList(List<T>, int)
• createUnsupportedException(String, Number)
• defaultCallStatic(CallSite, Class, Object)
• createLongInteger(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• declaration()
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• configureAnnotationNodeFromDefinition(AnnotationNode, AnnotationNode)
• ctorHead()
• convertToDoubleArray(Object)
• description(AST)
• createNonAwareCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object)
• createCompleters()
• createStaticSite(CallSite, Object)
• dArrayGet(double[], int)
• createNormalMetaClass(Class, MetaClassRegistry)
• createNode(Object, Map)
• createPojoCallSite(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• decodeFalse()
• createFloatFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• createLongLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• containingPackage()
• copyMethodsToSuper()
• containsValue(Object)
• containsKey(Object)
• disableTracker()
• configure(Statement)
• createDoubleLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• decodeNumberLax(boolean)
• declaresInterface(ClassNode)
• defaultValue()
• createNormalMetaClass(Class, MetaClassRegistry)
• differentFieldExpr(FieldNode, Expression)
• createVariableAlias(String, ClassNode, String)
• copyNonPrivateMethodsFromSuper(MetaMethodIndex.Header)
• correctArguments(Object)
• createIntegerDouble(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• configureClassNode(CompileUnit, ClassNode)
• convertToShortArray(Object)
• deleteDir(File)
• decodeFromChars(char[])
• contains(Object)
• countBy(Map<U, V>, Closure<K>)
• convertToFloatArray(Object)
• createGetPropertySite(Object)
• createGroovyLexer(String)
• containsSpreadExpression(Expression)
• compoundStatement()
• description()
• createSetStatement(Expression)
• createClasspath()
• createTuple(Object)
• copy()
• dehydrate()
• ctorX(ClassNode)
• createNumberNumber(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• contains(Object)
• define(Closure)
• createCollector(CompilationUnit, SourceUnit)
• createTemplate(URL)
• complete(List<GroovySourceToken>, List<CharSequence>)
• createList(Object)
• createMap()
• configure(CompilerConfiguration)
• complete(List<GroovySourceToken>, List<CharSequence>)
• defaultCallCurrent(CallSite, GroovyObject, Object)
• copy(char[], int, int)
• createEntry(K, int, V)
• createFloatLong(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• constantValueExpression()
• createClassName(Method)
• copy(MetaMethodIndex.Header, MetaMethodIndex.Header)
• createPogoMetaMethodSite(CallSite, MetaClassImpl, Class)
• createCompleters()
• describeAttribute(String)
• createPojoMetaMethodSite(CallSite, MetaClassImpl, Class)
• complete(String, int, List<CharSequence>)
• declareNamespace(Map)
• createSetterMethod(ClassNode, PropertyNode, String, Statement)
• createIntegerFloat(CallSite, MetaClassImpl, MetaMethod, Class, Object, Object)
• doInvokeMethod(String, Object, Object)
• extractAttribute(Map, String, Class)
• findClass(String)
• equals(Object)
• doAsType(ClassNode)
• findAndRemoveEntry(Entry)
• eachLine(Reader, int, Closure<T>)
• elements()
• eachRow(Closure)
• eachFileMatch(File, Object, Closure)
• execute()
• equals(Object)
• forName(String)
• findAll(Closure)
• enhance(Object, Map)
• fields(boolean)
• findParameterizedTypeFromCache(ClassNode, ClassNode)
• fileOpen(EventObject)
• equals(Object)
• errors()
• dispose()
• fallbackAttributeOrPropertySite(PropertyExpression, Expression, String, MethodCallerMultiAdapter)
• divideImpl(Number, Number)
• findTargetVariable(VariableExpression)
• fireMultiPropertyEvent(ObservableMap.PropertyEvent)
• externalClass()
• doOutside(Closure)
• execute(List<String>)
• eachFileMatch(File, Object, Closure)
• enableEnum(boolean)
• fieldNode(String, int, Class, Class, Closure)
• find(Closure)
• forStatement(Closure)
• escapeJavaScript(Writer, String)
• displayBuffer(List)
• entrySet()
• floatValue()
• execute(List<String>)
• entrySet()
• evaluate(Collection<String>)
• equals(Object)
• dotExpression(AST)
• findCommand(String, List<String>)
• doPrimitiveCompare(ClassNode, ClassNode, BinaryExpression)
• equals(Object)
• enumDef(AST)
• eachDirRecurse(File, Closure)
• find(Closure)
• eachFileRecurse(Path, Closure)
• equalityExpression()
• equals(Object)
• firePropertyChangeEvent(String, boolean, boolean)
• equals(def)
• entrySet()
• exceptions(Closure)
• eachDir(File, Closure)
• enable()
• fillInStackTrace()
• find(Closure)
• encode(ClassNode)
• extractTypesFromParameters(Parameter)
• exceptions()
• fireElementRemovedEvent(Object)
• format(Calendar, String)
• flush()
• flush()
• fields(boolean)
• finishException(Throwable, boolean)
• execute(List<String>)
• errorDetails(String, char[], int, int)
• findClassNode(SourceUnit, CompilationUnit, String)
• enumArguments(AST)
• expandArgumentFiles(def)
• equalParameterTypes(Parameter, Parameter)
• doInvoke()
• entrySet()
• encodeBase64(byte[])
• enumConstant()
• eachObject(ObjectInputStream, Closure)
• eachFileMatch(Path, Object, Closure)
• exclusiveOrExpression(int)
• doubleTwoOperands(MethodVisitor)
• formatNameForClassLoading(String)
• dispose()
• firstRow()
• doCastToWrappedType(MethodVisitor, ClassNode, ClassNode)
• doPrimtiveCompare(ClassNode, ClassNode, BinaryExpression)
• drop(CharSequence, int)
• filterLine(InputStream, Writer, String, Closure)
• fileNewWindow(EventObject)
• enumConstantField()
• findActualTypeByGenericsPlaceholderName(String, Map<GenericsType, GenericsType>)
• equals(IntRange)
• findAll(Closure)
• enumConstants()
• fileSaveAs(EventObject)
• findCurrentInstanceOfClass(Expression, ClassNode)
• finish()
• findMethodOrFail(Expression, ClassNode, String, ClassNode)
• evaluateBinaryExpression(String, BinaryExpression)
• end()
• endElement(String, String, String)
• entrySet()
• evaluateEqual(BinaryExpression, boolean)
• emptyArguments(Expression)
• dropWhile(Iterator<T>, Closure<?>)
• finallyClause()
• doCall(Object)
• enumConstantFieldInternal(AST, AST, AST, Token)
• focusLost(FocusEvent)
• eachMatch(String, String, Closure)
• enumBlock()
• execute(List<String>)
• execute(List<String>)
• filterLine(URL, Writer, String, Closure)
• equals(Object)
• flush()
• find(Closure)
• evaluateArrayAssignmentWithOperator(String, BinaryExpression, BinaryExpression)
• expressionList(AST)
• findMatchingPreImportedClasses(String, Collection<String>)
• enhanceMetaClass(JList)
• doMethodInvoke(Object, Object)
• formatLineNumber(int)
• expand(Object)
• execute(List<String>)
• displayWelcomeBanner(InteractiveShellRunner)
• forStatement(AST)
• execute()
• downto(BigDecimal, Number, Closure)
• find(Closure)
• fork(ASTNode)
• forIter()
• extractStaticReceiver(MethodCall)
• eachFileRecurse(File, Closure)
• error(String, Throwable)
• eachByte(Path, int, Closure)
• floatValue()
• enhanceMetaClass(def)
• flush()
• equals(Object)
• finish()
• fireElementEvent(ObservableSet.ElementEvent)
• doReturn(MethodVisitor, ClassNode)
• evaluate(Collection<String>)
• downto(Calendar, Calendar, Closure)
• enumDefinition(AST)
• doubleTwoOperands(MethodVisitor)
• fixEOLs(String)
• findIndexOf(T, int, Closure)
• fireElementClearedEvent(List)
• doLater(Closure)
• eval(String, int, int, Object)
• doMethodInvoke(Object, Object)
• eval(ScriptEngine, Reader, Binding)
• findMethod(ClassNode, String, ClassNode)
• encodeHex(byte[])
• equals(Object)
• equalsNullX(Expression)
• fArraySet(float[], int, float)
• doubleValue()
• eval(BinaryExpression)
• firstSentenceCommentText()
• dynamicVariable(String, boolean)
• equals(Object)
• field(Closure)
• encodeAngleBracketsInTagBody(String, Pattern)
• findAll(Closure)
• entrySet()
• findAll(Closure)
• fieldX(ClassNode, String)
• escaped()
• execute(List<String>)
• extractPropertyNameFromMethodName(String, String)
• findMethodOrFail(Expression, ClassNode, String, ClassNode)
• fieldDef(AST)
• execute()
• enumConstantBlock()
• edtBuilder(Closure)
• eachObject(ObjectInputStream, Closure)
• enumConstants()
• flush()
• failIfErrors()
• findConverter(Class<?>)
• each(int, int, Closure)
• eachObject(File, Closure)
• eachRow(GString, Closure)
• doStartElement(Object, Attributes)
• evaluate(String)
• equals(Object)
• eachWithIndex(Map<K, V>, Closure)
• escapeControlCharacters(String)
• equals(Object)
• extractRootCause(Throwable)
• findMethodInClassHierarchy(Class, String, Class, MetaClass)
• endDocument()
• equals(Object)
• eachLine(Reader, int, Closure<T>)
• doubleUnbox(Object)
• firstSentenceCommentText()
• findEndQuote(char[], int)
• findPrevious(EventObject)
• equals(Object)
• encodeByteIntoTwoAsciiCharBytes(int, byte[])
• executeUpdate(GString)
• execute(List<String>)
• endDocument()
• findDGMMethodsByNameAndArguments(ClassLoader, ClassNode, String, ClassNode, List<MethodNode>)
• findArg(String)
• downto(Calendar, Calendar, Closure)
• escapeQuote(String)
• drop(String, int)
• find(ASTNode, ASTNode)
• extractTemporaryTypeInfoKey(Expression)
• enumerateGrapes()
• doInvoke()
• exceptionDetails(String)
• entrySet()
• findMatchingImportedClassesCached(String, String, List<String>)
• doExtendTraits(ClassNode, SourceUnit, CompilationUnit)
• equals(Object)
• evaluate(File)
• format(Calendar, String)
• flush()
• entrySet()
• dropRight(T, int)
• extractClassFromFileDescription()
• enumConstantDef(AST)
• firstRow(String, Object)
• elvisOperator(Closure)
• execute(List<String>)
• eq(Object, Object)
• expandLine(String, int)
• enumConstants()
• dropStaticMethodCache(String)
• findClass(String)
• findMixinMethod(String, Class)
• findResult(Map<A, B>, U, Closure<V>)
• forward(String)
• excludeFieldsByType(Iterable<Class<?>>)
• dynamicMemberName()
• findAll(String, String, Closure<T>)
• execute(List<String>)
• encodeSpecialSymbols(String)
• endsWithAny(CharSequence, CharSequence)
• execute()
• findAll(Closure)
• expression(int)
• eachDir(Path, Closure)
• findAll(String, String, Closure<T>)
• firstArgTypesMatches(MethodCall, Class)
• entrySingleton()
• doCastToPrimitive(MethodVisitor, ClassNode, ClassNode)
• exitDesktop(EventObject, def)
• finalizeReference()
• doubleTwoOperands(MethodVisitor)
• div(double, double)
• eachByte(InputStream, int, Closure)
• eachLine(URL, String, int, Closure<T>)
• fields(boolean)
• expand(String, int)
• empty()
• executeQuery(String)
• equal(CachedClass, CachedClass)
• enumConstantField()
• findSetters(ClassNode, String, boolean)
• dropWhile$$bridge(CharSequence, Closure)
• excludeFieldsByName(Iterable<? extends CharSequence>)
• doInvoke()
• equals(Object)
• findOwnMethod(Class, String, Class, MetaClass, MetaMethod)
• eachByte(URL, int, Closure)
• evaluateCompareExpression(MethodCaller, BinaryExpression)
• doubleTwoOperands(MethodVisitor)
• forCond()
• firePropertyRemovedEvent(Object, Object)
• entryX(Expression, Expression)
• findFieldHelper(ClassNode)
• findWhereKeyword(String)
• dynamicMemberExpression(AST)
• findSAM(ClassNode)
• equals(Object)
• ensureClosure(Object)
• dropWhile(GString, Closure)
• divideImpl(Number, Number)
• executeBatch()
• eachLine(String, int, Closure<T>)
• execute()
• equals(Object)
• equals(Object)
• expression()
• doChooseMostSpecificParams(String, String, List, Class, boolean)
• encodeBase64Url(byte[], boolean)
• forCond()
• findInstanceOfNotReturnExpression(IfStatement)
• fireMultiElementRemovedEvent(List)
• findArg(String)
• eachFile(File, Closure)
• evaluateBinaryExpressionWithAssignment(String, BinaryExpression)
• findClass(String)
• flatten(Map)
• entrySet()
• equals(MapEntry)
• doCall(Object)
• eval(String, ScriptContext)
• execGroovy(String, PrintStream)
• fireElementAddedEvent(Object)
• escapeJava(Writer, String)
• encodeAngleBrackets(String)
• findIndexValues(T, Number, Closure)
• failedWithUnexpectedEOF()
• evaluateBinaryExpressionWithAssignment(String, BinaryExpression)
• flatten(Iterable<T>, Closure<? extends T>)
• findStaticFieldHelper(ClassNode)
• execute()
• evaluatePostfixMethod(PostfixExpression)
• floatUnbox(Object)
• expression(AST, boolean)
• fireMultiElementAddedEvent(int, List)
• firePropertyClearedEvent(Map)
• equals(ObjectRange)
• equals(ASTNode, ASTNode)
• divideImpl(Number, Number)
• expressionList()
• doubleTwoOperands(MethodVisitor)
• execute(List<String>)
• execute(String)
• error(Object, Throwable)
• equals(Object)
• doInvoke(Object, Object, Method)
• focusGained(FocusEvent)
• doGroovyCast(Variable)
• findAll(Closure)
• dup()
• doc(String)
• expressionStatementNoCheck()
• displayHelp(Options)
• entrySet()
• find(String, String, Closure)
• div(Duration, long)
• doCompilation(CompilerConfiguration, CompilationUnit, String, boolean)
• doCast(MethodVisitor, Class)
• divideImpl(Number, Number)
• findDGMMethodsForClassNode(ClassLoader, ClassNode, String, TreeSet<MethodNode>)
• equals(Map, Map)
• flush()
• execute(List<String>)
• findNextChar(int, int)
• execute(List<String>)
• entrySet()
• doubleValue()
• fastEquals(NumberRange)
• findResults(Map<K, V>, Closure<T>)
• expression(Closure)
• findRegex(Object, Object)
• findMixinMethod(String, Class)
• finalizeRef()
• fileSave(EventObject)
• findAll(Closure)
• execute(List<String>)
• eachMatch(String, String, Closure)
• fillInStackTrace()
• evaluateExpression(Expression, CompilerConfiguration)
• execute(String)
• equals(Sequence)
• errors()
• fireElementEvent(ObservableSet.ElementEvent)
• equals(MethodKey)
• existsProperty(PropertyExpression, boolean, ClassCodeVisitorSupport)
• encode(ClassNode)
• equals(Object)
• findResource(String)
• dump(AST)
• findMethodsWithGenerated(ClassNode, String)
• fireElementUpdatedEvent(int, Object, Object)
• find(String)
• doInvoke()
• entrySet()
• finalizeReference()
• executeFunction(String, List<String>)
• fail(String, Throwable)
• div(double, double)
• finishNormal(Object)
• forInit()
• execute(List<String>)
• eachDirRecurse(File, Closure)
• exec(String, int, int, Object)
• errorDetails(String)
• floatValue()
• findClass(String)
• divideImpl(Number, Number)
• enumBlock()
• doesKnow(String)
• encodeNibbleToHexAsciiCharByte(int)
• dropMethodCache(String)
• enumConstantBlock()
• finish()
• divide(Number, Number)
• equals(Object)
• doubleValue()
• displayVersion(PrintWriter)
• findClass(String)
• format(Object, boolean, int, boolean)
• findClass(String)
• eachDirMatch(Path, Object, Closure)
• extractSuperClassGenerics(ClassNode, ClassNode, Map<String, ClassNode>)
• equalityExpression(int)
• format(ZonedDateTime, FormatStyle)
• expand(String, int)
• enableGlobally()
• findLastIndexOf(T, int, Closure)
• forInClause()
• findClass(String)
• doParse(UnicodeEscapingReader)
• firstSentenceCommentText()
• findClass(String)
• fileNewFile(EventObject)
• enumConstants()
• find(String, String, Closure)
• execute(List<String>)
• execute()
• eachDir(File, Closure)
• filterLine(URL, Writer, String, Closure)
• enableAssert(boolean)
• floatValue()
• finallyClause()
• fireSizeChangedEvent(int, int)
• equalsNullExpr(Expression)
• formatTypeName(ClassNode)
• findClassNode(String, CompilationUnit)
• expressionStatement(int)
• firePropertyAddedEvent(Object, Object)
• eachDirMatch(File, Object, Closure)
• doSetMetaClass(Object, MetaClass)
• formatArgumentList(ClassNode)
• eachFile(Path, Closure)
• fireElementClearedEvent(List)
• endPrefixMapping(String)
• execute(List, List, File)
• fields(boolean)
• flush()
• equals(Object)
• execute(List<String>)
• filterLine(Path, Writer, String, Closure)
• executeCommand(String)
• finalizeReference()
• eachDirMatch(File, Object, Closure)
• forInit()
• extractName(String)
• equals(SpreadMap)
• fArrayGet(float[], int)
• eval(String, int, int, Object)
• enumerateGrapes()
• enums()
• evaluateEqual(BinaryExpression, boolean)
• error(SAXParseException)
• each(Map<K, V>, Closure)
• executeInsert(GString, List<String>)
• entrySet()
• equals(Object)
• firstSentenceCommentText()
• forStatement()
• escapeBackslashes(String)
• endDocument()
• execute()
• evaluateTernary(TernaryExpression)
• equals(Object)
• equals(Object)
• evaluate(Reader, String)
• doInterrupt(EventObject)
• evaluateCompareExpression(MethodCaller, BinaryExpression)
• fallbackAttributeOrPropertySite(PropertyExpression, Expression, String, MethodCallerMultiAdapter)
• findResources(String)
• execute()
• execute(List, List, File)
• doubleValue()
• firstSentenceCommentText()
• forEachClause()
• fireConstantMetaClassUpdate(Object, Class, MetaClass, MetaClass)
• eachLine(Path, String, int, Closure<T>)
• evaluatePrefixMethod(PrefixExpression)
• enums()
• endElement(String, String, String)
• execute(Class)
• findParameterizedType(ClassNode, ClassNode)
• errorDetails(String)
• flush()
• fireSizeChangedEvent(int, int)
• downto(Temporal, Temporal, TemporalUnit, Closure)
• eachFile(File, Closure)
• existsProperty(PropertyExpression, boolean, ClassCodeVisitorSupport)
• findRegex(Object, Object)
• flatSignature()
• fields(Closure)
• encodeAsValidClassName(String)
• enumerateGrapes()
• enhanceMetaClass(JComboBox)
• enumConstantsStart()
• endsWith(String)
• eachObject(Path, Closure)
• execute(List<String>)
• firstSentenceCommentText()
• dump(Object)
• forStatement()
• exceptions()
• eachByte(URL, int, Closure)
• fieldInfo(PropertyValue)
• findPropertyInClassHierarchy(String, CachedClass)
• eol()
• forIter()
• findHelper(ClassNode)
• eventually(Closure<Boolean>)
• div(Character, Character)
• finalizeReference()
• expressionSwitch(AST)
• format(String, Object)
• eachCombination(Iterable, Closure<?>)
• extendMethodNodePropertyTable(List<List<String>>, MethodNode)
• extractPlaceholders(ClassNode, Map<GenericsTypeName, GenericsType>)
• doInvokeMethod(String, Object, Object)
• execute(List<String>)
• finalizeReference()
• fireMultiElementAddedEvent(List)
• eval(ScriptContext)
• elements()
• evaluateBinaryExpression(String, BinaryExpression)
• escapeXml(String)
• file(String, Closure)
• eqX(Expression, Expression)
• equals(Object)
• firePropertyUpdatedEvent(Object, Object, Object)
• existsProperty(PropertyExpression, boolean, ClassCodeVisitorSupport)
• exit(EventObject)
• equals(GString)
• findNext(EventObject)
• fireElementRemovedEvent(int, Object)
• eachPermutation(Iterable<T>, Closure)
• fireMultiElementRemovedEvent(List)
• divideImpl(Number, Number)
• execute(GString, Closure)
• enumDefinition(AST)
• edt(Closure)
• doWith(CommonCache<K, V>)
• firePropertyEvent(ObservableMap.PropertyEvent)
• first(T)
• enumConstants()
• entrySet()
• executePreparedQuery(String, List<Object>)
• exclusiveOrExpression()
• eachDirRecurse(Path, Closure)
• equals(Object)
• div(Number, Number)
• dumpTree(AST)
• dup()
• equals(Object)
• find(EventObject)
• eachRow(Closure)
• enumConstant()
• eachFileRecurse(File, Closure)
• flatSignature()
• find(Method)
• fireSizeChangedEvent(int, int)
• exec(String, int, int, Object)
• equals(Object)
• equals(Object)
• floatValue()
• doubleTwoOperands(MethodVisitor)
• every(Object)
• fireElementAddedEvent(int, Object)
• doubleValue()
• equals(Object)
• expandLine(String, int)
• findTraits(ClassNode)
• exceptionDetails(String)
• findNextChar(int, int)
• dot(String)
• doCall(T)
• endElement(String, String, String)
• getInitialExpression()
• getArguments()
• getEngineVersion()
• getEnclosingBinaryExpressionStack()
• getAcg()
• getClassUnderInspection()
• getAgo()
• getClassNode()
• getArguments()
• getCompareCode()
• getColumn()
• getEnclosingClosureStack()
• getIfBlock()
• getHidden()
• getColumnLast()
• getCachedSuperClass()
• get(KEY)
• getClassText(ClassNode)
• getDeclaredField(String)
• getExpression()
• get(int)
• getInitialExpression()
• getCategoryNameUsage(String)
• getClassProps()
• getCharFromSizeOneString(Object)
• generateCallSiteArray()
• getFullPathName()
• generateAll()
• getExpression(int)
• getColumnName(int)
• getDelegate()
• getDescriptionByName(String)
• getErrorHandler()
• genPogoMetaMethodSite(CachedMethod, ClassWriter, String)
• getExtensionMethodNode()
• getGenericsTypes()
• getExpression()
• getExplicitMethods()
• getAt(String)
• getAt(Calendar, int)
• getBooleanExpression()
• getDocumentLocator()
• getCodeSource()
• getInitClosure()
• getFirst()
• getCause()
• getClosureWriter()
• getChangeType()
• getDeclaringClass()
• getCurrent()
• getFailonerror()
• getDelegate()
• getAttribute(Object, String)
• get(Object)
• getElementCode(ElementType)
• getExtension(File)
• getDeclaringClass()
• getCurrentBuilder()
• getDateTimeString(Date)
• getClasspath()
• getAnnotations(ClassNode)
• getDeclaredField(String)
• get(Class<?>)
• getClassList(AnnotationNode, String)
• getFactories()
• getBinaryExpressionHelper()
• getEnclosingMethods()
• getAgo()
• getAdaptee()
• getContinueLabel()
• getInstanceMethodsExtensionClasses()
• getEvent()
• getHardBundle()
• getIndentLevel()
• getColumnModel(int)
• getClosure()
• get(Object)
• fullSize()
• getHours()
• getClassNode()
• getClassDocsFromSingleSource(String, String, String)
• get(Object)
• getInstanceClass()
• getGroovyClassDocs()
• getInitialExpression()
• getExpression()
• getController()
• getFirst()
• getDTDHandler()
• getGrapeDir()
• getDeclaringClass()
• getDescription()
• getExceptions()
• getAttribute(Object, String)
• getCompileUnit()
• getFullPathName()
• getEnclosingMethodCall()
• getDeclaredMethods(String)
• getEnclosingMethod()
• getDescriptionByType(ClassNode)
• genericsType(Class, Closure)
• getCompareCode()
• getClassSourcesByPublicClassName()
• getHierarchy()
• getAt(int)
• getImports()
• getHistory()
• getDelegatedMetaClass()
• getDescription(int)
• getCandidates()
• getArguments()
• getAutoIndentString()
• getExpandoMethods()
• getColumn()
• getBytes(InputStream)
• getExpression()
• getExpression()
• getHash()
• getContent()
• generateCallSiteArray()
• getExpected()
• getImportsWhitelist()
• getCachedMethod()
• getClosureWriter()
• getCompleter()
• getContexts()
• getClassLoader()
• getInstanceNonPropertyFields(ClassNode)
• getInferredReturnTypeFromWithClosureArgument(Expression)
• getColumnName(int)
• getCompileUnit()
• getDescription(int)
• getCallSiteName()
• getBytes(InputStream)
• getEnclosingClassNodes()
• getField(String)
• getHref()
• getClassName()
• getAST()
• getDeclaringClass()
• getFourth()
• getExpression()
• getCatchStatement(int)
• getEventName()
• getClassNode()
• getAdaptee()
• getArgumentTypes(ArgumentListExpression)
• getFirstStatement()
• getClassNameResolver()
• getEnclosingMethod()
• getConditionalBlockValues()
• getClosure()
• getClosureWriter()
• getFourth()
• getDevisionOpResultType()
• getDTDHandler()
• getIndex()
• getDefaultStyle()
• getField()
• getDevisionOpResultType()
• getCallSiteWriter()
• getComponent()
• getClasspath()
• getClassTemplates()
• getComponentType()
• genericMethod()
• getErrorCount()
• getIOCause()
• getClassInternalName(String)
• getHelp()
• getArtifactClassLoader()
• getGroovyClassLoader()
• get(Object)
• getBooleanExpression()
• getCategoryName(ClassNode, String)
• get(Object)
• getEnclosingBinaryExpressionStack()
• getInstanceProperties(ClassNode)
• getAt(DOMCategory.NodesHolder, IntRange)
• getFifth()
• getImportStatements()
• getClosureSignatures(MethodNode, SourceUnit, CompilationUnit, String, ASTNode)
• get(int)
• getFirstChildText(AST)
• getInvocationWriter()
• getChangeType()
• getGetter()
• getFileNames(String, String, String)
• getExpression()
• getInstance()
• getContext()
• get(int)
• getGenericsTypes()
• getHelp()
• getAliases()
• getController()
• getDescription()
• getEvent()
• getDeclaringClass()
• getArray()
• getInterfacesAndSuperInterfaces(ClassNode)
• getInferredReturnType(ASTNode)
• getDeclaringClass()
• getAst()
• getExpandoSubclassMethods()
• getAccessedVariable()
• getCurrentCall()
• get(K)
• getBuffer()
• getGenericsTypes()
• getCause()
• getConfig()
• getInstancePropertyNames(ClassNode)
• getAndPut(K, ValueProvider<? super K, ? extends V>, boolean)
• getIntegerSafe(String, Integer)
• getArray()
• getIdentifierFor(String)
• getGenericsBounds(ClassNode)
• getExpression()
• getCallSiteWriter()
• getDeclaringClass()
• getGroovyRoot()
• getAllProperties(ClassNode, boolean, boolean, boolean, boolean, boolean)
• getData()
• getCv()
• getColumn()
• getInterfaces()
• getDocument()
• getIn(Process)
• get(int)
• getIndex()
• getDefaultMethods(Object, String)
• getChildren()
• getCause()
• getImpl()
• getConsoleId()
• getEncoding()
• getCandidates()
• getEnclosingReturnStatement()
• getDeclaringClass()
• getColumn()
• getFifth()
• getFourth()
• getElementCode(ElementType)
• getClosureSignatures(MethodNode, SourceUnit, CompilationUnit, String, ASTNode)
• getChildPropertySetter()
• get(int)
• getEntityResolver()
• getFields(BuilderASTTransformation, AnnotationNode, ClassNode)
• getBitwiseOperationBytecode(int)
• getConfigFile()
• getDeclaringClass()
• get(int)
• getDateTimeString(ZonedDateTime)
• getBuffers()
• getIncludeExclude(BuilderASTTransformation, AnnotationNode, ClassNode, List<String>, List<String>)
• get(Object)
• getCellEditorValue()
• get(String)
• getElementAt(int)
• getDevisionOpResultType()
• getIdentifierFor(String)
• getClassNode()
• getClassName()
• getClassesToResolve()
• getExpression()
• getBytes(URL, Map)
• getInstancePropertyFields(ClassNode)
• getChildBuilder()
• fullyResolveType(ClassNode, Map<GenericsTypeName, GenericsType>)
• getFifth()
• getElementType()
• getDescription()
• getBytecodeParameterTypes()
• getColumn()
• getClassLoader()
• getCandidates()
• getFieldOnSuperSpreadSafe(Class, Object, String)
• getCaseStatements()
• getExplicitProperties()
• getDeclarationEncoding()
• getEntrySetIterator()
• getCompilerFactory()
• getCause()
• getDefaultJmxNameType()
• getAnnotationName()
• getField()
• getFullPathName()
• getInvokeSpecialHandle(Method, Object)
• getDefaultStatement()
• get(K)
• getInstanceMethods()
• getFirst()
• getContent()
• getDeclaredVariable(String)
• getField(ClassNode, String)
• getGetter()
• getFieldSpreadSafe(Class, Object, String)
• getEnclosingClosureStack()
• get(Map<K, V>, K, V)
• getAt(String, Range)
• get()
• getDeclaringClass()
• getCellEditorValue()
• getCaseStatement(int)
• getGroovysh()
• getCompilationUnit()
• getAlias()
• getAt(Calendar, int)
• getElement(JTable, int)
• getEntityResolver()
• getErrorCollectors()
• getInstanceProperties(ClassNode)
• getAttribute(Object, String)
• getClassnames(Set<URL>, String)
• generateFileNames()
• getClassPathUrls()
• getCallSiteLoader()
• getController()
• getGroovyObjectPropertySafe(Class, GroovyObject, String)
• getDeclaringClass()
• getFifth()
• getEnclosingMethodCalls()
• getClassNode()
• getImport(String)
• getField()
• getExpression(int)
• getClasses()
• getContent()
• getErrorMessage()
• getClosure()
• getFrom()
• getExpandoProperties()
• getCompilationCustomizers()
• getExpression()
• getAllProperties()
• getFromInt()
• getFrom()
• getError(int)
• getDay(Integer)
• getFields()
• getDeclaringClass()
• getClasspath()
• getDeclaringClass()
• getAssertionWriter()
• getAnnotations(ClassNode)
• getDefaultJmxNameDomain()
• getFieldSafe(Class, Object, String)
• getDefaultCharset()
• getExpression()
• getColumn()
• getCause()
• getDeclaredVariables()
• getDefaultSoftBundle()
• getDescription()
• getAllDeclaredMethods()
• getEndColumn()
• getBugText()
• getEditor()
• getEntrySetIterator()
• getColumnClass(int)
• getFrom()
• fullyResolve(GenericsType, Map<GenericsTypeName, GenericsType>)
• getClassName(Object)
• getBooleanAnnotationParameter(AnnotationNode, String, boolean)
• getEmptyMethods()
• getColumnList()
• getGroovyObjectProperty(GroovyObject, String)
• getDaylightSavingsOffset(BaseDuration)
• getAdaptee()
• getCause()
• getAt(ZoneOffset, TemporalField)
• getGlobalTransformNames()
• getInternalBaseClassName()
• getField(Class, Object, String)
• getClassNode()
• getClassLoader()
• getBitwiseOperationBytecode(int)
• getCommandStyle()
• getDelegate()
• getClassInfo(Class)
• getFifth()
• getCurrentScope()
• getArgumentTypes(ArgumentListExpression)
• fullSize()
• getInvokeSpecialHandle(Method, Object)
• getEra(Year)
• getCount(Matcher)
• getFirst()
• getClassName()
• getDevisionOpResultType()
• get(Object)
• getFeature(String)
• getDevisionOpResultType()
• getCompareCode()
• getInitialExpression()
• getBooleanExpression()
• getClasspath()
• getIndex()
• getAllMethods(ClassNode)
• getCode()
• getIncludeantruntime()
• getDevisionOpResultType()
• getChars(String)
• getBoundVars(String, ClassLoader)
• getConstraints()
• getArraySetCaller()
• get(K)
• getCachedClass(Class)
• getDeclaredMethodsMap()
• getCount(Matcher)
• getDeclaredMethod(String, Parameter)
• getExpression()
• getInstance()
• getIndy()
• get(Object)
• get(int)
• getIndex()
• getDeclaredMethods(String)
• getDoubleQuotes()
• getCall()
• get(Object)
• getExpressions()
• generateClass(ClassNode)
• getAnnotations(ClassNode)
• fromJsonDate(char[], int, int)
• getContext()
• getEvents()
• getArrayGetResultType()
• getGetter()
• getEnclosingMethodCall()
• getEncoding()
• getCompilerConfiguration()
• getInstance()
• getContext()
• getConfiguration()
• getHidden()
• getGenericsSignature(ClassNode)
• getCodec(int, ClassLoader)
• getFrom()
• getClassToUpdate()
• getClassNode()
• getCachedSuperClass()
• getDebug()
• getInternalClassName()
• getExtensions()
• getColspan()
• getEnclosingClosure()
• get(Object)
• generateMopCalls(LinkedList<MethodNode>, boolean)
• getInterfaces()
• getHours(Integer)
• getElseBlock()
• getCorrectedReceiver()
• generateFileNamesFromOptions(CommandLine)
• getColumnCount()
• getEndLine()
• getGenericsMethodSignature(MethodNode)
• getGetterName(PropertyNode)
• getAndPut(K, ValueProvider<? super K, ? extends V>, boolean)
• getAt(PageContext, String)
• genericMethodStart()
• getFileList()
• getGroovyObjectField(Class, GroovyObject, String)
• getEnclosingBinaryExpression()
• getDefaultScriptExtension()
• getField()
• getClosureSharedVariables(ClosureExpression)
• getClasses()
• getEffectiveGetMetaProperty(Class, Object, String, boolean)
• getCurrentName()
• get(int)
• getBinding()
• getAllClassInfo()
• getContext()
• getCurrentFactory()
• fromISO8601(char[], int, int)
• getClosureExpression()
• getContent()
• getFrom()
• getClassNode()
• getAndPut(K, ValueProvider<? super K, ? extends V>)
• get(int)
• get(int)
• genMethod(int)
• get(Object)
• getExpression()
• getClassNode()
• get(int, boolean)
• getIndentation()
• getContext()
• getAt(TypedOption<T>, T)
• getConfig()
• get(Object)
• get(int)
• getDeclaringClass()
• getClosureArgument(SourceUnit, MethodCallExpression)
• getInstancePropertyFields(ClassNode)
• getInitialValueExpression()
• getExpectedType()
• getEnclosingClassNode()
• getHandler()
• getAcg()
• getErrorMessage()
• getDeclaringClass()
• getDeclaringClass()
• getArrayGetCaller()
• getAquaLAFName()
• getExpressionsBlacklist()
• getEnclosingClosure()
• getGetterBlock()
• getEnclosingPropertyExpression()
• getContext()
• getDelegationMetadata(ClosureExpression)
• getField()
• getErrors()
• getFileNames(String, String, String)
• getDays(Integer)
• get(Object, Object, Object)
• getHash()
• getBytes(String)
• getCellpadding()
• getInitialExpression()
• getFrom()
• getAndPut(K, ValueProvider<? super K, ? extends V>)
• getDeclaringClass()
• getEnableGrapes()
• getExpression()
• getDevisionOpResultType()
• getContents(String)
• getDeclaringClass()
• getAttributeValue(Attr)
• getForceLookupUnnamedFiles()
• getDateString(ZonedDateTime)
• get(int)
• getDependencies(Map, IvyGrabRecord)
• getInnerClasses()
• generateNamePrefixOnce()
• getAt(IntRange)
• getConstantAnnotationParameter(AnnotationNode, String, Class, def)
• getDefaultWeakBundle()
• getInstanceNonPropertyFields(ClassNode)
• getASTTransformationsContext()
• getAttribute(Class, Object, String, boolean, boolean)
• getInvokerClassOrInstance(List<GroovySourceToken>)
• getFile()
• getDocUrl(String, boolean, List<LinkArgument>, String, GroovyRootDoc, SimpleGroovyClassDoc)
• getInvocationWriter()
• getEnvironment()
• getBuilder()
• getCompleter()
• get()
• getBitwiseOperationBytecode(int)
• getEngine()
• getClassLoader()
• getEncoding()
• getClosure()
• getIndentPrefix()
• getDelegate()
• getHours(ZoneOffset)
• getColumn()
• getAdaptee()
• getGenericsTypes()
• getAttribute(Class, Object, String, boolean)
• getDelegate()
• getDisposalClosures()
• get(NamedNodeMap, String)
• getDeclaringClass()
• getContents(String)
• getErrorCollector()
• get(K, int)
• getClassLoader()
• getFrom()
• getClassNode(ClassNode, boolean)
• getFirst()
• generateCompilerConfigurationFromOptions(CommandLine)
• getErrorMessage()
• getAntProject()
• get()
• getClassNode()
• getCode()
• getClassVisitor()
• getAttributeDelegates()
• getGroovyObjectProperty(Class, GroovyObject, String)
• getClassScope()
• getGeneratedInnerClasses()
• getHelp()
• getInstructions()
• getDefiningClassLoader()
• getAgo()
• getClassPath()
• getClassInternalNames(ClassNode)
• getFourth()
• getErrorCollector()
• getCalls()
• getCurrentConstantMetaClassVersioning()
• getDataSource()
• getClosureSharedExpressions()
• getFailonerror()
• getDeclaringClass()
• get()
• getInputStream(String)
• getClosure()
• getCachedClass()
• get(int)
• getAt(String, Range)
• getAttributeInfoFromMap(Map)
• generateCallSiteArray()
• getGroovyObjectFieldSpreadSafe(Class, GroovyObject, String)
• getFirst()
• getDeclaringClass()
• getBitwiseOperationBytecode(int)
• getEighth()
• getClassVisitor()
• get(int)
• getFormatter()
• getCompileStack()
• getHeader(Class)
• getColumnMark()
• getInstance(int)
• getBooleanExpression()
• get(Object)
• getCode()
• getDelegateList()
• getAllProperties(Set<String>, ClassNode, ClassNode, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean, boolean)
• getAnnotationName()
• get(Object)
• getExecutable()
• getCompilationTimeStamp()
• getDateString(Date)
• genInners()
• getGroupOperationResultType(ClassNode, ClassNode)
• getBeanFactoryName()
• getCategoryMethods(String)
• getDefaultValueForPrimitive(ClassNode)
• getInvokeSpecialHandle(Method, Object)
• getErrorHandler()
• getCallSiteWriter()
• getAsType(Object, Class<T>)
• getBytecodeVersion()
• getAliases()
• getBody()
• getIndex()
• getFirst()
• getDeclaringClass()
• getClassgenCallback()
• getAdditionalMetaMethods()
• getInternalBaseClassName()
• getAt(int)
• getFieldName()
• getDateString(Date)
• getDeclaredVariablesIterator()
• getCorrectedClassNode(ClassNode, ClassNode, boolean)
• getAttribute(Class, Object, String, boolean)
• getColumnLast()
• getAntXmlContext()
• getInterface(Object, Class<T>)
• getClosureSignatures(MethodNode, SourceUnit, CompilationUnit, String, ASTNode)
• getFieldOnSuper(Class, Object, String)
• getAllInterfaces()
• getInvocationWriter()
• getDescription()
• getCompareCode()
• getDeclaredMethodMapsFromInterfaces(ClassNode)
• getContextAttribute(String)
• getInitialExpression()
• get(String)
• getAt(int)
• getCurrentNode()
• getEndColumn()
• getErr(Process)
• getInternalClassName()
• getDoCall()
• getArray()
• getEnclosingBinaryExpression()
• getCompileStack()
• getInstanceNonPropertyFieldNames(ClassNode)
• getArguments()
• getAbstractMethods()
• getAutoIndent()
• get(Object)
• getCallSites()
• getAst()
• getCompilationUnit()
• genPojoMetaMethodSite(CachedMethod, ClassWriter, String)
• getClosure()
• fromPhaseNumber(int)
• getBinding()
• getFirst()
• getExpressions()
• getAt(JToolBar, int)
• getAttribute(Class, Object, String, boolean)
• getChangeType()
• getImportType(String)
• getInterfaces()
• get(Object)
• getFieldOnSuperSafe(Class, Object, String)
• getCompileUnit()
• getCatchStatements()
• getFile()
• get(K)
• getExpression(int)
• getColumn()
• getClassCacheEntry(String)
• get(int)
• getFinallyStatement()
• getCurrent()
• getArrayGetResultType()
• getInstance(Class, def)
• genCallXxxWithArray(ClassWriter, String, String, CachedMethod, String)
• getCharset()
• genMethods()
• genStaticMetaMethodSite(CachedMethod, ClassWriter, String)
• getCommand()
• getCv()
• getClosureSignatures(MethodNode, SourceUnit, CompilationUnit, String, ASTNode)
• getEnclosingClassNodes()
• getInterceptor()
• getDeclaredMethodsFromInterfaces(ClassNode)
• getDelegate()
• get(String)
• getDescription()
• getHelp()
• getBitwiseOperationBytecode(int)
• getDirective()
• get()
• getErrorCollector()
• getDays()
• getAvailableCharsets()
• getAndPut(K, ValueProvider<? super K, ? extends V>)
• getInvokerTokens(List<GroovySourceToken>)
• getExceptionType()
• getFieldIndex()
• getFileSystem()
• getEnforce8Bit()
• get(int)
• getColumnClass(int)
• getFrom()
• getClosure()
• getGroovyObjectFieldSafe(Class, GroovyObject, String)
• getClassLoader()
• getEditorProcessBuilder(String, String)
• getFrom()
• getImportsBlacklist()
• getException(int)
• getBitwiseOperationBytecode(int)
• getCategoryMethods(String)
• getDeclaringClass()
• get(int)
• get()
• getEvalShell()
• getCachedMethod()
• getCachedClass()
• getExpression()
• getFactory()
• getDeclaringClass()
• getCompilationUnit()
• getCode()
• getDocTemplates()
• getClass(String)
• getEnclosingClassNode()
• getDisabledGlobalASTTransformations()
• getExpression()
• getClassLoader()
• getAgo()
• getInterfaceClassLoadingClass()
• get(int)
• get(int)
• getDelegate()
• getDelegateSet()
• getGroovyObjectPropertySpreadSafe(Class, GroovyObject, String)
• getDefaultSystemCharset()
• getBinaryExpressionHelper()
• get(String)
• getDebug()
• getCST()
• getCompleter()
• getHidden()
• getFields()
• getGetterMethod(String, boolean)
• getColumnNumber()
• getFeature(String)
• getClasspath()
• getDeclaringClass()
• getChars(String)
• getBean()
• get(K)
• getDeclaringClass()
• getDeclaredInterfaces()
• getInstanceMethodsExtensionClasses()
• getDelegate()
• getAST()
• getClosureSignatures(MethodNode, SourceUnit, CompilationUnit, String, ASTNode)
• getColumn()
• getBaseTemplateClass()
• getEncodingKnown()
• getClassesToCompile()
• getBrowserEnvironmentVariable()
• getDeclaringClass()
• getColumnList()
• getClassLoader()
• getCompletionCase(List<GroovySourceToken>)
• getBinaryExpressionHelper()
• getAssertionWriter()
• getAttributeInfosFromMap(Map)
• getConverter()
• getClasses()
• getGetterName(String, Class)
• getIndex()
• getFalseExpression()
• get(PageContext, String)
• getCategoryName(ClassNode, String)
• getCompileUnit()
• getCallSites()
• getArguments(MethodCall)
• getFullPathName()
• getEnclosingMethodCalls()
• getClassNode(String)
• getDateTimeString(Date)
• getFileNames(Map)
• getFileName()
• getEighth()
• getInterfaceClassLoadingClass()
• getBridgeMethodTarget(Method)
• getAt(QName)
• getDisableChecksums()
• genCallWithFixedParams(ClassWriter, String, String, CachedMethod, String)
• getColumnCount()
• getDescription()
• getAnchor()
• getConfiguration()
• getConfigscript()
• getFieldName()
• get(Object)
• getConverter()
• getCollectionExpression()
• getController()
• getBreakLabel()
• getHour(Integer)
• getBytecodePostprocessor()
• fragment(Map, String)
• getCompareCode()
• getFinalVariablesCallback()
• getClosure()
• getDelegatedMetaClass()
• getBytes(Path)
• getBooleanExpression()
• getDelegatedMetaClass()
• getColumnLast()
• getArrayGetResultType()
• getFields(BuilderASTTransformation, AnnotationNode, ClassNode)
• getConstantName()
• getFields()
• getExpressions()
• getCode()
• getClassLoadingTypeDescription(ClassNode)
• getAt(int)
• getCodeSource()
• getClassAnnotationParameter(AnnotationNode, String, ClassNode)
• getEngineName()
• getFourth()
• getFrom()
• getGeneratedInnerClass(String)
• getImports()
• getInnerClasses()
• getCompareCode()
• getIncludejavaruntime()
• fullStackTraces(EventObject)
• getDelegate()
• getClassNode()
• getCurrent()
• getDeclaredFieldOfCurrentClassOrAccessibleFieldOfSuper(ClassNode, ClassNode, String, boolean)
• getFrom()
• genericsTypes(Closure)
• getClassNodeResolver()
• getEnclosingMethod()
• getFromClassCache(String)
• getIndices(T)
• getExpression()
• getFourth()
• getElementName(String, String, String)
• getDelegateList()
• get(int)
• getDeclaredMethodsFromSuper(ClassNode)
• getInitialValue(Object)
• generateScriptName()
• getDefaultObjectName(def)
• get(Object)
• getFirst()
• getDeclaringClass()
• getDefaultFamily()
• getContinuationData()
• getCurrentTime()
• getDestdir()
• getColumn()
• getContent()
• getGrapeCacheDir()
• getGrabUrls()
• getEnclosingPropertyExpressions()
• getBytecodeVersion()
• getEndLabel()
• genericScriptName()
• getCallingClass(int, Collection<String>)
• getInstance()
• getDescriptor()
• getFullName(ZoneId, Locale)
• getGeneratedMethods()
• getConstantTypesBlackList()
• getEnclosingClassNode()
• getAt(QName)
• getFieldnameForAccessor(String, int)
• getDelimeterSize()
• getBundle(ResourceBundle, String, Locale)
• getFirstClassNode()
• getConnection()
• getBytes()
• getClassInfo()
• get(int)
• getEndLine()
• getEnableAutoDownload()
• getDescriptor()
• getInclusive()
• getConverter()
• getArguments()
• getInstance(Class)
• getConstantTypesWhiteList()
• getBooleanSafe(String)
• getDeclaringClass()
• getExpressionsWhitelist()
• getEnclosingMethods()
• generateScriptName()
• getBytecode(String)
• getMetaClass()
• getSyntheticProperties()
• getRawCommentText()
• getLoadedClasses()
• getProperty(String)
• getMethodVisitor()
• getReturnType()
• getResolveStrategy()
• getLocalGrapeConfig()
• getSourceValue()
• getReader(String)
• getPropertyOnSuperSpreadSafe(Class, GroovyObject, String)
• getList()
• getReferencedLocalVariable(String)
• getName()
• getMath(def, def)
• getStaticImportsWhitelist()
• getMethods()
• getMethodName(Expression)
• getSetterName(String, String)
• getPT()
• getOperandType(ClassNode)
• getParameterTypes(MethodNode, String, SourceUnit, CompilationUnit, ASTNode)
• getParameterTypes()
• getMethods()
• getPrintable(int)
• getLine()
• getRedoAction()
• getProperty(String)
• getPropertyInfos(BuilderASTTransformation, AnnotationNode, ClassNode, List<String>, List<String>, boolean, boolean)
• getParameters()
• getProperties(Object)
• getSiblings()
• getStaticMetaMethod(String, Object)
• getParentFactory()
• getSrcdir()
• getMetaClass(Class)
• getLocalName(Node)
• getManager()
• getListener()
• getResultType(ClassNode, int, ClassNode, BinaryExpression)
• getOrPut(K, V)
• getModel()
• getRegularInvocationWriter()
• getSourceModel()
• getProperty(Object)
• getQualifiedName()
• getPlainNodeReference()
• getOriginType()
• getObjectExpression()
• getOriginalDeclarationType(Expression)
• getStatementLabel()
• getProperty(Class, Object, String)
• getMethodNode()
• getMaximumNumberOfParameters()
• getNamedContinueLabel(String)
• getPreInstantiateDelegates()
• getProperties()
• getStrongMetaClass()
• getSuperClass()
• getPT()
• getPluginStaticGroovyMethods()
• getSecond()
• getParentContext()
• getParameterTypes(MethodNode, String, SourceUnit, CompilationUnit, ASTNode)
• getResolveStrategy()
• getSourceUnit()
• getPreviewFeatures()
• getNormalOpResultType()
• getPluginFactory()
• getRelativeRootPath()
• getTest()
• getLabel()
• getSourceBinding()
• getScriptExtensions()
• getProperties()
• getSixth()
• getShiftOperationBytecode(int)
• getLowerBound()
• getProperty(String)
• getStatementWriter()
• getSqlOrderByVisitor()
• getMetaClass()
• getProperty(Object)
• getName()
• getPackages()
• getParameterTypes()
• getMethods()
• getProperty(Object)
• getSourceUnit()
• getText()
• getProperty(String)
• getLoadedClasses()
• getOrPut(K, int, V)
• getResourceLoader()
• getSetterBlock()
• getOperationInfoFromMap(Map)
• getNamespaceTagHints()
• getTableCellEditorComponent(JTable, Object, boolean, int, int)
• getSeconds(Integer)
• getModuleRegistry()
• getPropertyInfoFromClassNode(BuilderASTTransformation, AnnotationNode, ClassNode, List<String>, List<String>, boolean, boolean)
• getMBeanServer()
• getMetaMethod(String, Object)
• getMetaMethods()
• getParameters(GString)
• getMessage()
• getMethod()
• getProperty(Object)
• getPackageTemplates()
• getStartColumn()
• getOwnerMetaClass(Object)
• getScriptClassDummy()
• getMetaProperty(String)
• getText()
• getMetaclassMethods(Object, String, boolean)
• getProperty(String)
• getSignature()
• getParameter(String)
• getReturnType()
• getLabel()
• getParentClasses()
• getMetaMethods()
• getSourceUnit()
• getSetterName(String)
• getName(String)
• getName()
• getPropertyChangeListeners(String)
• getMetaClassCreationHandler()
• getNewLineString()
• getSourceUnit()
• getProperty(String)
• getPropertyInfo()
• getRegistry()
• getSummariesByPublicClassName()
• getRegistry()
• getName()
• getNotNull(CachedClass)
• getListfiles()
• getSyntheticProperties()
• getStackLength()
• getSecond()
• getModule(String)
• getMopName()
• getOutput()
• getMinimumRecompilationInterval()
• getOrPut(Object)
• getSeconds(ZoneOffset)
• getModifiers()
• getReferencedClassVariable(String)
• getProperty(Object)
• getStandardOperationBytecode(int)
• getProperties()
• getMember(String)
• getLastResult()
• getResource(String)
• getTableCellRendererComponent(JTable, Object, boolean, boolean, int, int)
• getMethodVisitor()
• getProperty(String)
• getSAMMethod(Class<?>)
• getSyntheticProperties()
• getProperty(String)
• getNodeMetaData()
• getSecond()
• getProperty(Object)
• getPropertyMissingDelegate()
• getSourceUnit()
• getScriptBaseClass()
• getStandardOperationBytecode(int)
• getRawCommentText()
• getJavaClass()
• getRow()
• getOuterMostClass()
• getModifiers()
• getReturnType()
• getProperty(String)
• getRegularCallSiteWriter()
• getModifiers()
• getStatementLabels()
• getPropertyChangeListeners(String)
• getRootLoader(ClassLoader)
• getPackage()
• getObject()
• getProperty(Class, Object, String, boolean, boolean)
• getStaticStarImportsBlacklist()
• getName()
• getProperty(Class, Object, String, boolean, boolean)
• getPropertyOnSuper(Class, GroovyObject, String)
• getText()
• getStaticMetaMethod(String, Class)
• getOriginType()
• getLabel(String)
• getMetaDataMap()
• getProperty(String)
• getNormalOpResultType()
• getSqlWhereVisitor()
• getOriginType()
• getNormalOpResultType()
• getMillis()
• getTargetBytecode()
• getText()
• getNimbusLAFName()
• getTest()
• getProgressCallback()
• getProperties()
• getLocalPart()
• getSyntheticTriggerBinding(Object)
• getStaticMetaMethod(String, Class)
• getStaticStarImports()
• getLineNumber()
• getMaximumNumberOfParameters()
• getLastError()
• getText()
• getMetaMethod()
• getReturnType()
• getMixins()
• getNativeParameterTypes()
• getPropertyName(MethodNode)
• getOutputStyle()
• getRootText()
• getName()
• getTaskSuccess()
• getSourceURI(AnnotationNode)
• getName()
• getSnippet(LineColumn, LineColumn)
• getSourceUnit()
• getLineNumber()
• getMetaClassRegistryChangeEventListeners()
• getSilent(KEY)
• getPhantomBundle()
• getKey()
• getMetaClassForClass()
• getReturnType()
• getProperty(String)
• getResultSet()
• getLocation(Class)
• getOuterField(String)
• getStatementBlock()
• getPackageName()
• getMinute(Integer)
• getMethodPointer(Object, String)
• getMethodAsString()
• getMetaClass(Object)
• getNormalOpResultType()
• getPropertyValue(String)
• getPluginDefaultGroovyMethods()
• getSeventh()
• getReferenceFor(String)
• getScriptSource(boolean, String)
• getPluginStaticGroovyMethods()
• getSourceUnit()
• getName()
• getRows()
• getSuperClasses()
• getLine()
• getProperty(String)
• getSetter()
• getStaticMetaMethod(String, Class)
• getPackageName()
• getNewConstantMetaClassVersioning()
• getOwnerType()
• getSuperClassName()
• getText()
• getPrefix()
• getMetaRegistry()
• getScriptSourceLocation(String)
• getMetaClass()
• getProperty(String)
• getSourceUnit()
• getSyntheticProperties()
• getMethods()
• getStandardOperationBytecode(int)
• getTable()
• getOwner()
• getSixth()
• getRowCount()
• getTemplateConfiguration()
• getNextHelperMethodIndex()
• getRowModel()
• getMemoryMaximumSize()
• getShortcut()
• getTargetAnnotationList(AnnotationNode, AnnotationNode, SourceUnit)
• getProperty(String)
• getLocalTransforms$$bridge()
• getIsCaseMethod()
• getNewMetaMethods()
• getReturnType()
• getSize()
• getObjectDistance(ClassNode)
• getMethodAsString()
• getNumberOfPages()
• getSecond(Integer)
• getStartLabel()
• getMethodCallSyntax(String, String, String)
• getMessageWithoutLocationText()
• getText()
• getMixinClass()
• getReferencedLocalVariablesIterator()
• getMetaMethods()
• getReceiver()
• getMetaClassRegistry()
• getProperty(String)
• getterX(ClassNode, Expression, PropertyNode)
• getPropertySuggestionString(String, Class)
• getPropertyInfoFromBeanInfo(ClassNode, List<String>, List<String>, boolean)
• getParameterTypes()
• getKnownImmutables(AbstractASTTransformation, ClassNode)
• getModifier()
• getModifiers()
• getReader(String)
• getScope()
• getModifiers()
• getMethods()
• getPromptStyle()
• getMemoryInitialSize()
• getMessage()
• getOuterField(String)
• getSrcdir()
• getStarImportsBlacklist()
• getRootText()
• getOwner()
• getReturnType()
• getParameterType(int)
• getSixth()
• getMethod(String, Class)
• getProperty(String)
• getProperty(Object)
• getMethod()
• getProperty(String)
• getNamedBreakLabel(String)
• getLine()
• getReceiversWhiteList()
• getLabel()
• getRawCommentText()
• getTargets()
• getNormalOpResultType()
• getProperty(Object, String)
• getPerInstanceMetaClass(Object)
• getModifiers()
• getParameters()
• getProperties()
• getName(String)
• getSoftBundle()
• getTemplate(URL)
• getNewInstanceResolver()
• getRightExpression()
• getPhase()
• getProperty(String)
• getRoot()
• getModifiers()
• getResourceAsStream(String)
• getStartLine()
• getReader()
• getNormalOpResultType()
• getOperandStack()
• getSourceUnit()
• getSuperPropertyFields(ClassNode)
• getMetaClass()
• getReceiversBlackList()
• getReturnType()
• getMetaClassCreationHandler()
• getNode()
• getParent()
• getStandardOperationBytecode(int)
• getProperty(Object)
• getRelationNameResolver()
• getText()
• getReturnType()
• getParams()
• getKey()
• getLineNumber()
• getOptionProperties(String)
• getOperationInfosFromMap(Map)
• getJointCompilationOptions()
• getStrings()
• getStaticImports()
• getStartColumn()
• getObjectInitializerStatements()
• getProperties()
• getSourceUnit()
• getLoopBlock()
• getName()
• getPostInstantiateDelegates()
• getTableCellEditorComponent(JTable, Object, boolean, int, int)
• getOut()
• getStarImports()
• getShiftOperationBytecode(int)
• getMethodWithCaching(Class, String, Object, boolean)
• getScriptExtension()
• getLanguageName()
• getSubclassMetaMethods(String)
• getParameters()
• getPluginDefaultGroovyMethods()
• getOuterClass()
• getProperty(Object)
• getLocale()
• getProperty(Object)
• getProperty(String)
• getMetaMethod(String, Object)
• getLastMatcher(Matcher)
• getSuperNonPropertyFields(ClassNode)
• getLineMark()
• getStandardOperationBytecode(int)
• getMainClass()
• getNames()
• getOperandStack()
• getNinth()
• getPropertyCategorySetterName(String)
• getMilliseconds(Integer)
• getStartColumn()
• getMetaMethods()
• getModifiers()
• getMinutes()
• getKey()
• getLineNumber()
• getModifiers()
• getMetaClass()
• getLineNumber()
• getReader()
• getNodes()
• getKeywords()
• getName()
• getParameters()
• getRoot()
• getParent()
• getMetaProperty(String)
• getStaticImportsBlacklist()
• getMeaning()
• getOutermostClass()
• getReplacementCount()
• getModifiers()
• getKey()
• getStatementsBlacklist()
• getRootDoc()
• getSourceBinding()
• getText()
• getText()
• getMessageExpression()
• getSetter()
• getShortcut()
• getPublicFieldsAndMethods(Object, String)
• getLexer()
• getMonths()
• getPluginDefaultGroovyMethods()
• getMetaClassRegistryChangeEventListeners()
• getNormalizedType(String)
• getScriptUriAsFile(HttpServletRequest)
• getMetaMethod(String, Class)
• getProperty(Object, String)
• getSourceUnit()
• getReverseConverter()
• getOriginType()
• getQt()
• getMapEntryExpressions()
• getOrPutMethods(String, MetaMethodIndex.Header)
• getResourceConnection(String)
• getParametersSafe(ClosureExpression)
• getMessage()
• getNameWithoutPackage()
• getSystemPropertySafe(String)
• getSourceUnit()
• getSeconds()
• getReader(String)
• getSourceUnit()
• getSourceUnit()
• getMemberClassList(AnnotationNode, String)
• getProperty(String)
• getName(String)
• getMethods()
• getTargetDirectory()
• getStackTrace()
• getLine()
• getLoadedClass(String)
• getLoopBlock()
• getMetaClass()
• getMetaClass(Object)
• getText()
• getSuperPropertyFields(ClassNode)
• getShiftOperationBytecode(int)
• getMemberList(AnnotationNode, String)
• getPropertyForSetter(String)
• getSummariesBySourceName()
• getPrecedence(int, boolean)
• getStatementsWhitelist()
• getMapDelegate()
• getResolvedClasses()
• getMethod()
• getLine()
• getMillisecond(Integer)
• getOriginType()
• getProperty(Object, String)
• getOrPutEntry(Entry)
• getLastAction()
• getMinutes(ZoneOffset)
• getMode()
• getShowLastResult()
• getPhaseNumber()
• getProperty(String)
• getSourceUnit()
• getTargetBinding()
• getMethods(String)
• getReplacement()
• getModifiers()
• getParameterTypes()
• getReturnType()
• getOperation()
• getMethodMissingDelegate()
• getShiftOperationBytecode(int)
• getProperty(Object)
• getOffset(ZoneId, Instant)
• getText(BufferedReader)
• getMetaMethod()
• getProperty(Object)
• getMethodNode()
• getSizeExpression()
• getMethodNode()
• getSourceUnit()
• getProperty(String)
• getMessage()
• getModel(String)
• getModifiers()
• getMessage()
• getSyntheticProperties()
• getStubdir()
• getLoopBlock()
• getMethodWithoutCaching(int, Class, String, Class, boolean)
• getOut(Process)
• getSilent(K)
• getOperation()
• getRoot(boolean)
• getSql()
• getSourceLocator()
• getName()
• getSyntheticProperties()
• getObjectExpression()
• getName()
• getNextClosureInnerName(ClassNode, ClassNode, MethodNode)
• getLocalExplicitMethods()
• getSource()
• getMonths(Integer)
• getStandardOperationBytecode(int)
• getProperties()
• getOwner()
• getParentInterfaces()
• getProperty(Object)
• getLine()
• getMonths()
• getMethodPointer(Object, String)
• getProperty(String)
• getReturnType()
• getSourceUnit()
• getLineLast()
• getResolveStrategy()
• getReturnType()
• getSourceUnit()
• getMetaMethods()
• getName()
• getSuperClassDistance()
• getSrcdir()
• getProxyBuilder()
• getNullable(CachedClass)
• getReceiver()
• getReturnType()
• getTableCellRendererComponent(JTable, Object, boolean, boolean, int, int)
• getMethodName()
• getMetaMethods()
• getMethodSuggestionString(String, Class, Object)
• getSuperMethodNames()
• getProperty(Class, Object, String, boolean, boolean)
• getResultSetType()
• getReturnInsnByType(Type)
• getModules()
• getOwnerClass()
• getSize()
• getParent()
• getSourceUnit()
• getPrevIndex()
• getProperty()
• getMessage()
• getSourceUnit()
• getSourceUnit()
• getResultSetHoldability()
• getSignature()
• getName()
• getModifiers()
• getMethods()
• getSourceUnit()
• getLineLast()
• getReceiver()
• getNamespace(String)
• getPageFormat(int)
• getProperty(String)
• getReferenceFor(String)
• getPublicFields()
• getSourceUnit()
• getProgram(String)
• getProperty(Object)
• getProperty(Object, String)
• getPropertySafe(Class, Object, String)
• getPlugin()
• getSearchText()
• getLocalFactories()
• getNameMappingClosure()
• getNextInnerClassIdx()
• getStandardOperationBytecode(int)
• getName(int)
• getModelMBeanInfoFromMap(Map)
• getOutermostClass()
• getNow()
• getMembers()
• getTestClassName()
• getMimeTypes()
• getSourceUnit()
• getReturnType()
• getShell()
• getMopMethodName(MethodNode, boolean)
• getNode()
• getMemberStringList(AnnotationNode, String)
• getName()
• getMethods()
• getMethodTarget()
• getMetaClass(Class)
• getModifiers()
• getStepSize()
• getPackageNames(URL)
• getName()
• getSuperClass(ClassNode, ClassNode)
• getReader()
• getScriptUri(HttpServletRequest)
• getSyntheticProperties()
• getName()
• getRelativeRootPath()
• getMethods()
• getPhase()
• getPrinter()
• getterThisX(ClassNode, PropertyNode)
• getRegistrationGroups()
• getPreference(String, String)
• getSignatureFromParamInfo(def)
• getSourceValue()
• getParentNode()
• getSixth()
• getName()
• getResultSetConcurrency()
• getMath(Number, Number)
• getSourceUnit()
• getSourceUnit()
• getName()
• getRowspan()
• getStaticMethodsExtensionClasses()
• getReturnType()
• getMeaning()
• getRootNode()
• getOnPopHandlers()
• getParameters()
• getStartColumn()
• getSyntheticProperties()
• getModel()
• getName()
• getParameterText(Parameter)
• getParenLevel()
• getMethods(Class, String)
• getResourceConnection(String)
• getObjectProperties(Object)
• getSourceUnit()
• getOperation()
• getLocalizedMessage()
• getName(String)
• getPT()
• getSql()
• getName()
• getProperty(String)
• getModifiers()
• getSnippet()
• getStatementWriter()
• getMetaMethod(String, Object)
• getParameterCount()
• getSample(int, int, Janitor)
• getLocalExplicitProperties()
• getText()
• getMessage()
• getSourceUnit()
• getName()
• getModule()
• getSwitchPoint()
• getSyntheticProperties()
• getOutputStatement(String)
• getParameters()
• getReturnType()
• getName()
• getRegistrationGroupItems(String)
• getLoadedClasses()
• getMeaningAs(int[])
• getSourceValue()
• getSubstanceLAFName()
• getMethodWithoutCaching(Class, String, Class, boolean)
• getMetaClass()
• getSourceUnit()
• getSourceEncoding()
• getPropertyName()
• getNormalOpResultType()
• getPackageName()
• getModel()
• getPrefix()
• getSourceUnit()
• getLocationText()
• getMemberValue(AnnotationNode, String)
• getService()
• getScriptBaseClass()
• getSeventh()
• getMacroValue(BlockStatement, boolean)
• getjAnsiCodes()
• getTargetBytecode()
• getNormalizedEncoding()
• getMetaPropertyValues()
• getProxyTarget()
• getLastMatcher()
• getTargetBinding()
• getNodeMetaData()
• getNewMetaClass()
• getName()
• getLastColumnNumber()
• getShiftOperationBytecode(int)
• getMessage()
• getMacroArguments(SourceUnit, MethodCallExpression)
• getLeftExpression()
• getSetterMethod(String, boolean)
• getModifiers()
• getReader()
• getReferenceQueue()
• getReader()
• getSource()
• getOuterClasses()
• getMinutes(Integer)
• getResource(String)
• getProperty(String)
• getName()
• getReturnType()
• getProperty()
• getLineLast()
• getModifiers()
• getParameterType(int)
• getReferencedLocalVariablesCount()
• getModifiedExpando()
• getParameterType(int)
• getRowsModel()
• getProperty()
• getName()
• getStartLine()
• getNullObject()
• getOrAddClosureClass(ClosureExpression, int)
• getName()
• getName()
• getTemplateLoader()
• getStaticMethodsExtensionClasses()
• getMessage()
• getPrintAction()
• getReverseConverter()
• getNameCount()
• getParameterTypes(MethodNode, String, SourceUnit, CompilationUnit, ASTNode)
• getProperty(String)
• getStrings()
• getRelativeRootPath()
• getPropertyName()
• getReturnType()
• getIvyParts(String)
• getTableForReading()
• getStubCount()
• getPT()
• getName()
• getPropertyCategoryGetterName(String)
• getSourceValue()
• getSourcepath()
• getMetaDataMap()
• getOldMetaClass()
• getRegisteredExtensions(ClassLoader)
• getNormalizedColumn(int, int)
• getTable()
• getMethods()
• getParamTypes()
• getRecompileGroovySource()
• getRelativeRootPath()
• getStaticProperty(ClassNode, String)
• getLanguageVersion()
• getRelativeRootPath()
• getName()
• getOverride()
• getParameterTypes()
• getSourceUnit()
• getParameterTypes(MethodNode, String, SourceUnit, CompilationUnit, ASTNode)
• getScriptText()
• getParameterCount()
• getStartLine()
• getMethod(String, Parameter)
• getName()
• getLastContext()
• getName()
• getMainClassName()
• getPayload()
• getMethod()
• getMethods()
• getName()
• getProperty(Object)
• getName()
• getOrderBy()
• getRoot()
• getRelativeRootPath()
• getName()
• getProperty(Object)
• getMemberIntValue(AnnotationNode, String)
• getSourceModel()
• getName()
• getLine()
• getModifiers()
• getParameterCount()
• getNamespaceURI()
• getPackageName()
• getMessageWithoutLocationText()
• getListCellRendererComponent(JList, Object, int, boolean, boolean)
• getMethodPointer(Object, String)
• getLexer()
• getReferencedClassVariablesIterator()
• getSecond()
• getSourceUnit()
• getMBeanServer()
• getPropertySpreadSafe(Class, Object, String)
• getNormalizedText()
• getMixinInstance(Object)
• getMethodAsString()
• getParameterTypes(MethodNode, String, SourceUnit, CompilationUnit, ASTNode)
• getTargetMethod(Expression)
• getName()
• getSourceBinding()
• getOriginType()
• getLoadInsnByType(Type)
• getReturnType()
• getKeepStubs()
• getStarImportsWhitelist()
• getReader()
• getSetterName(String)
• getObject()
• getParameterCount()
• getSubclassMetaMethods(String)
• getPropertyAsString()
• getMethod()
• getProperty(String)
• getMetaMethods()
• getParentName()
• getNameWithTypeArgs()
• getProperty(Class, Object, String, boolean, boolean)
• getName()
• getMethod(String, Class)
• getParser()
• getOrPut(Object, Object, Object)
• getResourceLoader()
• getKnownImmutableClasses(AbstractASTTransformation, ClassNode)
• getModifiers()
• getSanitizeStackTrace()
• getModifiersText(int)
• getProperties()
• getLastLineNumber()
• getParameterType(int)
• getSelector(MutableCallSite, Class, String, int, boolean, boolean, boolean, Object)
• getName()
• getPropNameForAccessor(String)
• getPropertyOnSuperSafe(Class, GroovyObject, String)
• getReferencedClassVariables()
• getListIterator()
• getOuterClass()
• getSourceUnit()
• getModifiers()
• getProject()
• getPropertyChangeListeners(String)
• getMaxSizeForInMemory()
• getMetaMethods()
• getProperty(Class, Object, String, boolean, boolean)
• getLoopBlock()
• getPlainNodeReference()
• getParameterTypes(MethodNode, String, SourceUnit, CompilationUnit, ASTNode)
• getSourceUnit()
• getOptimizationOptions()
• getText()
• getSecond()
• getLine(int, Janitor)
• getPhaseDescription()
• getParamterTypes()
• getProperty(String)
• getOptionValue(TypedOption<T>, T)
• getReturnType()
• getParamsCount()
• getShiftOperationBytecode(int)
• getProperty(String)
• getParameters()
• getProperty(String)
• getRootDoc()
• getSecond()
• getMaxRows()
• getProperty(Object)
• getNextSuperClass(ClassNode, ClassNode)
• getSubList(List, List)
• getIOException()
• getMetaClass(Class<T>)
• getResourceConnection(String)
• getMemberClassValue(AnnotationNode, String, ClassNode)
• getMetaProperty(String)
• getMessage()
• getModifiers()
• getParserFlavor()
• getParametersText(Parameter)
• getName()
• getRelativeDaylightSavingsOffset(Date, Date)
• getPostNodeCompletionDelegates()
• getStatementWriter()
• getMetaPropertyValues(Object)
• getPackageNamesFromJar(JarFile)
• getSize()
• getOwnerMetaClass(Object)
• getStartLine()
• getPropertySafe(Object, String)
• getTest()
• getStaticStarImportsWhitelist()
• getRowCount()
• getMetaProperty(String)
• getReturnType()
• getMOPMethodName(CachedClass, String, boolean)
• getService()
• getModifiers()
• getStatements()
• getReader()
• getProperties()
• getObjectExpression()
• getName()
• getScriptEngine()
• getMethodName()
• getReverseConverter()
• getMath(def, def)
• getStaticMetaMethod(String, Object)
• getTemporaryTypesForExpression(Expression)
• getSourceModel()
• getService()
• getModules()
• getParentClassLoader()
• getLubName()
• getLine(int, Janitor)
• getMethodDescriptor(Class, Class)
• getQuote()
• getProperty(String)
• getStrings()
• getMonth(Integer)
• getOuter()
• getRowIndex()
• getModifiers()
• getMetaClass(GroovyObject)
• getMkp()
• getScrollableTracksViewportWidth()
• getShiftOperationBytecode(int)
• getRawCommentText()
• getKeyExpression()
• getShortName(ZoneId, Locale)
• getMetaProperty(String)
• getText()
• getSuperNonPropertyFields(ClassNode)
• getSeventh()
• getPackage()
• getPermissions(CodeSource)
• getResolvedClasses()
• getSecond()
• getQuietly(Object)
• getMetaProperty(String)
• getName()
• getSourceUnit()
• getTable()
• getModifiers()
• getOwner()
• getLayoutTarget(Container)
• getTargetBinding()
• getStaticMethods()
• getSourceUnit()
• getShell()
• getMethodDescriptor()
• getNextNode(Iterator)
• getMessage(String)
• getSecond()
• getMemberStringValue(AnnotationNode, String)
• getReturnTypes()
• getModule()
• getReturnType()
• getOriginalMessage()
• getTarget()
• getMessage()
• getSyntaxError(int)
• getType()
• getUserdata(Object, boolean)
• getWarningList()
• getType()
• getVariableExpression()
• inspect()
• init(AsmClassGenerator, GeneratorContext, ClassVisitor, ClassNode)
• hasInitialExpression()
• getTriggerBean()
• getType()
• inspectChild(FactoryBuilderSupport, Object, Map)
• getUpdateStrategy()
• hasPackage()
• GroovyScriptEngine(ResourceConnector, ClassLoader)
• hashCode()
• getURI()
• getTransformer(ASTNode, SourceUnit)
• grab(Map, Map)
• hasDecimalChar(char[], boolean)
• hasSingleCharacterArg(Closure)
• getVersion()
• gotoPhase(int)
• getWrapped()
• getVariables()
• ifStatement(Closure)
• getURI()
• getVerbose()
• getToday()
• getText()
• hasNoRealSourcePosition()
• getValue()
• getVariable()
• getText(int)
• hasCallSiteUse()
• getType()
• getVersion()
• getType()
• historyNext(EventObject)
• inferListExpressionType(ListExpression)
• getValue()
• getType(ASTNode)
• hashCode()
• getValueAt(int, int)
• inout(InParameter)
• getUnescapedUnicodeOffsetCount()
• hasDefaultImplementation(Method)
• hasSameFieldX(FieldNode, Expression)
• getTupleExpression()
• getText(URL, Map, String)
• getValidator()
• gstring(AST)
• hasImportsResolved()
• init(int)
• importedClasses()
• getUnaryExpressionHelper()
• getTheClass()
• hasProperty(Object, String)
• incVersion()
• getTypeCheckingAnnotations()
• getType()
• getTimeString(ZonedDateTime)
• hasPackageName()
• hasInitialExpression()
• initActions()
• getTypeSourceDescription()
• importedClasses()
• hasGroup(Matcher)
• getWhere()
• includeUnescaped(String)
• getValueCount()
• initialCapacity(int)
• getTo()
• getValueExpression()
• init(ASTNode, SourceUnit)
• getWarning(int)
• hasDefaultValue()
• handleNotification(Notification, Object)
• grep(T)
• getType()
• identifierStar()
• importNode(Class, String)
• getUnwrapper(ClassNode)
• handleMatches(long, LinkedList, Object, long)
• handleException(String, Exception)
• hasRHSIncompleteGenericTypeInfo(ClassNode)
• handleIncompatibleAssignment(ClassNode, ClassNode, Expression)
• getThird()
• inclusiveOrExpression(int)
• hash(K)
• getVariable(String)
• getTo()
• identifierStar()
• getVersion()
• inspect()
• getToInt()
• initialize()
• hasCategoryInCurrentThread()
• getTypeClass()
• getText()
• ifConstraint(T, Closure<T>)
• innerClasses(boolean)
• hasWarnings()
• getYears()
• getType()
• getURI()
• hasNext()
• getUsage()
• getUncurriedArguments(Object)
• getUpdate()
• hasListeners(String)
• getTreeContext()
• hydrated()
• getValue(int)
• handleIncompatibleAssignment(ClassNode, ClassNode, Expression)
• getText(String)
• getValueModel()
• inspect()
• hasPossibleStaticMethod(ClassNode, String, Expression, boolean)
• getTypeDescription(ClassNode)
• hasUTF16LEBom()
• huntForTheScriptFile(String)
• getTree()
• hasMore()
• hideAndClearOutputWindow(EventObject)
• getWarningLevel()
• hasBlockRecorder()
• hasSamePropertyX(PropertyNode, Expression)
• handleAmbiguousMethods(List<MethodNode>, Expression)
• getThird()
• innerClassDef(AST)
• init(T)
• includeEscaped(String)
• getType()
• handleMissingMethod(ClassNode, String, ArgumentListExpression, ClassNode, MethodCall)
• initialize(BSFManager, String, Vector)
• insertString(Document, int, String, AttributeSet, boolean)
• ignore(Object, Closure)
• getText()
• hashCode()
• hash(int)
• hasChildren()
• getTypeDescription()
• importStatement()
• incrementIndent()
• getType()
• getType()
• inferClosureParameterTypes(ClassNode, Expression, ClosureExpression, Parameter, MethodNode)
• implies(Boolean, Boolean)
• getVersion()
• hashCode()
• getTo()
• getValues()
• incVersion()
• getText()
• getTimestamp(Class)
• getValues()
• hashCode()
• getValues()
• indexExpression(AST)
• hasImplicitParameter(ClosureExpression)
• hasCategoryInAnyThread()
• init(ServletConfig)
• getZoneId(Date)
• hashCode()
• initialize()
• getType()
• indexOf(Object)
• hasCustomStaticInvokeMethod()
• getType()
• getVariableScope()
• incrementBatchCount()
• getWarnings()
• getType()
• getType()
• getValues()
• groupEntriesBy(Map<K, V>, Closure<G>)
• getTokensBlacklist()
• getThird()
• getType()
• handleUnresolvedVariableExpression(VariableExpression)
• grow(char[])
• head()
• getTheClass()
• getVariableScope()
• hashCode()
• getText()
• getValidator()
• hashCode()
• getType()
• getType()
• hasOption(TypedOption)
• getText()
• getXMLReader()
• hash(int)
• hasChar()
• getTypeClass()
• hashCode()
• getText()
• ignorableWhitespace(char[], int, int)
• getValue()
• hashCode()
• getVisibleClasses(List)
• getType()
• indented(Closure)
• getUpperBounds()
• hasProperty(Object, String)
• getWrapperClass(Class)
• hashCode()
• initialize()
• hashCode()
• implementsClause()
• getVariable(String)
• gotoPhase(int)
• getValidator()
• getTransformLoader()
• getURI()
• getType()
• hasNext()
• getTimeString(Date)
• getTypeAsString()
• hasPossibleMethod(String, Expression)
• getTheClass()
• getType()
• getThird()
• hasProperty(Object, String)
• handleMissingMethod(ClassNode, String, ArgumentListExpression, ClassNode, MethodCall)
• hashCode()
• identifier()
• getTrueExpression()
• hashCode()
• getVariableScope()
• hashCode()
• getTreeCellRendererComponent(JTree, Object, boolean, boolean, boolean, int, boolean)
• getText()
• getValueAt(int, int)
• getText()
• init(VariableScope, Parameter)
• getVersion()
• hasRuntimeRetention()
• inspect(Object)
• getText()
• inspectAst(EventObject)
• handleRootPaneTasks(FactoryBuilderSupport, Window, Map)
• getTypeAsString()
• getUnescapedUnicodeColumnCount()
• hydrated()
• hasClassNodeToCompile()
• getValues()
• getValue()
• initialize()
• getType()
• getThird()
• getValue()
• getTypeAsString()
• hashCode()
• getTheClass()
• getVariable(String)
• getTextEditor()
• initMetaClass(Object)
• getVariable()
• hasSourceRetention()
• getWeakMetaClass()
• hasNext()
• hasEscapeChar(char[], int, int[])
• getTimeString(Date)
• insert(String)
• identifier(AST)
• getType()
• getTryStatement()
• getValue(Object, int, int)
• getWriter()
• inclusive(boolean)
• handleIncompatibleReturnType(ReturnStatement, ClassNode)
• in(int, Object)
• head()
• getValue()
• getText()
• getVariableType()
• getTimeStamp(Class)
• hasNext()
• innerInterfaceDef(AST)
• getUnexpectedToken()
• getThisObject()
• getYearOfEra(Year)
• hasListeners(String)
• indexed(Iterator<E>, int)
• groovyScriptFactory(String)
• hyperlinkUpdate(HyperlinkEvent)
• getText()
• getType()
• getValues()
• ignore(Object, Closure)
• hasPrevious()
• getTypeChooser()
• handleMissingMethod(ClassNode, String, ArgumentListExpression, ClassNode, MethodCall)
• hasCustomStaticInvokeMethod()
• hasVetoableAnnotation(AnnotatedNode)
• identity(U, Closure<T>)
• getValue()
• innerClass(String, int, Closure)
• indexPropertyArgs(AST)
• hasPossibleStaticProperty(ClassNode, String)
• getTheCachedClass()
• hasClassX(Expression, ClassNode)
• indy(EventObject)
• getWrapped()
• hasEqualPropertyX(PropertyNode, Expression)
• ifElseS(Expression, Statement, Statement)
• hasNext()
• hashCode()
• initialize()
• getType()
• getUnaryExpressionHelper()
• getVersion()
• hasCurrent()
• getUnit()
• hashCode()
• getVariable(String)
• getValueAt(int, int)
• getVariables()
• getText()
• getText()
• getType()
• initialize(Token)
• getText()
• getURL()
• hasProperty(String)
• handleUnresolvedProperty(PropertyExpression)
• getYear(Integer)
• getUnresolvedSuperClass(boolean)
• getUsage()
• getValue()
• gString(String, Closure)
• info()
• hasInitialExpression()
• hasAnnotationDefault()
• hash(Object)
• hasNext()
• inspect()
• getType()
• getTransforms(CompilePhase)
• getTextToRun(boolean)
• handleIncompatibleReturnType(ReturnStatement, ClassNode)
• inferLoopElementType(ClassNode)
• getTheClass()
• getText()
• getText()
• getTypeDescription()
• getText()
• importedPackages()
• identicalExpr(Expression, Expression)
• getVerbosity()
• hasErrors()
• handles(Class<?>)
• hasListeners(String)
• identifier()
• getURI()
• importDefinition()
• getTriggerBinding(PropertyBinding)
• getUserStateDirectory()
• handleUnresolvedAttribute(AttributeExpression)
• hasBindableAnnotation(AnnotatedNode)
• includeGroovy(String)
• getTotal()
• hashCode()
• insertString(FilterBypass, int, String, AttributeSet)
• getTo()
• getTo()
• getTypeClass()
• getVariables()
• hashCode()
• hashCode()
• hashCode()
• hasNext()
• getTypeSourceDescription()
• hasChanged()
• getWrappedClassDescriptor(Type)
• getTypeDescriptor()
• handleNodeAttributes(Object, Map)
• hasPerInstanceMetaClasses()
• hashCode()
• hashCode()
• getThrowsClauseText(ClassNode)
• getYears()
• hashCode()
• getVisibleClasses(List)
• inits(Iterable<T>)
• importedClasses()
• getVersion()
• getUpdateCount()
• getTypeCheckingAnnotations()
• handler()
• getTolerance()
• handleException(SAXException)
• getValue()
• hadEscape()
• getType()
• ifStatement(AST)
• handler()
• hashCode()
• initializer()
• getType()
• initialize()
• hasMetaMethod(String, Class)
• getURLs()
• handleAmbiguousMethods(List<MethodNode>, Expression)
• hasDeclaredMethod(ClassNode, String, int)
• getText(Process)
• getTokensWhitelist()
• handleUnresolvedProperty(PropertyExpression)
• getWarningCount()
• initValue()
• ifS(Expression, Statement)
• include(String)
• hasNext()
• getValue(int)
• hasMethod(String, Parameter)
• handleUnresolvedAttribute(AttributeExpression)
• hadEscape()
• getType()
• hasVisibility(int)
• getText()
• hashCode()
• getTypeClass()
• hasInitialExpression()
• initializeDelegateHelpers()
• implicitParameters()
• getWrapped()
• hideOutputWindow(EventObject)
• inclusiveOrExpression()
• getType(ASTNode)
• handleIncompatibleAssignment(ClassNode, ClassNode, Expression)
• getUnresolvedSuperClass(boolean)
• hasModule(String)
• getType()
• innerClasses(boolean)
• handleAmbiguousMethods(List<MethodNode>, Expression)
• initTemplateEngine(ServletConfig)
• getTo()
• hasNext()
• getTreeCellEditorComponent(JTree, Object, boolean, boolean, boolean, int)
• getTextNodeData(Text)
• getTimeStamp()
• getValue()
• grab(Map<String, Object>, Map)
• getValue()
• getVariableScope()
• hashCode()
• getText()
• inSamePackage(Class, Class)
• getType()
• initialize()
• getTypeChooser()
• getType()
• hashCode()
• hasProperty(Object, String)
• getThird()
• getValues()
• getType()
• implementsInterface(ClassNode)
• getValue()
• inferComponentType(ClassNode, ClassNode)
• getText()
• hashCode(String)
• getValue()
• getVersion()
• groupBy(Map, List<Closure>)
• hasNext()
• inferReturnTypeGenerics(ClassNode, MethodNode, Expression, GenericsType)
• innerClasses(boolean)
• getType()
• getTransformer(ASTNode, SourceUnit)
• inferMapExpressionType(MapExpression)
• getText()
• getText(Path)
• hasLocale()
• getTimeZone(Date)
• getType()
• hasUTF16BEBom()
• handleUnresolvedVariableExpression(VariableExpression)
• getValues()
• hasVariable(String)
• init(ServletConfig)
• getValue()
• getUnit()
• getUnresolvedInterfaces(boolean)
• getValues()
• getType()
• inspectLast(EventObject)
• ignorableWhitespace(char[], int, int)
• getValue()
• getValidator()
• inspect(Object)
• importedPackages()
• hashCode()
• inspect(def)
• getType()
• getText(String)
• handles(Class<?>)
• hasNext()
• increment(Object)
• init(AsmClassGenerator, GeneratorContext, ClassVisitor, ClassNode)
• indexOf(Object)
• getText()
• implementsInterfaceOrSubclassOf(ClassNode, ClassNode)
• getTimestampFromFieldName(String)
• getValues()
• head(T)
• getTokenStartColumn()
• initializeDelegateHelpers()
• hashCode()
• implementsClause()
• inject(E, U, Closure<V>)
• init()
• hasModifiedMetaClass(ExpandoMetaClass)
• hasSetter(PropertyExpression)
• hasUnmatchedOpenBracketOrParen(String)
• getTypeChooser()
• getText()
• getUnresolvedInterfaces(boolean)
• historyPrev(EventObject)
• getVariableScope()
• getUpdatedParams(List<Object>, List<Tuple>)