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>)
• initHash()
• getZoneOffset(Date)
• hasMoreElements()
• getValue()
• groupAnswer(Map<K, List<T>>, T, K)
• hasSingleStringArg(Closure)
• hasNext()
• getVersion()
• handleUnresolvedAttribute(AttributeExpression)
• getType()
• getValue()
• grab(Map, Map)
• hashCode()
• getTransformer(ASTNode, SourceUnit)
• implementsCloneable(ClassNode)
• hashCode()
• getUsage()
• getYears(Integer)
• getTopOperand()
• grow(V)
• getWeeks(Integer)
• getVariableScope()
• getTransformer(ASTNode, SourceUnit)
• hashCode()
• getTheClass()
• getWriter()
• hasMetaProperty(String)
• hasAnnotation(ClassNode, ClassNode)
• getType()
• inspect()
• getVisibility(AnnotationNode, AnnotatedNode, Class<? extends AnnotatedNode>, int)
• info(String)
• getWeakBundle()
• hasCompatibleConfiguration(CompilerConfiguration)
• head()
• getUri()
• hashCode()
• getText()
• getTypeChooser()
• getText(BufferedReader)
• initialize(BSFManager, String, Vector)
• handleUnresolvedProperty(PropertyExpression)
• getTypeCheckingContext()
• handle(String, Throwable)
• initAuxViews()
• getValue()
• init(int)
• getText()
• getThird()
• importDef(AST)
• hasPossibleStaticMethod(String, Expression)
• getType()
• getVerbose()
• hasInitialExpression()
• hashCode()
• hasPackageName()
• hasFiles()
• indexX(Expression, Expression)
• getTreePath()
• hasDeclaredMethod(ClassNode, String, int)
• in(char, int, int, char[])
• getText()
• getText()
• indexOf(Object)
• getVersion()
• getTransformLoader()
• hasClassRetention()
• handleTargetMethodCallExpression(MethodCallExpression)
• getWrapper(ClassNode)
• implementsInterfaceOrIsSubclassOf(ClassNode, ClassNode)
• getUsage()
• handleUnresolvedVariableExpression(VariableExpression)
• hasInitialExpression()
• hasAnnotation(AnnotatedNode, ClassNode)
• hasUTF8Bom()
• importedPackages()
• innerClasses(boolean)
• importedPackages()
• ignoreSyntaxErrorForLineEnding(String)
• hashCode()
• init(AsmClassGenerator, GeneratorContext, ClassVisitor, ClassNode)
• handleNotification(Notification, Object)
• hasStaticProperty(ClassNode, String)
• hasDeclaredMethod(String, Parameter)
• hasCustomInvokeMethod()
• hydrated()
• getType()
• identPrimary()
• getUndoAction()
• getWeek(Integer)
• hasEqualFieldX(FieldNode, Expression)
• hasGroup(Matcher)
• hashCode()
• getVersion()
• initialize()
• init(ServletConfig)
• getText()
• inits(Iterable<T>)
• getText()
• getVariable(String, boolean)
• getType()
• getVariables()
• handleIncompatibleReturnType(ReturnStatement, ClassNode)
• getType()
• getValue()
• getType()
• hasProperty(Object, String)
• handleMissingMethod(ClassNode, String, ArgumentListExpression, ClassNode, MethodCall)
• handleException(Exception)
• getUnresolvedName()
• hashCode()
• hasChar()
• getUnaryExpressionHelper()
• hasNext()
• importedClasses()
• isDefaultMethod(Method)
• isHandlesNodeChildren()
• invokeNewN(Class, Class, Object)
• isLeaf()
• isInStaticContext()
• invokeMethod(String, Object)
• intValue()
• isExcludingFieldsNamed(String)
• isScriptBody()
• isFloat(String)
• isFocused()
• invokeMethodOnCurrent0(Class, GroovyObject, String)
• isGlobalTrimWhitespace()
• isInitialized()
• isLeaf()
• isError()
• isEnum()
• isEmpty()
• isPreviewFeatures()
• isDynamicReturnType()
• isCachable()
• isFinal()
• invokeMethod0(Class, Object, String)
• isDirectlyAssignable(Object)
• isStatic(InnerClassNode)
• isAuthorized(Expression)
• isTrueExpr(Expression)
• intdiv(long, long)
• invokeMethod(String, Object)
• invokeMethod(String, Object)
• isLazyDefaultValues()
• isInClosure()
• isClass()
• invokeMethod(Class, Object, String, Object, boolean, boolean)
• isIncluded()
• isDirectlyAssignable(Object)
• isOrigZ()
• isEmpty()
• invokeMethod(Object, String, Object)
• isCompatibleWith(ClassNode)
• isNotExplicitThisInClosure(boolean)
• invokeMethod(String, Object)
• isLoggingMethod(String)
• isAssignableFrom(Class)
• invokeMethod(String, Object)
• isRecompilable(Class)
• isHandlesNodeChildren()
• isGroovy()
• isModified()
• invokeMethod(String, Object)
• isPhaseComplete()
• isDefaultVisibility(int)
• isLoggingMethod(String)
• is(Object, Object)
• isError()
• isAuthorized(Statement)
• invoke(Object, Object)
• isProtected()
• isUnwrapped()
• isFloatingPoint(def)
• invoke(String, Object, String)
• isError()
• isSynthetic()
• isAnnotatedBy(ASTNode, ClassNode)
• isSynchronized()
• invokeMethodOnSuperNSafe(Class, GroovyObject, String, Object)
• invokeStaticMethod(Object, String, Object)
• isPublic()
• isClass()
• isClassNode()
• isPublic()
• isStatic()
• intValue()
• isTargetAllowed(int)
• isPostJDK9(String)
• isNonpositive(ChronoPeriod)
• invokeMethod0Safe(Class, Object, String)
• isReverse()
• isCellEditable(int, int)
• isContainer()
• installInterceptor()
• isExpanded()
• isDynamic()
• isNumericTypeSpecifier(char, boolean)
• isNullConstant(Expression)
• isAutoIndent()
• isNumber(String)
• isInclusive()
• intdiv(Number, Number)
• invokeMethod(String, Object)
• isDynamic()
• isDerivedFrom(ClassNode)
• isPrivate()
• isAbstract()
• isNumberOrArrayOfNumber(ClassNode, boolean)
• isDigit(char)
• invoke(Object, Object)
• isIgnoringAutoboxing()
• isSourceNewer(GroovyScriptEngine.ScriptCacheEntry)
• isStar()
• isGenericSetMethod(MetaMethod)
• isHandlesNodeChildren()
• isNumberCategory(ClassNode)
• intArrayGet(int[], int)
• isConstantString()
• isEmpty()
• isOrigInt()
• isCase(Object, Object)
• isLongCategory(ClassNode)
• isClass()
• isClosureSharedVariable()
• isDirectlyAssignable(Object)
• isISO8601(char[], int, int)
• isOvertypeMode()
• isLazyChop()
• isEnumSubclass(Object)
• isFastPath()
• invalidateCallSites()
• invoke(Object, Object)
• invokeMethodOnSuperN(Class, GroovyObject, String, Object)
• isStatic()
• isThisExpression(Expression)
• integerExpression(AST)
• invoke(Object, Object)
• isDebug()
• isDoubleCategory(Class)
• isClassClassNodeWrappingConcreteType(ClassNode)
• isSafe()
• instantiateAggregateFromInterface(Map, Class)
• isUseDoubleQuotes()
• invokeStaticMethod(Object, String, Object)
• isOrigIntArray()
• invokeStaticMethod(Object, String, Object)
• invokeMethod(String, Object)
• invokeMethod(String, Object)
• isAutoEscape()
• isEmpty(Iterable)
• isCoreObjectMethod(Method)
• isFinal()
• isAssignableFrom(Class)
• isHandlesNodeChildren()
• invoke(Object, Object)
• isExpandEmptyElements()
• isFatal()
• isProtected()
• isAbstract()
• isEnum()
• invokeStaticMethod(Class, String, Object)
• isOrigByte()
• isColfill()
• isPackageAllowed()
• isNonnegative(ChronoPeriod)
• isDirectlyAssignable(Object)
• isInitialized()
• isOrigCArray()
• isEmpty()
• isIncluded()
• invokeStaticMethod0(Class, Class, String)
• isDynamic(VariableExpression)
• isDelimiter(int)
• isStatic()
• invokeSuperMethod(Object, String, Object)
• isRunningAndroid()
• isNumberDigit(int)
• isNull(Object)
• isDynamicTyped()
• intValue()
• isNotClinit()
• isCallingClassReflectionAvailable()
• isField()
• interfaces()
• isExcludingValues(Object)
• isSynthetic()
• isReferencedClassVariable(String)
• isDirectlyAssignable(Object)
• isEscape(int)
• isUseReferenceDirectly()
• isEnableNamedQueries()
• isClosureSharedVariable()
• isOrigDArray()
• isAllOf(int[])
• isEmpty()
• isEmpty()
• isDebug()
• isLeaf()
• isEnumEnabled()
• isStaticallyCompiled(AnnotatedNode)
• invoke(Object, Object)
• isClosuresAllowed()
• isMethodCall(Object)
• invokeMethodOnCurrentNSafe(Class, GroovyObject, String, Object)
• invokeMethod(String, Object)
• isInClosure()
• invoke(Object, Object)
• isDecimalChar(int)
• isOrigZArray()
• isTabsAsSpaces(boolean)
• isEmpty()
• isPrimitive()
• interfaceExtends()
• invoke(Object, Object)
• isArray()
• isSyntheticPublic()
• invokeMethod(String, Object)
• isDynamicTyped()
• invokeClosure(Object, Object)
• isQuiet()
• isEmpty()
• invalidateCallSites()
• invoke(Object, Object)
• isStaticClass()
• isGlobalKeepIgnorableWhitespace()
• isStaticExtension()
• isHandlesNodeChildren()
• isLeaf()
• isEmpty()
• isPublic()
• isJavaIdentifier(String)
• invokeStaticMethod(Object, String, Object)
• isNotExplicitThisInClosure(boolean)
• isSAMType(ClassNode)
• isAssignableFrom(Class)
• invokeMethod(String, Object)
• isInteger(char[], int, int)
• isNonChangeCheck()
• isUndefinedException(ClassNode)
• isApplicationClass(String)
• invoke(Object, Object)
• isAnnotationType()
• isEditable()
• invoke(Object, Object)
• isTraitSelf(VariableExpression)
• isDeprecated()
• interfaces()
• isLeaf()
• isMethodDefinitionAllowed()
• isPrivate()
• isCase(String, Object)
• invokeMissingProperty(Object, String, Object, boolean)
• isAnnotationCompatible()
• invokeMissingMethod(Object, String, Object)
• invoke(Object, Method, Object)
• isDynamic()
• isAssertEnabled()
• isDirectlyAssignable(Object)
• isField()
• isOrigDouble()
• invokeMethod(String, Object)
• isBigDecimal(Number)
• isLeaf()
• invokeMethod(String, Object)
• isClosureSharedVariable()
• isInterface()
• isLeaf()
• invokeGroovyObjectInvoker(MissingMethodException, Object, String, Object)
• invoke(Object, Object)
• isProtected()
• isTransient()
• isUnboundedWildcard(GenericsType)
• isParameterizedWithGStringOrGStringString(ClassNode)
• isIntCategory(ClassNode)
• isInitialized()
• isEscapeBackslash()
• inspectVariables(EventObject)
• intdivImpl(Number, Number)
• isAnExpression()
• isEmpty()
• isLeaf()
• invoke(Object, Object)
• isCommand(String, CommandRegistry)
• isClassNode()
• isOrImplements(ClassNode, ClassNode)
• interfaceExtends()
• isImplicitThis()
• isFloat(String)
• isInterface()
• isSameMetaClass(MetaClass, Object)
• invokeMethod(Class, Object, String, Object, boolean, boolean)
• isCase(String, Object)
• isPrivate()
• invoke(Object, Object)
• isPublic()
• isModified()
• isUsingGenericsOrIsArrayUsingGenerics(ClassNode)
• isMultipleAssignmentDeclaration()
• invoke(Object, Object)
• isStaticContext()
• interfaceField()
• isFinal()
• invoke(Object, Method, Object)
• isUsingGenerics()
• isDeprecated()
• isLeaf()
• isAssignment(int)
• interfaceDef(AST)
• invoke(Object, Object)
• isCoerce()
• isOrigC()
• invokeHandle(Object, Object)
• isDoubleQuote(int)
• isInstanceof(ClassNode, Expression)
• isLetter(Character)
• isPackageScope()
• isPreserveWhitespace()
• isAnnotationType()
• invokeMethodNSafe(Class, Object, String, Object)
• isResolved()
• isFinal()
• isDouble(String)
• isFloatingCategory(ClassNode)
• isOrigBArray()
• isCacheable()
• isTrait(Class<?>)
• isHexDigit(char)
• isNative()
• isAbstract()
• isDynamicTyped()
• isContainer()
• invoke(Object, Object)
• isDirectlyAssignable(Object)
• isOctalDigit(char)
• invokeHandle(Object, Object)
• is(Object)
• isCellEditable(int, int)
• interfaceBlock()
• isAbstract()
• isAbstract()
• isKeepIgnorableWhitespace()
• invokeMethod(String, Object)
• invokeMethod(Class, Object, String, Object, boolean, boolean)
• isAssignableFrom(Class)
• isNullConstant(Expression)
• instanceofExpression(AST)
• isClassMBean(Class)
• isAbsolute()
• isInteger(String)
• isScriptBody()
• isOrigShort()
• isDirectlyAssignable(Object)
• isBuiltIn()
• isPackagePrivate()
• interfaceField()
• invoke(Object, Object)
• invoke(Object, Object)
• intValue()
• isClassLiteralPossible(ClassNode)
• invokeMissingMethod(Object, String, Object)
• isMethod()
• isDerivedFromGroovyObject()
• isPrivate()
• isFastPath()
• isAssignableFrom(Class)
• isAbstract()
• invokeMethodOnCurrent0SpreadSafe(Class, GroovyObject, String, Object)
• isLong(def)
• isOrdinaryClass()
• isLong(char[], int, int)
• invoke(Object, Object)
• isSerializable()
• isOneExpr(Expression)
• isStatic(Method)
• isNamespaceAware()
• invoke(Object, Object)
• invokeHandle(Object, Object)
• isUsingGenerics()
• isKnownImmutableType(ClassNode, List<String>)
• isDecimalDigit(int)
• invoke(Object, Object)
• invokeMethodN(Class, Object, String, Object)
• isAtLeastJdk(String)
• isAnnotationType()
• isSpreadSafe()
• isSuperExpression()
• isFatal()
• isEqual(K, int)
• intArraySet(int[], int, int)
• isInfo()
• isExternalizable()
• isFloatingPoint(Number)
• isHolder()
• invoke(Object, Object)
• invokeMethod0SpreadSafe(Class, Object, String)
• isPublic()
• isAssignableFrom(Class)
• isChop()
• isSetter(String, CachedClass)
• isPrimitive()
• invokeMissingMethod(Object, String, Object)
• inverse(Map<K, V>, boolean)
• invoke(Object, Object)
• isCacheTemplates()
• interfaceTypes()
• isUsingUncheckedGenerics(ClassNode)
• isEmpty()
• isInteger(String)
• isProtected()
• invokeMethod(Object, String, Object)
• isLong(String)
• isAssignableFrom(Class, Class)
• isIncluded()
• isPublic()
• isClassScope()
• isPrimitiveTypeLiteral(AST)
• invokeMethod(String, Object)
• isAutoNewLine()
• isCase(Object)
• isLHS()
• isOrigFArray()
• invokeMethod(String, Object)
• isModified()
• isOrigF()
• invokeMethod(Object, String, Object)
• isNative()
• isEmpty()
• invokeMethod(String, Object)
• isSuperclass(Class, Class)
• isThisExpression()
• isSkipMode(AnnotatedNode)
• isAnnotationExpression(CompilationFailedException, String)
• isClass()
• isRecursive(MethodNode, StaticMethodCallExpression)
• isKeepIgnorableWhitespace()
• isNumberType(ClassNode)
• isEmpty()
• isFinal()
• isOrigD()
• isEnumConstant()
• isSecondPassNeededForControlStructure(Map<VariableExpression, ClassNode>, Map<VariableExpression, List<ClassNode>>)
• isAbstract()
• isImplicitThis()
• isBuildInvocation(MethodCallExpression)
• interfaces(Closure)
• isEmpty()
• invokeMethodOnSuper0SpreadSafe(Class, GroovyObject, String, Object)
• isEmpty()
• invokeMethod(String, Object)
• invoke(Object, Object)
• isAssignableFrom(Class)
• isClosureSharedVariable()
• isTypeAvailable()
• invalidateSwitchPoints()
• intdivImpl(Number, Number)
• isOrigInt()
• invokeMissingProperty(Object, String, Object, boolean)
• isCompareToBoolean(int)
• isValidAttribute(AbstractASTTransformation, AnnotationNode, String)
• isLoggingMethod(String)
• isPrefixRegistered(String, String)
• isCachedType(ClassNode)
• isHandlesNodeChildren()
• isShort(Number)
• isLazyReferencesAllowed()
• isExcludingFieldsNamed(String)
• isAssignableFrom(Class)
• isStatic()
• isAnnotationType()
• invokeMethod(String, Object)
• invoke(Object, Object)
• isOmitNullAttributes()
• intdivImpl(Number, Number)
• instantiateAggregate(Map, List<Class>, Class, Object)
• invokeMethod(String, Object)
• isDefaultRenderer()
• invokeMethod(String, Object)
• isEmpty()
• isClosureCall(String, Expression, Expression)
• isExtensionMethod(MethodNode)
• isEmpty()
• isAnnotationTypeElement()
• isScript()
• invokeClosure(Object, Object)
• isOneX(Expression)
• isPackagePrivate()
• invokeStaticMethod(Object, String, Object)
• isSelected()
• invokeMethodOnSuperNSpreadSafe(Class, GroovyObject, String, Object)
• invokeMethod(String, Object)
• isParameterSpecified()
• isStatic()
• isKeepJavaMetaClasses()
• isException()
• isJsonDate(char[], int, int)
• isInt(ClassNode)
• isHandlesNodeChildren()
• isSerializable()
• invokeMethod(String, Object)
• invokeMethodOnCurrent0Safe(Class, GroovyObject, String, Object)
• isReverse()
• isSynchronized()
• isPrimaryClassNode()
• isTrueExpression()
• isAnExpression()
• interfaces()
• invoke(Object, Object)
• isContainer()
• isReverse()
• isInStaticContext()
• isPublic()
• isOrigS()
• isTypeOrArrayOfType(ClassNode, ClassNode, boolean)
• interfaces(AST)
• isEmpty()
• invokeMethodOnSuper0Safe(Class, GroovyObject, String, Object)
• isStatic()
• isHandlesNodeChildren()
• isValid()
• isEmpty()
• invalidateCallSites()
• isStaticContext()
• instantiateDelegateWithBaseClass(Map, List<Class>, Object, Class, String)
• isAnnotatedWithTrait(ClassNode)
• isInterface()
• isPrivate()
• isPlaceholder()
• invoke(Object, Object)
• interfaces()
• isDynamic()
• intervalAdded(ListDataEvent)
• invokeMethod(String, Object)
• isMethodNode()
• isOrigSArray()
• isAllWhitespace(String)
• isSynthetic()
• isClosureSharedVariable()
• isAbstract()
• isSpreadSafe()
• isAssignableFrom(Class)
• isNumber(String)
• isBeingCompiled(ClassNode)
• isEmpty()
• isRelevant(int)
• isUpperCase(Character)
• isStatic()
• isBigIntCategory(ClassNode)
• isProtected()
• isError()
• invokeMethodOnCurrentNSpreadSafe(Class, GroovyObject, String, Object)
• isDigit(Character)
• isException()
• isUndefined(ClassNode)
• instantiateDelegate(Map, List<Class>, Object)
• invoke(Object, Object)
• invoke(CachedMethod, Object, Object)
• isExternalizable()
• isDynamicTyped()
• isExecutable(String)
• interfaceTypes()
• invoke(Object, Object)
• invokeCustom(Object, Method, Object)
• isInStaticContext()
• invoke(Object, Object)
• isLeaf()
• invokeMethod(String, Object)
• isFatal()
• invokeMethodOnSuper0(Class, GroovyObject, String)
• instantiateAggregateFromBaseClass(Map, Class, Object)
• intUnbox(Object)
• isStatic()
• invokeCustom(Object, Method, Object)
• isClosureSharedVariable()
• isAnnotationDefinition()
• isInterface()
• isArray(Class)
• isType(int, AST)
• isBigDecCategory(Class)
• isDynamicTyped()
• internalError(String)
• isRedirectNode()
• isAllWhitespace(String)
• isBlank(CharSequence)
• isBigDecCategory(ClassNode)
• isDirectlyAssignable(Object)
• isNumberDigit(int)
• isBigInteger(Number)
• isSourceUnit()
• isNotClinit()
• invoke(Object, Object)
• inspectTokens(EventObject)
• isOrigL()
• isEmpty()
• isHandlesNodeChildren()
• isUseReferenceDirectly()
• isInStaticContext()
• isStrict()
• invokeTextAction(def, def, def)
• isEnum()
• isOrigIntArray()
• interfaceTypes()
• isStatic()
• isStaticMethod()
• invoke(Object, Object)
• isDirectlyAssignable(Object)
• isExcludingValues(Object)
• isSaveStreams()
• isGenericsPlaceHolder()
• isDisableCustomMetaClassLookup()
• isPublicClass(String)
• isStatic()
• isEnum()
• intValue()
• invokeStaticMethod(Object, String, Object)
• invokeMethod(String, Object)
• isLowerCase(Character)
• isGroovy()
• isPrivate()
• isInScriptBody()
• isCacheNamedQueries()
• isOrigFloat()
• invoke(Object, Object)
• isExpandEmptyElements()
• isEditable()
• isReferencedLocalVariable(String)
• intdivImpl(Number, Number)
• isDirectlyAssignable(Object)
• invoke(Object, Object)
• isLong(String)
• isOrdinaryClass()
• isCoreObjectMethod(Method)
• invokeMethod(String, Object)
• isPrimitiveType(ClassNode)
• isFinal()
• isImplicitThis()
• isField()
• isPrivate()
• isEmpty(NodeList)
• invokeMissingMethod(Object, String, Object)
• isInitialized()
• isProtected()
• isStatic()
• invokeStaticNoArgumentsMethod(Class, String)
• isUseReflection()
• isSourceNewer(URL, Class)
• isExternalizable()
• isClassInnerClassOrEqualTo(ClassNode, ClassNode)
• isIncluded()
• isDeprecated()
• isRoot()
• invokeMethod(Class, Object, String, Object, boolean, boolean)
• invokeNew0(Class, Class)
• isTypeAvailable()
• isStatic()
• isSerializable()
• isPostJDK5(String)
• isOrdinaryClass()
• isPrimitive()
• invoke(Object, Object)
• isStaticConstantInitializerType(ClassNode)
• isReverse()
• isPackagePrivate()
• isArrayAccessExpression(Expression)
• isDouble(String)
• isEscapeAttributes()
• interfaces()
• invokeMethod(String, Object)
• isLeaf()
• isPublic()
• interfaceBlock()
• interfaceDefinition(AST)
• isPrivateBridgeMethodsCallAllowed(ClassNode, ClassNode)
• isCollectionWithClosure(Object)
• isOrigChar()
• invokeMissingProperty(Object, String, Object, boolean)
• invokeStaticMethod(Object, String, Object)
• isDynamic()
• isIntCategory(Class)
• isResolved()
• isEnum()
• isShouldRecompile()
• invokeMethodNSpreadSafe(Class, Object, String, Object)
• isLeaf()
• invokeMethod(Class, Object, String, Object, boolean, boolean)
• isAnonymous()
• isLoggingMethod(String)
• isMethod()
• isEffectivelyFinal(Variable)
• isStaticMethod()
• isDynamic()
• isEofToken(Token)
• isTypeOrMethodDeclaration(List<String>)
• isOrImplements(ClassNode, ClassNode)
• isAssignableFrom(Class)
• isInStaticContext()
• isEmptyStringExpression()
• isNullConstant(Expression)
• isModified()
• isPrimitive()
• isMethod(MetaMethod)
• isPublic(Method)
• isSyntheticPublic()
• isLeaf()
• isDirectlyAssignable(Object)
• isEmpty()
• interfaceTypes()
• isLeaf()
• isOrigB()
• isEqualityCheck()
• isGStringOrGStringStringLUB(ClassNode)
• invoke(Object, Object)
• isIncludeDestClasses()
• isBuiltinImmutable(String)
• invokeMethodSafe(Object, String, Object)
• isDelimiter(int)
• invokeFunction(String, Object)
• isTrait()
• isFinal()
• isReturningNullOrVoid()
• isFloat(ClassNode)
• isResolved()
• isTransient()
• isHeldExclusively()
• isStatic()
• isValid()
• installAnsi()
• isSerializable()
• isLetterOrDigit(Character)
• isStatic()
• isHandlesNodeChildren()
• invoke(Object, Object)
• isDecimalChar(int)
• isInScriptBody()
• isLong(Number)
• isAssignableFrom(Class)
• isIndirectImportCheckEnabled()
• isStatic()
• isEnum()
• isInterface()
• isValidExactMethod(Class)
• isException()
• isMopMethod(String)
• isBigDecimal(String)
• invoke(Object, Object)
• isPrivate()
• isDynamicTyped()
• isA(int)
• interfaces()
• invoke(Object, Object)
• isFalseExpression()
• isSet(String)
• isLeaf()
• isDouble(ClassNode)
• isBigInteger(String)
• installAutoTabAction(JTextComponent)
• isEmpty()
• isKeyword(String)
• isDeprecated()
• isInStaticContext()
• IntRange(boolean, int, int)
• intersect(Map<K, V>, Map<K, V>)
• isInStaticContext()
• isMethod()
• isNullExpression()
• isOneOf(int[])
• invokeMethod(Class, Object, String, Object, boolean, boolean)
• isMethod()
• isEmpty()
• invoke(Object, Object)
• isBigDecimal(String)
• isCheckDates()
• isPerInstanceMetaClassChange()
• isAssignableFrom(Class, Class)
• isLoggingMethod(String)
• isISO8601QuickCheck(char[], int, int)
• isDynamicTyped()
• invoke(Object, Object)
• isEmpty()
• isSkippedInnerClass(AnnotatedNode)
• invokeMissingProperty(Object, String, Object, boolean)
• invokeMethodOnCurrentN(Class, GroovyObject, String, Object)
• isDoubleCategory(ClassNode)
• isBigInteger(String)
• isEnumConstant()
• isEditable()
• isPrimitive()
• isCacheStatements()
• invokeMethod(Class, Object, String, Object, boolean, boolean)
• invokeStaticMissingProperty(Object, String, Object, boolean)
• isEditable()
• isEmpty()
• isOrdinaryClass()
• isUsingGenerics()
• isGroovyObject()
• invokeCustom(Object, Method, Object)
• isEnumConstant()
• isParameterizedWithString(ClassNode)
• isDynamic()
• isStaticMethodCallOnClass(MethodCall, ClassNode)
• isAnnotationTypeElement()
• isSame(MetaMethod)
• isScript()
• isTrueX(Expression)
• isInteger(Number)
• isExternalizable()
• invoke(Object, Object)
• isHolder()
• isEnumConstant()
• isAnnotationTypeElement()
• isEmpty()
• invokeMethod(Object, String, Object)
• invoke(Object, String, Object)
• isInnerClass(ClassNode)
• isCompilable(CachedMethod)
• isAssignableFrom(Class)
• invoke(Object, Object)
• invoke(Object, Object)
• invokeMethod(Object, String, Object)
• isOrigBool()
• isOrigLArray()
• isSameCompilationUnit(ClassNode, ClassNode)
• isValid()
• invokeStaticMethod(Object, String, Object)
• isLoggingMethod(String)
• isLeaf()
• isEmpty()
• isEmpty()
• interfaceDefinition(AST)
• isGenerated(MethodNode)
• isProtected()
• isContainer()
• isAnnotationTypeElement()
• isTrimWhitespace()
• isException()
• isOmitEmptyAttributes()
• isValidAccessorName(String)
• isAssignableFrom(Class)
• invoke(Object, Object)
• isPostJDK7(String)
• isLongCategory(Class)
• isTableHeader()
• isNamespaceAware()
• isPrimitiveType(ClassNode)
• isAbstract()
• isBridgeMethod(Method)
• isEqual(K, int)
• isEligible(String, int)
• isOrigLong()
• isField()
• isByte(Number)
• isInstanceOfX(Expression, ClassNode)
• isPackagePrivate()
• isRecording()
• isLeaf()
• invokeStaticMethodN(Class, Class, String, Object)
• isGroovyObject()
• invoke(Object, Object)
• invoke(Object, Object)
• isIndyEnabled()
• isReverse()
• isDigit(int)
• isSafe()
• isDynamicTyped()
• isStatic()
• invoke(Object, Object)
• invokeMethod(String, Object)
• isDebugEnabled()
• isRowfill()
• intervalRemoved(ListDataEvent)
• isExpandEmptyElements()
• isFastPath()
• intdiv(Number, Number)
• isAssignableFrom(Class)
• isPostJDK8(String)
• invokeMethod(String, Object)
• isCacheable()
• isMultiLineTabbed(boolean)
• isPositive(ChronoPeriod)
• isAnnotated()
• mapEntry(Map)
• keySet()
• loadOutputTransforms()
• matching(String)
• makeNodeWithProperties(Object, List<List<String>>)
• makeArray()
• matches(ASTNode)
• longValue()
• loadTest(String)
• listener(EvictionListener<K, V>)
• makeCachedCall(Expression, ClassExpression, Expression, Expression, Expression, MethodCallerMultiAdapter, boolean, boolean, boolean, boolean)
• iterator(JTabbedPane)
• makeGetPropertySite(Expression, String, boolean, boolean)
• makeDescriptorWithoutReturnType(MethodNode)
• leftShift(long, long)
• macro(CompilePhase, boolean, String, List<Closure<Expression>>, Class<T>)
• mBOR_ASSIGN(boolean)
• isWithinBatch()
• keys()
• makeCompileUnit(GroovyClassLoader)
• main(String)
• mESC(boolean)
• longUnbox(Object)
• makeArray(Object, Class, int)
• match(String)
• iterator(NodeList)
• leftShift(String)
• lookAndFeel(Object, Map, Closure)
• isWeekday(DayOfWeek)
• load(ClassNode, int)
• main(String)
• main(String)
• mergeNewPackages(Collection<String>, URL, Map<String, CachedPackage>)
• leftShift(Command)
• mBAND(boolean)
• max(Iterable<T>)
• loadClass(String, boolean)
• lpad(char[], int, char)
• makeDelegateCall(String, String, String, String, int)
• makeProxyInstance(def, boolean)
• iterator()
• makeController(WriterController)
• iterable()
• marshal(JAXBContext, T)
• list()
• makeCallSiteArrayInitializer()
• len()
• makeOutputArea(String)
• matchFiles(String, String, File, List<CharSequence>)
• iterator()
• main(String)
• lookAndFeel(Object)
• length()
• mapX(List<MapEntryExpression>)
• keys()
• mASSIGN(boolean)
• iterator()
• mAT(boolean)
• markAsExpression()
• loadArguments(List<Expression>, Parameter)
• iterateClassNodeToCompile()
• main(String)
• makeCallSite(Expression, String, Expression, boolean, boolean, boolean, boolean)
• length()
• ManagedLinkedList(ReferenceBundle)
• makeGenericsType(AST)
• makeWithoutCaching(String)
• keys()
• match(String)
• listIterator(int)
• list2args(List)
• layout(Map, String, boolean)
• loadClass(String)
• makeOutputArea(String)
• makeDeclaringAndActualGenericsTypeMap(ClassNode, ClassNode)
• maybeRecordInput(String)
• listOfVariables(AST, AST, Token)
• main(String)
• main(String)
• mCOLON(boolean)
• markAsExpression()
• leftShift(Month, Year)
• maybeRecordResult(Object)
• main(String)
• leftShiftImpl(Number, Number)
• len()
• isValidMethod(Class)
• makePrefix(CSTNode, boolean)
• jump(int, Label)
• ltX(Expression, Expression)
• largerFont(EventObject)
• loadWrapper(Expression)
• maybeRecordError(Throwable)
• loadGroovySource(String)
• list(NodeList)
• main(def)
• mapExpression(AST)
• keySet()
• iterator(DataInputStream)
• keySet()
• leftShift(Socket, byte[])
• main(String)
• markSupported()
• localText()
• join(short[], String)
• makeModule()
• keys()
• matches(String, Pattern)
• map(Closure)
• mark(int)
• makeCall(Expression, ClassExpression, Expression, Expression, Expression, MethodCallerMultiAdapter, boolean, boolean, boolean)
• makeNodeWithProperties(Object, List<List<String>>)
• leftShift(JToolBar, Action)
• loadThisOrOwner()
• makeSingleArgumentCall(Expression, String, Expression)
• length()
• matchesPartially(Matcher)
• makeTransitiveHull()
• keySet()
• mBSR_ASSIGN(boolean)
• makeProxyInstance(def, boolean)
• makeClassSafe(Class)
• keySet()
• main(String)
• loadScriptByName(String)
• lookupClassNodeFor(String)
• matchRegex(Object, Object)
• log(String)
• main(String)
• make(ClassNode)
• makeGroovyObjectGetPropertySite(Expression, String, boolean, boolean)
• makeClassForNameCall(Expression, Expression, Expression, Expression)
• loadMaxOutputChars()
• lowestUpperBound(ClassNode, ClassNode)
• localText(Element)
• makeUncachedCall(Expression, ClassExpression, Expression, Expression, Expression, MethodCallerMultiAdapter, boolean, boolean, boolean, boolean)
• makeSingleArgumentCall(Expression, String, Expression)
• iterator()
• makeCommonArray(Object, int, Class)
• makeClassSafeWithGenerics(ClassNode, GenericsType)
• leftShift(Object)
• lookupNamespace(String)
• mBXOR_ASSIGN(boolean)
• makeNode(Object)
• keySet()
• makeDirectCall(Expression, Expression, Expression, Expression, MethodCallerMultiAdapter, boolean, boolean)
• mark(int)
• loadReference(String, WriterController)
• mBOR(boolean)
• listDependencies(ClassLoader)
• iterator()
• iterator()
• leftShift(Process, byte[])
• knownImmutableClasses()
• main(String)
• loadOutputTransforms$$bridge()
• iterator()
• mark(int)
• loadFunction(String)
• knownImmutables()
• last(T)
• leftShift(OutputStream, byte[])
• member(String, Closure)
• listAttributeValues()
• isVolatile()
• makeOutputArea(String)
• makeDirectCall(Expression, Expression, Expression, Expression, MethodCallerMultiAdapter, boolean, boolean)
• matchRegex(Object, Object)
• lock()
• memoizeAtLeast(int)
• makeCallSite(Expression, String, Expression, boolean, boolean, boolean, boolean)
• isValidExpandoProperty(String)
• macro(MacroContext, PropertyExpression, ConstantExpression, ClosureExpression)
• isValidOutputArea(String)
• keySet()
• iterator()
• iterator()
• matchByClass(Class<ASTNode>)
• main(def)
• iterator()
• makeParameter(CompileUnit, Type, Class, Annotation, String)
• list()
• listDependencies(ClassLoader)
• mBNOT(boolean)
• label(String)
• longValue()
• loadStaticField(FieldExpression)
• longValue()
• mDIV_ASSIGN(boolean)
• makeTypeWithArguments(AST)
• items()
• lArrayGet(long[], int)
• iterator()
• listClasspath(EventObject)
• makePostfix(CSTNode, boolean)
• isVoid()
• logicalAndExpression(int)
• listOperationNames()
• mCHAR_LITERAL(boolean)
• keySet()
• mDIGITS_WITH_UNDERSCORE_OPT(boolean)
• lastIndexOf(Object)
• listAttributeNames()
• loadInstanceField(FieldExpression)
• main(String)
• matches(ASTNode, ASTNode)
• makeCallSite(Expression, String, Expression, boolean, boolean, boolean, boolean)
• logicalOrExpression()
• matches(String, Pattern)
• makeSingleArgumentCall(Expression, String, Expression)
• leftShift(StringBuilder, Object)
• markAsGenerated(ClassNode, T)
• loadOrStoreVariable(BytecodeVariable, boolean)
• makeDynamic(VariableExpression, ClassNode)
• loadDriver(String)
• list(Closure)
• listExpression(AST)
• load(URL)
• mDIGITS_WITH_UNDERSCORE(boolean)
• iterator()
• makeNodeWithProperties(Object, List<List<String>>)
• makeGetPropertySite(Expression, String, boolean, boolean)
• iterator()
• keySet()
• loadTestSuite()
• me(String, Object, String)
• makeReference()
• main(String)
• loadFromRes(String)
• merge(ConfigObject)
• isVerbose()
• mDEC(boolean)
• isVolatile()
• iterator()
• marshal(JAXBContext, T)
• literalExpression(AST, Object)
• leftShift(File, InputStream)
• iterator()
• makeSiteEntry()
• main(String)
• main(String)
• leftShift(Number, Number)
• labelledStatement(AST)
• main(String)
• matchGenericTypeBracketsFailed(String, String)
• isVarArgs()
• iterator()
• make(Map)
• main(String)
• keySet()
• main(def)
• mDIGIT(boolean)
• main(String)
• main(String)
• loadClass(String, boolean)
• mCOMMA(boolean)
• leftShift(Object)
• len()
• markSupported()
• location()
• length()
• loadClass(String, boolean, boolean, boolean)
• iterator()
• make(LexerSharedInputState)
• memoizeBetween(int, int)
• listIterator(int)
• makeToken(int, AST)
• make(LexerSharedInputState)
• keywordPropertyNames()
• main(String)
• lookup(String, int)
• loadClass(String, boolean)
• main(String)
• isWildcard()
• location()
• makeArgumentList(Expression)
• memoizeAtMost(int)
• logMethodCall(Object, String, Object)
• isVoidMethod()
• makeCallSiteArrayInitializer()
• makeGroovyObjectGetPropertySite(Expression, String, boolean, boolean)
• isValidMethod(Object)
• isWhitespace(Character)
• loadUserScript(String)
• isWrapped()
• leftShiftImpl(Number, Number)
• makeSingleArgumentCall(Expression, String, Expression)
• leftShift(File, InputStream)
• main(def)
• makeEnumNode(String, int, ClassNode, ClassNode)
• listIterator(int)
• maximumWeightedCapacity(long)
• iterator()
• makeController(WriterController)
• loadClass(String, boolean)
• main(String)
• isWildcardLeftHandSide(ClassNode)
• lookupKeyword(String)
• length()
• iterator()
• makeClassSafe0(ClassNode, GenericsType)
• isZeroExpr(Expression)
• lastIndexOf(Object)
• makeClosureClassTreeNodes(ClassNode)
• makeCall(Expression, Expression, Expression, Expression, MethodCallerMultiAdapter, boolean, boolean, boolean)
• main(String)
• keys()
• iterator()
• iterator()
• macroMethod(T)
• lock()
• len()
• lookupSymbol(String)
• matches(Closure<Boolean>)
• iterator(ResultSetMetaData)
• make(String)
• mDIV(boolean)
• mBSR(boolean)
• makeCachedCall(Expression, ClassExpression, Expression, Expression, Expression, MethodCallerMultiAdapter, boolean, boolean, boolean, boolean)
• largerFont(EventObject)
• listOperationDescriptions()
• makeCallSiteArrayInitializer()
• makeSiteEntry()
• keys()
• leftShift(StringBuilder, Object)
• iterator(ResultSetMetaData)
• list()
• main(String)
• lowerBound(Class)
• md5(byte[])
• iterator()
• isWeekend(DayOfWeek)
• mark()
• items()
• iterator(Matcher)
• map()
• isVolatile()
• makeGroovyObjectGetPropertySite(Expression, String, boolean, boolean)
• leftShift(Object)
• load(ClassLoader)
• items()
• lArraySet(long[], int, long)
• keySet()
• makeSingleArgumentCall(Expression, String, Expression)
• memberHasValue(AnnotationNode, String, Object)
• logicalOrExpression(int)
• makeType(AST)
• main(String)
• matches(Object)
• loadClass(String, boolean)
• lookup(ClassNode, String)
• makeGetPropertySite(Expression, String, boolean, boolean)
• iterator()
• mEQUAL(boolean)
• longValue()
• keySet()
• localText()
• makeDelegateToClosureCall(String, String, String, String, int)
• leftShift(long, long)
• listX(List<Expression>)
• label(AST)
• isVerbose()
• longValue()
• loadScriptFile(File)
• isZeroX(Expression)
• isWithCall(String, Expression)
• log()
• keys()
• listDependencies(ClassLoader)
• list()
• main(String)
• leftShiftImpl(Number, Number)
• makeNode(Object)
• makeCached(Class)
• iterator()
• mBXOR(boolean)
• iterator()
• makeSiteEntry()
• memoize()
• localVarX(String, ClassNode)
• leftShift(Path, InputStream)
• mapEntryExpression(AST)
• make(Class, boolean)
• load(MethodVisitor, ClassNode, int)
• logicalAndExpression()
• loadArguments(List<Expression>, Parameter)
• iterator(DataInputStream)
• makeFallBack(MutableCallSite, Class<?>, String, int, MethodType, boolean, boolean, boolean)
• iterator()
• makeCachedCall(Expression, ClassExpression, Expression, Expression, Expression, MethodCallerMultiAdapter, boolean, boolean, boolean, boolean)
• make(MethodNode)
• max(T, Comparator<T>)
• loadDgmInfo()
• loadParameters(CachedMethod, int, MethodVisitor)
• listAttributeDescriptions()
• makeOwnerList(Expression)
• iterator()
• mBAND_ASSIGN(boolean)
• lastIndexOf(Object)
• makeNode(Object)
• isVarArgs()
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• newInstance()
• methodCall(Closure)
• orX(Expression, Expression)
• newInputStream(URL, Map)
• onMethodSelection(Expression, MethodNode)
• modImpl(Number, Number)
• orientationVertical(EventObject)
• name()
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newModule(Properties, ClassLoader)
• nodeIterator()
• newInstance(List<T>, boolean, Closure)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• methodMissing(String, def)
• objectArrayGet(Object, int)
• modifiers()
• newInitializationExpression(String, ClassNode, Expression)
• newModule(Properties, ClassLoader)
• nonGeneric(ClassNode)
• ofType(int, int)
• or(Boolean, Boolean)
• next()
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• packageDefinition()
• mPLUS(boolean)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• onHandleNodeAttributes(FactoryBuilderSupport, Object, Map)
• modifiersInternal()
• name()
• overriddenClass()
• minus(DatumDependentDuration)
• onHandleNodeAttributes(FactoryBuilderSupport, Object, Map)
• mixedContent(NodeList)
• next()
• packageDefinition()
• next(Date)
• methodPointerExpression(AST)
• openUncachedStream(URL)
• namePart()
• nextChar()
• of(String)
• minus(String, Object)
• nodeIterator()
• notYetImplemented()
• mSL(boolean)
• newExpression()
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newReader(Path, String)
• modifiers()
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newInstance(Class, Map)
• onNodeChildren(FactoryBuilderSupport, Object, Closure)
• next()
• onHandleNodeAttributes(FactoryBuilderSupport, Object, Map)
• notYetImplemented(Object)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• modifiers()
• newSymbol(String, int, int)
• next()
• next()
• mLE(boolean)
• notNullX(Expression)
• onEviction(K, V)
• modifiers()
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• onFactoryRegistration(FactoryBuilderSupport, String, String)
• newInputStream(URL, Map)
• of(K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V, K, V,
• next()
• onNodeChildren(FactoryBuilderSupport, Object, Closure)
• onModule(ExtensionModule)
• newReader(InputStream, String)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newObjectInputStream(File, ClassLoader)
• orImpl(Number, Number)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• methods(boolean)
• normalizeIndex(int)
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• namespaceURI()
• newDataOutputStream(Path)
• newObjectOutputStream(OutputStream)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newInstance(Map<String, Object>)
• methods(boolean)
• nextElement()
• newStatic(Class, String)
• mMINUS(boolean)
• mRPAREN(boolean)
• name()
• orImpl(Number, Number)
• onNodeChildren(FactoryBuilderSupport, Object, Closure)
• nameWithDots()
• modImpl(Number, Number)
• objectBlock(AST)
• next()
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• neX(Expression, Expression)
• outputAST(SourceUnit, SourceBuffer)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• name()
• methodCallExpression(AST)
• moveColumn(int, int)
• multiplicativeExpression()
• nodePrinter(String)
• newInteger(String, int, int)
• newLine()
• newWriter(Path, String)
• missesGenericsTypes(ClassNode)
• overriddenType()
• newReader(URL, Map, String)
• modifiers(AST, List<AnnotationNode>, int)
• packageNamed(String)
• newSAXParser(String, boolean, boolean, URL)
• methods(boolean)
• multiply(double, double)
• methods(boolean)
• name()
• onHandleNodeAttributes(FactoryBuilderSupport, Object, Map)
• notNullExpr(Expression)
• MopWriter(WriterController)
• name()
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• name()
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• normalize(String)
• onSetPropertyFoundInHierarchy(MetaMethod)
• modifiers()
• newInstance(boolean, boolean)
• overriddenClass()
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• or(Number, Number)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• namespaceURI()
• multiplyImpl(Number, Number)
• newDecimal(String, int, int)
• onClassNode(ClassWriter, ClassNode)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• methodMissing(String, Object)
• noCopyStringFromChars(char[])
• modImpl(Number, Number)
• multipleAssignmentDeclaration()
• onGetPropertyFoundInHierarchy(MetaMethod)
• name()
• mLBRACK(boolean)
• or(Process, Process)
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• mod(long, long)
• onSetPropertyFoundInHierarchy(MetaMethod)
• minus(String, Object)
• newOutputStream(File)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newString(String, int, int)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• name()
• multicatch_types()
• mLOR(boolean)
• onHandleNodeAttributes(FactoryBuilderSupport, Object, Map)
• modifier()
• newDataInputStream(File)
• mMOD_ASSIGN(boolean)
• newStatic(Class, String, boolean, boolean)
• onNodeChildren(FactoryBuilderSupport, Object, Closure)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• onHandleNodeAttributes(FactoryBuilderSupport, Object, Map)
• newArrayDeclarator()
• onInvokeMethodFoundInHierarchy(MetaMethod)
• newPrintWriter(Writer)
• packageNamed(String)
• normaliseIndex(int, int)
• MockProxyMetaClass(MetaClassRegistry, Class, MetaClass, boolean)
• multipleAssignmentDeclarationStart()
• multiply(String, Number)
• mNUM_INT(boolean)
• minimumSize()
• multiply(Period, int)
• newMethod(String, Callable<ClassNode>)
• nodeCompleted(Object, Object)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• nextRowIndex()
• newInstance(Class<T>, Object)
• multiplyImpl(Number, Number)
• nameWithDots()
• mod(Number, Number)
• mVOCAB(boolean)
• modifierSpecifier()
• normalizeClassName(String)
• negative(Period)
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• minus(Date, Date)
• methodCall(AST)
• mSR_ASSIGN(boolean)
• newInstance(Class, Map)
• onHandleNodeAttributes(FactoryBuilderSupport, Object, Map)
• onSuperMethodFoundInHierarchy(MetaMethod)
• next(Enum)
• newClass(ClassNode)
• minus(Date, Date)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• mQUESTION(boolean)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newRealm(String, Realm)
• mLAND(boolean)
• next(Date)
• OptimizingStatementWriter(WriterController)
• onMethodSelection(Expression, MethodNode)
• numberAwareCompareTo(Comparable, Comparable)
• nodeIterator()
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• next()
• normalizedValue(Object)
• methodMissing(String, def)
• methodDef(AST)
• mSL_COMMENT(boolean)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• modImpl(Number, Number)
• negate()
• multiply(double, double)
• newArrayDeclarator()
• overrides(GroovyMethodDoc)
• options()
• nextToken()
• notX(Expression)
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• needSortedInput()
• out(int)
• next()
• openBlock()
• newObjectOutputStream(File)
• multipleAssignment(int)
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• newStatic(Class, String)
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• notifySystemOut(int, String)
• mNOT_EQUAL(boolean)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• methods(Closure)
• name()
• mINC(boolean)
• newAssignmentExpression(Variable, Expression)
• minus(Duration)
• notImplementedYet(AST)
• newOutputStream(File)
• onMethodSelection(Expression, MethodNode)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• multiplyImpl(Number, Number)
• newDataInputStream(Path)
• mEXPONENT(boolean)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• onHandleNodeAttributes(FactoryBuilderSupport, Object, Map)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• ncurry(int, Object)
• mindmap(String)
• next()
• mFLOAT_SUFFIX(boolean)
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• minus(TimeDatumDependentDuration)
• newObjectOutputStream(Path)
• needsVetoableChangeSupport(ClassNode, SourceUnit)
• modifiers()
• mod(long, long)
• newVisitor(SourceUnit, ClassNode)
• next(ZonedDateTime)
• nodeCompleted(Object, Object)
• metaClass(Object, Closure)
• negateBoolean(MethodVisitor)
• onNodeChildren(FactoryBuilderSupport, Object, Closure)
• nextChar()
• noCopyStringFromChars(char[])
• minimumSize()
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• nodeIterator()
• minus(Month, int)
• openOrClosableBlock()
• modifierSpecifier()
• mixin(MetaClass, Class)
• orImpl(Number, Number)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newVisitor(SourceUnit, ClassNode)
• method(String, int, Class, Closure)
• name()
• mLCURLY(boolean)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• noCopyStringFromChars(char[])
• onSuperMethodFoundInHierarchy(MetaMethod)
• packageDef(AST)
• newInstance(Map<K, V>, Closure)
• ordinaryClasses()
• mPLUS_ASSIGN(boolean)
• newIdentifier(String, int, int)
• newDataOutputStream(File)
• onMixinMethodFound(MetaMethod)
• namedArgumentList(Closure)
• onClassInfo(ClassInfo)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• mMINUS_ASSIGN(boolean)
• namespace(String, String)
• overriddenType()
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• mSR(boolean)
• multiplyImpl(Number, Number)
• onFactoryRegistration(FactoryBuilderSupport, String, String)
• overriddenMethod()
• mGE(boolean)
• minus(double, double)
• noCopyStringFromChars(char[])
• nodeIterator()
• name()
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newKeyword(String, int, int)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• minus(Number, Number)
• next()
• multiplicativeExpression(int)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newObjectInputStream(Path, ClassLoader)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• onLineNumber(ASTNode, String)
• multiply(Number, Number)
• onHandleNodeAttributes(FactoryBuilderSupport, Object, Map)
• onNodeChildren(FactoryBuilderSupport, Object, Closure)
• newWriter(File, String)
• next(String)
• newInterface(Class, String)
• newScope(Closure)
• normaliseIndex(int, int)
• mHEX_DIGIT(boolean)
• newPrintWriter(Path, String)
• newObjectOutputStream(OutputStream)
• mSL_ASSIGN(boolean)
• nlsWarn()
• mixin(String, int, Closure)
• newDataInputStream(File)
• methodCallArgs(AST)
• newScript(Class<?>, Binding)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• nodeCompleted(Object, Object)
• nodeIterator()
• modifierSpecifier()
• notifySystemErr(int, String)
• option(def, Map, def)
• orImpl(Number, Number)
• onHandleNodeAttributes(FactoryBuilderSupport, Object, Map)
• mIDENT(boolean)
• next()
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• mSTAR(boolean)
• mSTRING_LITERAL(boolean)
• newInputStream(Path)
• nodeIterator()
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• objectIDAttributeDelegate(def, def, def)
• onInvokeMethodFoundInHierarchy(MetaMethod)
• multicatch_types()
• modifiersOpt()
• or(long, long)
• nodeCompleted(Object, Object)
• nullify(String)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• mLNOT(boolean)
• newDataOutputStream(File)
• onHandleNodeAttributes(FactoryBuilderSupport, Object, Map)
• mRCURLY(boolean)
• namespaceURI()
• mod(Number, Number)
• methodPointer(Closure)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• mML_COMMENT(boolean)
• onSuperPropertyFoundInHierarchy(MetaBeanProperty)
• mixins(Closure)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• mLT(boolean)
• newObjectInputStream(File, ClassLoader)
• next()
• or(long, long)
• methodDescriptorWithoutReturnType(MethodNode)
• newOutputStream(Path)
• objectArraySet(Object, int, Object)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• namespace(String, String)
• newScript(ClassLoader, Binding)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• onNodeChildren(FactoryBuilderSupport, Object, Closure)
• modImpl(Number, Number)
• newWriter(OutputStream, String)
• newContext()
• methodInfo(MetaMethod)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• name()
• onHandleNodeAttributes(FactoryBuilderSupport, Object, Map)
• name()
• mRBRACK(boolean)
• onSuperPropertyFoundInHierarchy(MetaBeanProperty)
• nonGeneric(ClassNode)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• normalize(String)
• newExpression()
• overrides(GroovyMethodDoc)
• modifier()
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• nextPhase()
• min(T, Closure)
• mixinClassesToMetaClass(MetaClass, List<Class>)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• onHandleNodeAttributes(FactoryBuilderSupport, Object, Map)
• onAllClassInfo(ClassInfo.ClassInfoAction)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• openingVisit(GroovySourceAST)
• ordinaryClasses()
• newPlaceholder(int)
• not(Closure)
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• next(String)
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• nodeCompleted(Object, Object)
• min(Iterable<T>)
• minus(Date, Date)
• multiplyImpl(Number, Number)
• nodeIterator()
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• minus(double, double)
• mSEMI(boolean)
• newReader(URL, Map, String)
• noSuchMethod(CachedMethod, Object, Object)
• onGetPropertyFoundInHierarchy(MetaMethod)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• name(Node)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• nls()
• mLPAREN(boolean)
• MetaMethodIndex(CachedClass)
• newPrintWriter(OutputStream)
• newModule(Properties, ClassLoader)
• nextToken()
• mMOD(boolean)
• onNodeCompleted(FactoryBuilderSupport, Object, Object)
• mGT(boolean)
• normalize()
• newInstance()
• next(double)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• next()
• name()
• multiply(String, Number)
• newInstance(Map, BuilderSupport)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• notNegative(int)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• next()
• nodeCompleted(def, def)
• mSTAR_ASSIGN(boolean)
• newObjectInputStream(InputStream, ClassLoader)
• mWS(boolean)
• onNodeChildren(FactoryBuilderSupport, Object, Closure)
• multicatch()
• multiplyImpl(Number, Number)
• onNodeChildren(FactoryBuilderSupport, Object, Closure)
• multicatch()
• newVirtual(Class, String)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• onNodeChildren(FactoryBuilderSupport, Object, Closure)
• options()
• onHandleNodeAttributes(FactoryBuilderSupport, Object, Map)
• newWriter(File, String)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• minus(DatumDependentDuration)
• name2VariableMappingFor(MethodNode)
• nextIndex()
• needsPropertyChangeSupport(ClassNode, SourceUnit)
• newContainer()
• n2sort()
• nodeIterator()
• objectInit(AST)
• newInstance(FactoryBuilderSupport, Object, Object, Map)
• nextChar()
• modifierSpecifier()
• multiply(Number, Number)
• overriddenMethod()
• methodDescriptor(MethodNode)
• newPrintWriter(File, String)
• pushVariableScope(VariableScope)
• replaceAllTagsCollated(String, String, String, String, String, Pattern)
• permutations(List<T>, Closure<V>)
• parseInt(char[])
• put(K, V)
• remove(int)
• readLines(URL, String)
• register()
• replaceDelegate()
• parseDocument(int, int)
• removeConsoleId()
• parse()
• pushDynamicName(Expression)
• removeNodeMetaData(Object)
• rebind()
• putNodeMetaData(Object, Object)
• parseToStringDate(Date, String)
• popEnclosingClosure()
• parseDouble(char[], int, int)
• printNotice(String)
• push(GroovySourceAST)
• rehash()
• registerPassThruNodes()
• rename(String)
• plus(Object)
• qualifiedTypeName()
• pop()
• printError(String)
• put(K, V)
• putAll(Map)
• record(Object, int)
• removePreInstantiateDelegate(Closure)
• removeTwoOperands(MethodVisitor)
• remove()
• removeMetaClass(Class)
• parse(CharBuffer, int, int)
• printName(Node, XmlNodePrinter.NamespaceContext, boolean, boolean)
• parse(String)
• removePropertyChangeListener(String, PropertyChangeListener)
• parameterDeclaration()
• removeTwoOperands(MethodVisitor)
• parameterDeclarationList()
• push(GroovySourceAST)
• rebind()
• readLine(Reader)
• readNumber()
• pushAssignmentTracking()
• putAt(Date, int, int)
• parents()
• pushLoop(List<String>)
• removeColumn(DefaultTableColumn)
• removeLastChar(char)
• removeTwoOperands(MethodVisitor)
• registerTableComponents()
• registerTextWidgets()
• parametersEqual(Parameter, Parameter)
• processRunners(InputStream, String, ClassLoader)
• println(def)
• removePostInstantiateDelegate(Closure)
• pushEnclosingReturnStatement(ReturnStatement)
• pickMethod(String, Class)
• processConfigScripts(List<String>, CompilerConfiguration)
• remove(WriterController)
• remove()
• push(GroovySourceAST)
• renameTo(File, String)
• put(String, GroovyRunner)
• register(Command)
• putAll(Map)
• printChildren(Node, Map)
• remove(Object)
• register(Command)
• removeVar(int)
• removeAll(Collection<?>)
• printDoubleBreak()
• plus(NodeList, Closure)
• replaceSelection(String)
• qualifiedName()
• putDeclaredVariable(Variable)
• pushEnclosingPropertyExpression(PropertyExpression)
• parse(char[])
• printNameAttributes(Map, XmlNodePrinter.NamespaceContext)
• remove(Node)
• param()
• push(List<T>, T)
• pop()
• registerExplicitMethod(String, String, Closure)
• readLine()
• read(byte[], int, int)
• qualifiedName()
• putAt(Date, int, int)
• printSpecialNode(Node)
• registerSubclassInstanceMethod(MetaMethod)
• replaceAll(String, String, Closure)
• registerBeanFactory(String, String, Class)
• removeAttributeDelegate(Closure)
• remove(Object)
• readLine()
• pushLHS(boolean)
• putAt(MutableTreeNode, int, MutableTreeNode)
• registerActionButtonWidgets()
• parent()
• remove(Object)
• param(ClassNode, String, Expression)
• put(K, V)
• replaceFirst(String, String, Closure)
• parseIntFromTo(char[], int, int)
• rebind()
• replaceBody(Object)
• postCompleteNode(FactoryBuilderSupport, Object, Object)
• relativize(Path)
• removePropertyChangeListener(PropertyChangeListener)
• removeHandler(TypeCheckingExtension)
• parameterizeType(ClassNode, ClassNode)
• put(Object, Object)
• removeMetaClass(Class)
• parseCST(SourceUnit, Reader)
• parse(Script, URL)
• parseClass(GroovyCodeSource, boolean)
• removeNodeMetaData(Object)
• remove(Object)
• pushSwitch()
• recycle()
• replaceIn(ASTNode)
• parseClassNodesFromString(String, SourceUnit, CompilationUnit, MethodNode, ASTNode)
• put(K, int, V)
• parseText(String)
• registerBoxLayout()
• parse(Map, URL, String)
• removePropertyChangeListener(String, PropertyChangeListener)
• proxyInstance(def)
• remove()
• readNumber()
• properties()
• removeChild(String)
• repeatString(String, int)
• replaceNode(Closure, GPathResult)
• pushTemporaryTypeInfo()
• qualifiedTypeName()
• popEnclosingMethod()
• remove(Object)
• parametersAreCompatible(Class, Class)
• proxy(Map<Object, Object>, Object)
• put(K, V)
• postfixExpression(AST, int)
• prepareCallSite(String)
• removeStyle(String)
• replaceBody(Object)
• registerTagLib(Object)
• properties()
• powerExpression(int)
• padLeft(String, Number, String)
• putAll(Map<? extends K, ? extends V>)
• processResult(int[])
• putAll(Map)
• print(GroovySourceAST, int, String)
• popDownTo(int)
• pipeTo(Process, Process)
• put(Object, Object)
• put(String, String)
• printLineBreak()
• pushEnclosingMethodCall(Expression)
• removePropertyChangeListener(PropertyChangeListener)
• prepareCallSite(String)
• primitiveArrayBox(Object)
• renameField(String, String)
• println(String)
• postfix(Closure)
• replaceAllTags(String, String, String, Pattern, List<LinkArgument>, String, GroovyRootDoc, SimpleGroovyClassDoc)
• preInstantiate(Object, Map, Object)
• removeRange(int, int)
• renameTo(File, String)
• printIndent()
• registerWindows()
• propertyMissing(String)
• rebuildBindings()
• pathElementStart()
• pathMatches(List<ASTNodePredicate>)
• qualifiedName(AST)
• putAll(Map)
• printEnd(String, boolean)
• parse(String)
• positive(Period)
• read(Object, String)
• printNotice(String)
• putAt(PageContext, String, Object)
• plus(Closure)
• putAll(Map<? extends K, ? extends V>)
• parse(Collection<String>)
• paste(EventObject)
• putAllClasses(Map<String, GroovyClassDoc>)
• previous(String)
• registerBinding()
• print(PrintWriter)
• replaceWithMoreSpecificType(Object, MethodType)
• put(String, Object)
• remove(Object)
• recordInput(String)
• replaceNode(Node, Closure)
• put(KEY, VALUE)
• replace(CharSequence, int, Map<CharSequence, CharSequence>)
• plus(Timestamp, int)
• plus(StringBuffer, String)
• putAll(Map<String, GroovyClassDoc>)
• replaceBody(Object)
• pop()
• parents()
• prepareSiteAndReceiver(Expression, String, boolean, boolean)
• padRight(String, Number, String)
• removeAll(Map<K, V>, Closure)
• parameterModifiersOpt()
• pop()
• replaceBody(Object)
• remove(Object, Object, Object)
• registerSupportNodes()
• pushInstanceOfTypeInfo(Expression, Expression)
• relativePath(File, File)
• pathElement(AST)
• popEnclosingMethodCall()
• parameterDeclaration()
• parse(Reader, boolean, boolean, boolean)
• pop()
• remove(Object)
• plus(Month, int)
• push(ClassNode)
• putAt(StringBuffer, IntRange, Object)
• parseInteger(AST, String)
• plus(StringBuilder, String)
• range(Range)
• pop()
• prefix(Closure)
• println(Object)
• plus(Date, BaseDuration)
• previous()
• preInstantiate(Object, Map, Object)
• push(GroovySourceAST)
• preCheckForNamedParams(String)
• parseText(String)
• renameTo(Path, URI)
• power(BigInteger, BigInteger)
• put(String, GroovyPackageDoc)
• remove()
• renderToOutput(OutputTool, String)
• printLineBegin()
• parameterDeclarationList()
• popEnclosingClassNode()
• parent(Node)
• replace(EventObject)
• parent()
• replaceFirst(String, String, Closure)
• postfixExpression(int)
• parameterizeArguments(ClassNode, MethodNode)
• putIfAbsent(K, V)
• parametersEqual(Parameter, Parameter)
• removeTwoOperands(MethodVisitor)
• prettyPrint()
• parseClass(GroovyCodeSource, boolean)
• parse(ZonedDateTime, CharSequence, String)
• parseText(String)
• rcurry(Object)
• renderPrompt()
• replaceNode(Closure)
• remove(Object)
• relationalExpression(int)
• read(char[], int, int)
• remove()
• render(String, ValueRecorder)
• parse(String)
• parameters()
• pushConstant(ConstantExpression)
• put(K, V)
• remove(Command)
• read(Object, String)
• println()
• processKeyEvent(KeyEvent)
• recordResult(Object)
• popImplicitThis()
• parameters(Closure)
• ReferenceManager(ReferenceQueue)
• processBytecode(String, byte[])
• readBytes(Path)
• remove()
• pushEnclosingBinaryExpression(BinaryExpression)
• removeNotify()
• removeStandardMethods(Collection<ReflectionCompletionCandidate>)
• params(Parameter)
• plus(double, double)
• pathExpression(int)
• print(Node, XmlNodePrinter.NamespaceContext)
• parse(Map, URL, String)
• removeTwoOperands(MethodVisitor)
• pushEnclosingMethodCall(Expression)
• parameters(AST)
• registerContainers()
• put(K, V)
• removeField(String)
• pushBooleanExpression()
• postInstantiate(Object, Map, Object)
• remove()
• put(K, V)
• printSanitizedStackTrace(Throwable)
• remove(int)
• regexPattern(Object)
• parseIntFromToIgnoreDot(char[], int, int)
• printf(Object, String, Object)
• postInstantiate(Object, Map, Object)
• processAST()
• pushState()
• plus(Number, Number)
• removeAssignment(int)
• putAll(Map<? extends String, ? extends GroovyRunner>)
• print(Object)
• primitiveArrayGet(Object, Collection)
• remove(FilterBypass, int, int)
• removeAll(Collection<?>)
• parse(String)
• putCopyOfUnexisting(Entry)
• plus(TimeDuration)
• removeMethod(MethodNode)
• replace(ClassNode, int)
• parse(Date, String, String, TimeZone)
• remove(Class<?>)
• plus(DatumDependentDuration)
• printAttributes(Map)
• process(AST)
• postNodeCompletion(Object, Object)
• putStyle(String, Style)
• pushBool(boolean)
• put(Object, Object)
• qualifiedTypeName()
• processBytecode(String, byte[])
• parse(Collection<String>)
• plus(double, double)
• parseBigDecimal(char[])
• parse(File, String)
• previous(Date)
• println(Object, PrintWriter)
• parse(File, String)
• print(def)
• parseJsonNumber(char[], int, int, int[])
• parseClass(URL)
• processParameters(CompileUnit, Method)
• parameter(Map<String, Class>, Closure)
• processParameters(CompileUnit, Method)
• popEnclosingClosure()
• redoTo(UndoableEdit)
• previous(Enum)
• replaceNode(Closure)
• pushErrorCollector()
• parse(InputStream)
• registerExtensionModuleFromProperties(Properties, ClassLoader, Map<CachedClass, List<MetaMethod>>)
• replace(FilterBypass, int, int, String, AttributeSet)
• refreshInheritedMethods(Set)
• performSecondPass()
• remove(int)
• process(AST)
• remove(Object)
• pop()
• remove(K)
• putAll(Map<? extends K, ? extends V>)
• readLine()
• parse(Collection<String>)
• putAll(Map<K, V>, Collection<? extends def>)
• printError(String)
• reallocateIndexes()
• previous(Date)
• replaceBody(Object)
• processFiles(List<String>)
• redirect(String)
• plus(DatumDependentDuration)
• remove(int)
• pi(Map<String, Map<String, Object>>)
• removeReferencedClassVariable(String)
• replaceIn(ASTNode)
• put(String, Object)
• recompile(URL, String, Class)
• removeLast(List<T>)
• remove(Object)
• print(Object)
• pathUpTo(Class<ASTNode>, ASTNodePredicate)
• pushEnclosingClosureExpression(ClosureExpression)
• readLines(Reader)
• pushEnclosingBinaryExpression(BinaryExpression)
• record(Token)
• pushImplicitThis(boolean)
• push(GroovySourceAST)
• postfixExpression()
• readForRecycle()
• registerMenuWidgets()
• printAttributeWithPrefix(Attr, StringBuffer)
• registerEditors()
• registerStaticMethod(String, Closure, Class)
• read()
• pi(Map<?, ?>)
• propertyChange(PropertyChangeEvent)
• print(Object)
• remove(Object, Object)
• printSimpleItem(Object)
• register(URL)
• qualifiedName()
• properties()
• refresh()
• readLines(String)
• printNamespace(Object, XmlNodePrinter.NamespaceContext)
• putAll(Map<? extends String, ? extends String>)
• parse(def)
• popEnclosingBinaryExpression()
• popAssignmentTracking(Map<VariableExpression, List<ClassNode>>)
• padLeft(String, Number, String)
• removeColumn(TableColumn)
• renumberTableColumns()
• registerBeanFactory(String, String, Class)
• parse(Reader)
• parents()
• printWarning(String)
• registerTextComponent(JTextComponent)
• replaceBody(Object)
• putAll(Map)
• registerConditionalBlock(String, String)
• prefixExpression(AST, int)
• remove()
• popContext()
• popEnclosingReturnStatement()
• registerBorders()
• remove(Class<?>)
• pushEnclosingClassNode(ClassNode)
• remove(Object)
• readNumber(char[], int, int)
• plus(String)
• removeModule(ExtensionModule)
• putAll(Map)
• register(WatchService, Kind<?>)
• preferenceChange(PreferenceChangeEvent)
• put(K, V)
• popLHS()
• plumb()
• processDoMethodInvokeException(Exception, Object, Object)
• popErrorCollector()
• processingInstruction(String, String)
• readBytes(File)
• removeClassCacheEntry(String)
• rebind()
• parameters()
• put(K, V)
• removeNamePrefix(String)
• property(Closure)
• plus(Timestamp, int)
• pickMethod(String, Class)
• readLine(Reader)
• prettyPrintMethodList(List<MethodNode>)
• remove(Object)
• remove(Object)
• print(Node)
• registerMBeanFromMap(String, Map)
• remove(K, int)
• parents()
• previous(double)
• pushBlockRecorderVisit(BlockRecorder)
• parameterModifier()
• read(CharBuffer)
• parseLine(String, int)
• putChild(String, StructuredSyntaxDocumentFilter.LexerNode)
• removeMetaClassRegistryChangeEventListener(MetaClassRegistryChangeEventListener)
• removeMetaClassRegistryChangeEventListener(MetaClassRegistryChangeEventListener)
• putAt(String, Object)
• pop()
• registerFactories()
• pushEnclosingClosureExpression(ClosureExpression)
• remove(Object)
• proxy()
• putAll(Map<? extends K, ? extends V>)
• putReferencedClassVariable(Variable)
• proxyDelegateInstance(def)
• registerBasicLayouts()
• replaceIn(ASTNode)
• printComment(Comment, boolean)
• printWarning(String)
• remove()
• propertyChange(PropertyChangeEvent)
• print(Object)
• putAt(Element, String, Object)
• printText(Text, boolean)
• putNodeMetaData(Object, Object)
• readBytes(File)
• parseText(String)
• pop()
• replaceTags(String)
• removeClass(Class)
• query(GString, Closure)
• replaceAll(String, String, Closure)
• redirect()
• pop(List<T>)
• println(Object)
• remove(KEY)
• proxyDelegateInstance(def)
• pushConstant(MethodVisitor, int)
• print(Object, PrintWriter)
• printElement(Element, Map, boolean)
• parseDecimal(String)
• prepareCallSite(String)
• recurByThrowStatement()
• popTemporaryTypeInfo()
• position2VariableMappingFor(MethodNode)
• printPI(ProcessingInstruction, boolean)
• printNewlineAndIndent(GroovySourceAST, int)
• popEnclosingClassNode()
• popEnclosingMethod()
• put(String, String)
• relationalExpression()
• popEnclosingPropertyExpression()
• plus(StringBuffer, String)
• print(EventObject)
• performOperationOnMetaClass(ProxyMetaClass.Callable)
• putAt(int, Object)
• processOtherServices(ClassLoader, File)
• putAll(Map<? extends K, ? extends V>)
• put(Object, Object)
• printLineEnd(String)
• parseText(String)
• primaryExpression()
• put(Object, Object)
• push(GroovySourceAST)
• pop()
• print(Object)
• registerNamespacePrefix(String, String)
• parse(Date, String, String, TimeZone)
• provide(K)
• pickMethod(String, Class)
• remove()
• registerInstanceMethod(String, Closure)
• primitiveArrayToList(Object)
• put(K, V)
• registerTableLayout()
• replaceCurrentBuffer(List<String>)
• redo(EventObject)
• print(char)
• plus(Closure)
• printUpdatingTabLevel(GroovySourceAST, int, String, String, String)
• registerBasicWidgets()
• param()
• propX(Expression, Expression)
• placeholder(String)
• processSerializedCategoryMethods(InputStream)
• popContext()
• replaceNode(Closure)
• replaceNode(Closure)
• printName(Node)
• removeStallEntries()
• removeTextListener(TextListener)
• process(AST)
• plusX(Expression, Expression)
• remove(Object)
• prepareVisit(ClassNode)
• pathChain(int, AST)
• previous(String)
• plus(Object)
• register(HasCleanup)
• parseLongFromToIgnoreDot(char[], int, int)
• putAt(int, Object)
• rangeExpression(AST, boolean)
• popEnclosingBinaryExpression()
• regexExpression(int)
• removeRange(int, int)
• parse(Collection<String>)
• printIndent()
• push(GroovySourceAST)
• postNodeCompletion(Object, Object)
• replaceNode(Closure)
• pickMethod(String, Class)
• removePostNodeCompletionDelegate(Closure)
• preferences(EventObject)
• parseFromInstance(T, def)
• removeListeners()
• pushEnclosingMethod(MethodNode)
• removeAll(Collection<?>)
• popTemporaryTypeInfo()
• registerBeanProperty(String, Object)
• padRight(String, Number, String)
• parseLong(char[])
• qualifiedTypeName()
• recreateSrc()
• remove()
• removeElement(Collection<E>, Object)
• properties()
• replace(K, V, V)
• previous()
• println(Object)
• putAll(Map)
• reenableTracker()
• parameterizedType(ClassNode, ClassNode)
• printResults(PrintStream)
• popEnclosingMethodCall()
• postNodeCompletion(Object, Object)
• postCompleteNode(FactoryBuilderSupport, Object, Object)
• putReferencedLocalVariable(Variable)
• readLines(Reader)
• positionStmtsAfterEnumInitStmts(List<Statement>)
• plus(DatumDependentDuration)
• pushEnclosingMethod(MethodNode)
• pickGenericType(MethodNode, int, int)
• registerThreading()
• rehydrate(Object, Object, Object)
• postCompleteNode(FactoryBuilderSupport, Object, Object)
• remove(K)
• removeAt(List<E>, int)
• parseCST(SourceUnit, Reader)
• postCompleteNode(FactoryBuilderSupport, Object, Object)
• read(Reader, CharBuf, int)
• rebind()
• printAttributes(Element)
• remove(String)
• parseLongFromTo(char[], int, int)
• redo()
• qualifiedTypeName()
• plus(Date)
• prettyPrint(String)
• parseFromSpec(Class<T>, String)
• printList(List, XmlNodePrinter.NamespaceContext)
• propertyNode(String, int, Class, Class, Closure)
• recordError(Throwable)
• parents()
• remove(int)
• pushContext(ASTNode)
• previous(ZonedDateTime)
• pushBlockRecorder(BlockRecorder)
• printQuoted(String)
• remove(Object)
• removeAll(Collection)
• parseToStringDate(Date, String)
• pop()
• put(String, Value)
• registerMDIWidgets()
• parameter(AST)
• removeTwoOperands(MethodVisitor)
• parents()
• removeBinding(BindingUpdatable)
• previous()
• put(CachedClass, SingleKeyHashMap)
• put(K, V)
• qualifiedName()
• push(GroovySourceAST)
• readLines(Path, String)
• registerFactory(String, String, Factory)
• parenthesizedExpression()
• propertyChange(PropertyChangeEvent)
• remove(Object)
• putAt(StringBuilder, EmptyRange, Object)
• pop()
• putAt(StringBuffer, IntRange, Object)
• putUserdata(Object, Object)
• parseFloat(char[], int, int)
• remove(Object)
• powerExpressionNotPlusMinus(int)
• read(Object, String)
• remove(int)
• registerDataModels()
• put(Object, Object)
• print(String)
• registerRenderers()
• processGridBagConstraintsAttributes(FactoryBuilderSupport, Object, Map)
• parameterizeInterfaceGenerics(ClassNode, ClassNode)
• recurStatement()
• printStackTrace()
• process(AST)
• proxyInstance(def)
• println(StringBuffer)
• registerModifiedMetaClass(ExpandoMetaClass)
• primaryExpression()
• previousIndex()
• put(Object, Object)
• qualifiedTypeName()
• printAttributeWithoutPrefix(Attr, boolean)
• pushTemporaryTypeInfo()
• primitiveArrayPut(Object, int, Object)
• removeMethod(String)
• popBlockRecorderVisit(BlockRecorder)
• remove(Object)
• recordModification(Object)
• rebind()
• print(Graphics, PageFormat, int)
• printf(String, Object)
• pushEnclosingClassNode(ClassNode)
• printList(List)
• removePropertyChangeListener(String, PropertyChangeListener)
• registerExplicitProperty(String, String, Closure, Closure)
• parse(char[])
• properties(Closure)
• replaceNode(Closure)
• setLocale(Locale)
• setCompilationUnit(CompilationUnit)
• setInitialValueExpression(Expression)
• setMaxRows(int)
• safeNextChar()
• setEvent(String)
• setParameters(List<Object>, PreparedStatement)
• retrieveStaticMethod(String, Object)
• setAttribute(Class, Object, String, Object, boolean, boolean)
• setFinal(boolean)
• setHeader(String)
• setModel(Object)
• setColumn(long)
• resolveTemplate(String)
• setEnforce8Bit(boolean)
• sameType(Collection)
• setLineLast(int)
• reset()
• setInterfaceClassLoadingClass(InterfaceHelperClassNode)
• resolve(Map, List, Map)
• setIndex(Matcher, int)
• setProperty(String, Object)
• retainAll(Collection<?>)
• setCompilationUnit(CompilationUnit)
• setBytes(Path, byte[])
• setPropertyMissingDelegate(Closure)
• setGroovyObjectProperty(Object, Class, GroovyObject, String)
• resolveType(Expression, ClassNode)
• setModifiers(int)
• setExpression(Expression)
• returnStatementAdded(ReturnStatement)
• setAttribute(Class, Object, String, Object, boolean, boolean)
• setProperty2(Object, Object, String)
• setLine(long)
• setKeepStubs(boolean)
• setClassValidator(Closure<Boolean>)
• setErrorHandler(ErrorHandler)
• respondsTo(Object, String)
• saveDgmInfo(List<DgmMethodRecord>, String)
• setMethodNode(MethodNode)
• returnFalseIfWrongType(ClassNode, Expression)
• setAccessedVariable(Variable)
• setConstantTypesClassesBlackList(List<Class>)
• setCompilationUnit(CompilationUnit)
• setFork(boolean)
• setOrigBool(boolean)
• setKeyExpression(Expression)
• setProperty(Object, Object)
• setIndirectImportCheckEnabled(boolean)
• run()
• reverseUpdate()
• send(Object)
• setFatal(boolean)
• setReceiversClassesBlackList(List<Class>)
• resolveClassNullable(String)
• setEditable(boolean)
• setClosure(Closure)
• setCommentText(String)
• setEndLine(long)
• run()
• setMessage(String)
• resolveSibling(String)
• runSelectedScript(EventObject)
• setCompilationUnit(CompilationUnit)
• reset()
• setGroovyObjectFieldSpreadSafe(Object, Class, GroovyObject, String)
• setNoTimestamp(boolean)
• returnType()
• setDisableChecksums(boolean)
• restoreFromContinuationData(Map<String, Object>)
• resolve(List<ClassNode[]>, ClassNode, Expression, ClosureExpression, MethodNode, SourceUnit, CompilationUnit, String)
• setCompilationUnit(CompilationUnit)
• setLastColumnNumber(int)
• setEntityResolver(EntityResolver)
• setClasspathRef(Reference)
• save(def, def, def, def, def, def, CompilePhaseAdapter, def, def)
• setModel(TableModel)
• round(BigDecimal, int)
• setConfigscript(String)
• set(int, CSTNode)
• setCompilerFactory(JavaCompilerFactory)
• set(Object)
• setMethodNode(MethodNode)
• setChop(boolean)
• setLoopBlock(Statement)
• setRawCommentText(String)
• setClasspathList(List<String>)
• setIndy(boolean)
• setCheckDates(boolean)
• resolve()
• setReceiversClassesWhiteList(List<Class>)
• setGroovyObjectPropertySpreadSafe(Object, Class, GroovyObject, String)
• setChild(FactoryBuilderSupport, Object, Object)
• rightShift(Closure<W>)
• setDisabledGlobalASTTransformations(Set<String>)
• setLoopBlock(Statement)
• setOuter(GroovyClassDoc)
• setClasspath(Path)
• setInitialized(boolean)
• setColumnLast(int)
• setMetaClass(MetaClass)
• setPackageAllowed(boolean)
• respondsTo(Object, String)
• setRecompileGroovySource(boolean)
• setAllowedTargets(int)
• setProperty(String, Object)
• returnType()
• setArguments(Expression)
• setMetaClass(GroovyObject, MetaClass)
• setChild(FactoryBuilderSupport, Object, Object)
• setCategoryUsed(boolean)
• setEscapeBackslash(boolean)
• setOriginType(ClassNode)
• setHistory(FileHistory)
• setAlign(String)
• setExpression(Expression)
• setMethodDispatcherCode(BlockStatement, Expression, Parameter)
• setCode(Statement)
• setPropertyGetterDispatcher(BlockStatement, Expression, Parameter)
• retainAll(Collection<?>)
• setImportsResolved(boolean)
• resolve(String)
• setColumnLast(int)
• setReplacement(Expression)
• setConfiguration(CompilerConfiguration)
• resetCachedMetaClasses()
• setPlaceholder(boolean)
• setAnonymous(boolean)
• reverse()
• scanExtensionModuleFromProperties(Properties)
• setAbstract(boolean)
• setRawCommentText(String)
• setName(String)
• setParameters(Parameter)
• setProperty(String, Object)
• setParent(TextNode)
• setMetaClassCreationHandle(MetaClassRegistry.MetaClassCreationHandle)
• setPackage(String, List<AnnotationNode>)
• setEnableGrapes(boolean)
• setOutput(PrintWriter)
• setChild(FactoryBuilderSupport, Object, Object)
• setBooleanExpression(BooleanExpression)
• setColumn(int)
• setDelegate(Object)
• setElseBlock(Statement)
• setNamespaceAware(boolean)
• resolveFactory(Object, Map, Object)
• setHolder(boolean)
• setFeature(String, boolean)
• setClasspath(Path)
• setManagedResource(Object)
• setController(SourceUnit)
• setResolveStrategy(int)
• setProperty(String, Object)
• setFilename(String)
• setOrigChar(boolean)
• rootLoader(String)
• setLastMatcher(Matcher)
• setExpression(Expression)
• setPropertySetterDispatcher(BlockStatement, Expression, Parameter)
• setClassNameResolver(Object)
• setLazyReferencesAllowed(boolean)
• setParent(FactoryBuilderSupport, Object, Object)
• setClassScope(ClassNode)
• send(Object)
• setKey(Object)
• setReceiversWhiteList(List<String>)
• setProperty(String, Object)
• setClasspath(String)
• setOutputPreferences(boolean, File)
• setColumnMark(long)
• setProperty(String, Object)
• setProperty(Object, String, Object)
• setDebug(boolean)
• setCompilationUnit(CompilationUnit)
• setParent(FactoryBuilderSupport, Object, Object)
• setClasspath(Path)
• resetFileLists()
• setProperty(String, Object)
• setAdaptee(MetaClass)
• setNameWithTypeArgs(String)
• serializableFields()
• rightShiftImpl(Number, Number)
• setProperties(Object, Map)
• setIndex(Matcher, int)
• run()
• setProperty(String, Object)
• setInterfaceClassLoadingClass(InterfaceHelperClassNode)
• setChild(FactoryBuilderSupport, Object, Object)
• resolveChildRelationName(String, Object, String, Object)
• setConstantName(String)
• setMetaClass(MetaClass)
• setAutoEscape(boolean)
• setDocumentLocator(Locator)
• setIncludeAntRuntime(boolean)
• setExecutable(String)
• setJointCompilationOptions(Map<String, Object>)
• setGenericsTypes(GenericsType)
• resolveClassname(String)
• setDefaultFamily(String)
• setPublic(boolean)
• setExpression(Expression)
• setAdaptee(MetaClass)
• setLine(int)
• setMethodDefinitionAllowed(boolean)
• set(int, CSTNode)
• setMetaMethod(MetaMethod)
• retainAll(Collection<?>)
• retainAll(Collection)
• setLineNumber(int)
• setProtected(boolean)
• searchForGroovyScriptFile(String)
• setFeature(String, boolean)
• respondsTo(Object, String)
• setReceiversBlackList(List<String>)
• setDestdir(File)
• resolveClassname(String)
• setPackage(PackageNode)
• setMaxSizeForInMemory(int)
• setHeader(String)
• setExpressionsBlacklist(List<Class<? extends Expression>>)
• run(String, Binding)
• setBytes(OutputStream, byte[])
• setMetaClassCreationHandle(MetaClassRegistry.MetaClassCreationHandle)
• setPosix(Boolean)
• resolve(int)
• setChild(FactoryBuilderSupport, Object, Object)
• setGlobalTrimWhitespace(boolean)
• resolveExplicitMethod(String, Object)
• setParent(Node)
• setClassLoader(GroovyClassLoader)
• resolveName(String, CompilationUnit)
• setExtensions(String)
• setParameters(boolean)
• setAdditionalClassInformation(ClassNode)
• setClosureSharedVariable(boolean)
• reverseEach(T, Closure)
• setAnnotated(boolean)
• setChild(FactoryBuilderSupport, Object, Object)
• setChildPropertySetter(Object)
• set(int, Object)
• setInterceptor(Interceptor)
• setQuote(String)
• setCapacity(long)
• setProgressCallback(CompilationUnit.ProgressCallback)
• resolveParentRelationName(String, Object, String, Object)
• setProperty(Class, Object, String, Object, boolean, boolean)
• setExpandArgumentFiles(boolean)
• reset()
• returnS(Expression)
• setNewLineString(String)
• safeExpression(Expression, Expression)
• rightShiftUnsignedImpl(Number, Number)
• setMethodMissingDelegate(Closure)
• setFieldSpreadSafe(Object, Class, Object, String)
• setPropertySafe2(Object, Object, String)
• setExpression(Expression)
• setNodeMeta(TypeChooser, ClassNode)
• setClassgenCallback(CompilationUnit.ClassgenCallback)
• setHolder(boolean)
• scanDir(File, File, String)
• setPrivate(boolean)
• setFailonerror(boolean)
• setOrigLong(boolean)
• setChild(FactoryBuilderSupport, Object, Object)
• saveOnRun(EventObject)
• reset()
• setChild(Object, Object, String, String)
• setClassNodeResolver(ClassNodeResolver)
• selectBlock(EventObject)
• returnValueOfNext()
• reset()
• setIncludeMainForScripts(boolean)
• setMethodsToBeVisited(Set<MethodNode>)
• setContextClassLoader(boolean)
• setChild(FactoryBuilderSupport, Object, Object)
• setOrigFloat(boolean)
• rightShiftUnsigned(Number, Number)
• setHandled(boolean)
• run(Reader, String, String)
• setLast(Token)
• setIncludeantruntime(boolean)
• setChild(FactoryBuilderSupport, Object, Object)
• setDeclaringClass(ClassNode)
• setPluginFactory(ParserPluginFactory)
• setConstantTypesClassesWhiteList(List<Class>)
• setCatchStatement(int, CatchStatement)
• setMeaning(int)
• setDebug(boolean)
• setArraySetAndGet(MethodCaller, MethodCaller)
• sendHEADRequest(URL)
• setOutput(File)
• setGroovy(boolean)
• setLineMark(long)
• setPrepareEditor(Closure)
• reset()
• setMetaClass(MetaClass, Class)
• setClassLoader(GroovyClassLoader)
• rollback()
• setGenericsPlaceHolder(boolean)
• setDefaultJmxNameDomain(String)
• rows(int, int)
• setName(String)
• resolveTemplate(String)
• samePackageName(ClassNode, ClassNode)
• setAccessTrue(AST, boolean)
• setChild(FactoryBuilderSupport, Object, Object)
• setField(CachedField)
• setChild(FactoryBuilderSupport, Object, Object)
• resolveTemplate(String)
• runQuery(Connection)
• setOptimizationOptions(Map<String, Boolean>)
• setProperty(Class, Object, String, Object, boolean, boolean)
• rethrow(Throwable)
• setOvertypeMode(boolean)
• setHref(String)
• set(int, T)
• setParent(FactoryBuilderSupport, Object, Object)
• serializationMethods()
• setParent(FactoryBuilderSupport, Object, Object)
• setObject(PreparedStatement, int, Object)
• resolveClassname(String)
• resultSet(int)
• server()
• setJavaHome(File)
• setModule(ModuleNode)
• selectFilename(def)
• rightShiftImpl(Number, Number)
• setExpandEmptyElements(boolean)
• setProperty(String, Object)
• resetLoadedClasses()
• setBooleanExpression(BooleanExpression)
• serializableFields()
• setAttribute(Object, String, Object)
• setPublic(boolean)
• setPrivate(boolean)
• ServletBinding(HttpServletRequest, HttpServletResponse, ServletContext)
• report(Throwable, boolean)
• setClosureSharedVariable(boolean)
• setProperty(String, Object)
• setCode(Statement)
• resolveParentRelationName(String, Object, String, Object)
• setLastLineNumber(int)
• setHasNoRealSourcePosition(boolean)
• setPackagePrivate(boolean)
• setRef(String)
• resolveClass(String)
• setEnableAutoDownload(boolean)
• setInStaticContext(boolean)
• setMessageExpression(Expression)
• setCompilationUnit(CompilationUnit)
• setConfigscript(String)
• service(HttpServletRequest, HttpServletResponse)
• rightShiftUnsignedImpl(Number, Number)
• returnFalseIfNotInstanceof(ClassNode, Expression)
• setMode(String)
• returnTrueIfIdentical(Expression, Expression)
• reverseUpdate()
• setClosureArguments(Object)
• setParent(Object, Object)
• setParent(Object, Object)
• resolveClassNodeGenerics(Map<GenericsTypeName, GenericsType>, Map<GenericsTypeName, GenericsType>, ClassNode)
• setInitialExpression(Expression)
• setFatal(boolean)
• setGroovyObjectFieldSafe(Object, Class, GroovyObject, String)
• serializationMethods()
• setForce(boolean)
• setBytes(File, byte[])
• setChild(FactoryBuilderSupport, Object, Object)
• setDefaultStatement(Statement)
• setParametersTypes(CachedClass)
• setOmitNullAttributes(boolean)
• setIncludejavaruntime(boolean)
• setName(String)
• setClasspath(Path)
• setDefaultJmxNameType(String)
• setAutoIndentString(String)
• retrieveStaticMethod(String, Class)
• setPerInstanceMetaClass(Object, MetaClass)
• select(int)
• sameClass(Class, Object)
• setRedirect(ClassNode)
• setModifierBit(AST, int, int)
• setKeepIgnorableWhitespace(boolean)
• samePackages(String, String)
• setParameters(boolean)
• setFormatter(HelpFormatter)
• reset()
• setFileEncoding(String)
• setOverride(ClassLoader)
• run()
• setMetaClass(MetaClass)
• setBeanFactoryName(String)
• setBugText(String)
• run()
• setCompilationUnit(CompilationUnit)
• setDefaultStyle(Style)
• setOwner(ClassNode)
• setReferenceResolver(Object)
• setMetaClass(MetaClass)
• setMnemonic(AbstractButton, String)
• setAppend(boolean)
• setProperty(String, Object)
• setParent(Object, Object)
• setClosuresAllowed(boolean)
• run()
• returnStatement(AST)
• setConverter(Closure)
• setClassNode(ClassNode)
• setCode(Statement)
• setIfBlock(Statement)
• setCoerce(boolean)
• setProperty(String, Object)
• setObjectExpression(Expression)
• setEnableNamedQueries(boolean)
• setObjectExpression(Expression)
• setMemoryMaximumSize(String)
• setLineNumber(int)
• setProperty(String, Object)
• setModifiers(int)
• setLeftExpression(Expression)
• setCacheStatements(boolean)
• setRawCommentText(String)
• runScript(Class, String)
• setConstantTypesWhiteList(List<String>)
• setDelegate(Object)
• setDTDHandler(DTDHandler)
• setChild(FactoryBuilderSupport, Object, Object)
• setNameMappingClosure(Closure)
• setFieldOnSuper(Object, Class, Object, String)
• setField(Object, Class, Object, String)
• service(HttpServletRequest, HttpServletResponse)
• set(int, Object)
• returnFalseIfPropertyNotEqual(PropertyNode, Expression)
• setCharset(String)
• setImportsWhitelist(List<String>)
• setClasspathRef(Reference)
• setChild(FactoryBuilderSupport, Object, Object)
• setImportsBlacklist(List<String>)
• resource()
• setDirty(boolean)
• setOrigIntArray(boolean)
• saveVariableExpressionMetadata(Set<VariableExpression>, Map<VariableExpression, ListHashMap>)
• setResolveStrategy(int)
• resolveTemplate(String)
• run()
• setProperty(Class, Object, String, Object, boolean, boolean)
• run()
• setEvent(String)
• setLazyChop(boolean)
• setExpandEmptyElements(boolean)
• serializationMethods()
• reset()
• setEntityBaseUrl(URL)
• setAutoNewLine(boolean)
• setBean(Object)
• setProperty(Object, Class, Object, String)
• setBundle(ReferenceBundle)
• setProperties(Object, Map)
• set(String, Object)
• setCompilationUnit(CompilationUnit)
• setCompilationUnit(CompilationUnit)
• sArraySet(short[], int, short)
• setClassNodeResolver(ClassNodeResolver)
• setModifiers(int)
• secondVisit(GroovySourceAST)
• setFieldOnSuperSafe(Object, Class, Object, String)
• set(Date, Map<Object, Integer>)
• setClosureDelegate(Closure, Object)
• setPackages(String)
• setInStaticContext(boolean)
• setProxyBuilder(FactoryBuilderSupport)
• setLoopBlock(Statement)
• set(int, Object)
• setExpressionsWhitelist(List<Class<? extends Expression>>)
• rightShift(Number, Number)
• resolveJvmClass(String)
• setIndentation(String)
• setGroovyObjectPropertySafe(Object, Class, GroovyObject, String)
• setNoVersionStamp(boolean)
• setClassLoader(ClassLoader)
• setProperty(Object, Object)
• setAdaptee(MetaClass)
• setGenericsTypes(GenericsType)
• setChild(FactoryBuilderSupport, Object, Object)
• setProperty(String, Object)
• reverse(String)
• setCode(Statement)
• sanitize(Throwable)
• setBytecodePostprocessor(BytecodeProcessor)
• run(Map)
• setEntityResolver(EntityResolver)
• reverse(String)
• setImplicitThis(boolean)
• serialize(String, Object)
• setLoopBlock(Statement)
• resName(String)
• setReportClass(ClassNode)
• setName(String)
• setAttribute(Object, String, Object)
• setKeepWhitespace(boolean)
• resolveFactory(Object, Map, Object)
• setCompilationUnit(CompilationUnit)
• setProperty(Object, Object)
• resolve(ClassLoader, Map, List, Map)
• setOrigByte(boolean)
• setOriginType(ClassNode)
• setDestdir(File)
• run()
• setDescription(String)
• setDisableCustomMetaClassLookup(boolean)
• setClosure(Closure)
• setRedirect(ClassNode)
• setMetaClass(MetaClass)
• setProperty(Class, Object, String, Object, boolean, boolean)
• setAdaptee(Object)
• resetLineNumber()
• reset()
• sArrayGet(short[], int)
• sanitizeRootCause(Throwable)
• returnValueOfNext()
• setCachable(boolean)
• reverseUpdate()
• serializableFields()
• setInternalConnection(Connection)
• setMainClass(String)
• setDoctitle(String)
• setMixinInstance(Object, Object)
• setCurrent(Object)
• setColumn(int)
• setClassCacheEntry(Class)
• setFieldSafe(Object, Class, Object, String)
• run(File, String)
• setNodeAttributes(Object, Map)
• setIndy(boolean)
• setConfig(CompilerConfiguration)
• setEditable(boolean)
• setLeftExpression(Expression)
• setPropertySafe(Object, Class, Object, String)
• runAfter(Timer, int, Closure)
• setProtected(boolean)
• setMemoryInitialSize(String)
• setDestdir(File)
• setErrorProperty(String)
• set(PageContext, String, Object)
• serialize(String, Writer)
• ResolveVisitor(CompilationUnit)
• setParent(FactoryBuilderSupport, Object, Object)
• rightShift(long, long)
• setDefaultCharset(Charset)
• setParent(def, def)
• segmentFor(int)
• setRelationNameResolver(ObjectGraphBuilder.RelationNameResolver)
• rightShift(long, long)
• setPackage(boolean)
• setModifiers(int)
• setMetaClass(Class, MetaClass)
• setPackagenames(String)
• setColspan(int)
• setNewInstanceResolver(Object)
• setParent(FactoryBuilderSupport, Object, Object)
• resolveType(Expression, ClassNode)
• setOrigShort(boolean)
• setAccess(String)
• setPropertyOnSuper(Object, Class, GroovyObject, String)
• setCompilationUnit(CompilationUnit)
• setModel(TableModel)
• restoreVariableExpressionMetadata(Map<VariableExpression, ListHashMap>)
• setGenericsTypes(GenericsType)
• reverseUpdate()
• setBounds(int, int, int, int)
• setProcessScripts(boolean)
• set()
• searchMethods(String, CachedClass)
• setMember(String, Expression)
• setChild(FactoryBuilderSupport, Object, Object)
• setGetter(MetaMethod)
• setBytes(OutputStream, byte[])
• setBaseTemplateClass(Class<? extends BaseTemplate>)
• run(Class<?>, GroovyClassLoader)
• setInterfaces(ClassNode)
• setEnclosingMethod(MethodNode)
• setFullPathName(String)
• setLexer(CharScanner)
• setClosureDelegate(Closure, Object)
• setPropertyOnSuperSpreadSafe(Object, Class, GroovyObject, String)
• setMetaClass(MetaClass)
• setParent(Object, Object)
• setMethod(Expression)
• set(int, T)
• setEventName(String)
• setExpandEmptyElements(boolean)
• setDir(String)
• safeCall(Closure, Object)
• setGenericsPlaceHolder(boolean)
• setParameters(boolean)
• setProperty(Object, Object)
• setMinimumRecompilationInterval(int)
• setDeprecated(boolean)
• respondsTo(Object, String)
• rightShift(Number, Number)
• serialize(Element)
• resolveType(Type)
• setColumnLast(int)
• setFinallyStatement(Statement)
• setBooleanExpression(BooleanExpression)
• setDynamicTyped(boolean)
• setEndColumn(long)
• setClassLoader(ClassLoader)
• set(T)
• setPreviewFeatures(boolean)
• setDestdir(File)
• setFooter(String)
• setParser(CommandLineParser)
• setProperty(String, Object)
• run(String)
• setClasspath(Path)
• safeNextChar()
• setOrigDouble(boolean)
• setProperty(String, Object)
• setProperty(Object, Object)
• setKeepIgnorableWhitespace(boolean)
• resolveFactory(Object, Map, Object)
• setChild(Object, Object, String, String)
• setFork(boolean)
• run(Class<?>, GroovyClassLoader)
• runStatements(Reader, PrintStream)
• setPropertySpreadSafe(Object, Class, Object, String)
• setColumnNumber(int)
• setCompilationUnit(CompilationUnit)
• setGlobalKeepIgnorableWhitespace(boolean)
• setProperty(String, Object)
• setPropertyName(String)
• setConstantTypesBlackList(List<String>)
• requireFailed(String, String)
• safeExpression(Expression, Expression)
• rightShiftUnsigned(Number, Number)
• setMetaClass(MetaClass)
• setExpression(Expression)
• set(int, E)
• setAutoIndent(boolean)
• setOptionsFromAnnotations(def, Class, Object, boolean)
• setColfill(boolean)
• selectAll(EventObject)
• setImplicitThis(boolean)
• selectMethod(MutableCallSite, Class, String, int, Boolean, Boolean, Boolean, Object, Object)
• setConsoleId(int)
• setProperty(Object, String, Object)
• setBinding(Map)
• setDoubleQuotes(boolean)
• setProperty(String, Object)
• scanClasspathModules()
• setMetaClass(MetaClass)
• setMethodVisitor(MethodVisitor)
• setAttribute(Class, Object, String, Object, boolean, boolean)
• setPropertyOnSuperSafe(Object, Class, GroovyObject, String)
• resolve(Map<String, Object>, List, Map)
• returnValueOfNext()
• setEndLabel(Label)
• setResourceLoader(GroovyResourceLoader)
• setConfigFile(URL)
• setClasspathRef(Reference)
• setEnvironment(String)
• setCandidates(SortedSet<String>)
• setPrimitiveMeta(Class, boolean)
• setMBeanServer(MBeanServerConnection)
• setClosure(Closure)
• setProperty(Class, Object, String, Object, boolean, boolean)
• setProceed(boolean)
• setRequireMain(boolean)
• setClosureSharedVariable(boolean)
• setInitialValueCreator(Closure)
• setClosureSharedVariable(boolean)
• setIsScriptBody()
• setContainingPackage(GroovyPackageDoc)
• setIndentLevel(int)
• setAttribute(Object, String, Object)
• setAutoIndent(boolean)
• serializableFields()
• setMetaClass(MetaClass)
• sameX(Expression, Expression)
• setPackageName(String)
• setAnnotationParameters(Map<String, Object>)
• respondsTo(Object, String)
• setMethodNode(MethodNode)
• setProperty(String, Object)
• setCollectionExpression(Expression)
• setPreserveWhitespace(boolean)
• setAttribute(Class, Object, String, Object, boolean, boolean)
• setProperty(String, Object)
• setParent(Object, Object)
• setNonChangeCheck(boolean)
• setGroovyObjectProperty(Object, GroovyObject, String)
• setAdditionalClassInformation(ClassNode)
• setLineLast(int)
• setCharset(String)
• setLine(int)
• setDeclarationEncoding(String)
• rollback()
• setBinding(Binding)
• setClosureSharedVariable(boolean)
• setResolved(boolean)
• rightShiftUnsignedImpl(Number, Number)
• setAccessible()
• setProperty(String, Object)
• setInStaticContext(boolean)
• setFatal(boolean)
• setResolveStrategy(int)
• setNamespaceTagHints(Map)
• setExpression(Expression)
• setName(String)
• setField(CachedField)
• setParent(Object, Object)
• setMethodTarget(MethodNode)
• setProperty(Object, Object)
• setIncludeDestClasses(boolean)
• setCacheTemplates(boolean)
• setListfiles(boolean)
• setProperty(Object, Object)
• setClosureArgument(Object)
• setKeepJavaMetaClasses(boolean)
• setClasspathRef(Reference)
• setCompileUnit(CompileUnit)
• setRawCommentText(String)
• setProperty(String, Object)
• segmentFor(int)
• returnStatement(Closure)
• setColumn(int)
• setFooter(String)
• setProperties(Object, Map)
• setPreviewFeatures(boolean)
• serializationMethods()
• setCurrent(Object)
• setBeanProperties(MetaClass, Object, Map)
• rightShift(YearMonth, YearMonth)
• setMeaning(int)
• setDelegate(Object)
• reset()
• rightShiftImpl(Number, Number)
• setEmptyMethods(boolean)
• setLine(int)
• setParent(Object, Object)
• setProperty(String, Object)
• setOrigInt(boolean)
• setCandidateStrings(String)
• setFirstSentenceCommentText(String)
• setGetterBlock(Statement)
• setNewMopMethods(List<MetaMethod>)
• setLineLast(int)
• setProperty(String, Object)
• resources()
• setMetaClass(Object, MetaClass)
• setProperty(Class, Object, String, Object, boolean, boolean)
• setBaseNameValidator(Closure<Boolean>)
• respondsTo(Object, String)
• setClassRetention(boolean)
• setBooleanExpression(BooleanExpression)
• setPackageName(String)
• resourceList()
• resolveExplicitProperty(String)
• setOverview(File)
• setDescription(String)
• setCallSites(List<String>)
• setLineNumber(int)
• setExpression(Expression)
• runScript(EventObject)
• setCode(Statement)
• setNamespaceAware(boolean)
• setFieldOnSuperSpreadSafe(Object, Class, Object, String)
• setEqualityCheck(boolean)
• sameClass(Class, Object)
• setCacheNamedQueries(boolean)
• setEncoding(String)
• setParent(Object, Object)
• sameClasses(Class, Object, Object, Object, Object)
• setModule(ModuleNode)
• setGroovyObjectField(Object, Class, GroovyObject, String)
• sep()
• setConverter(Closure)
• setDescription(String)
• setFailonerror(boolean)
• setDelegate(Object)
• setDefaultValue(String)
• setMethodVisitor(MethodVisitor)
• setDTDHandler(DTDHandler)
• setAnnotationDefault(boolean)
• rows(GString, int, int, Closure)
• retainAll(Map<K, V>, Closure)
• returnFalseIfNull(Expression)
• resolve(List<ClassNode[]>, ClassNode, Expression, ClosureExpression, MethodNode, SourceUnit, CompilationUnit, String)
• setChild(FactoryBuilderSupport, Object, Object)
• setIdentifierResolver(Object)
• setParent(FactoryBuilderSupport, Object, Object)
• setOmitEmptyAttributes(boolean)
• setEscapeAttributes(boolean)
• setField(FieldNode)
• setAuthor(boolean)
• resolveChildRelationName(String, Object, String, Object)
• setConverter(Closure)
• resize(int)
• setForceLookupUnnamedFiles(boolean)
• setMetaClass(Class, MetaClass)
• reset()
• returnFalseIfFieldNotEqual(FieldNode, Expression)
• setDefaultScriptExtension(String)
• setModifiers(int)
• resize(int)
• setDirective(int)
• setNodeMetaData(Object, Object)
• setCellpadding(int)
• scopeExit(Closure)
• reverseUpdate()
• setConstantValueExpression(String)
• setOwnerType(ClassNode)
• setNodeMetaData(Object, Object)
• setClasspathRef(Reference)
• run(TestResult)
• run(Closure, String)
• setEditorValue(Closure)
• setErrorHandler(ErrorHandler)
• setProperty(String, Object)
• resolveType(Expression, ClassNode)
• set(Date, Map<Object, Integer>)
• rightShiftUnsigned(long, long)
• set(Object)
• setProperty(Object, String, Object)
• setFilename(String)
• setClosureSharedVariable(boolean)
• setDebug(boolean)
• resetLineNumber()
• setExtensionValidator(Closure<Boolean>)
• run(Class<?>, GroovyClassLoader)
• resolve(int)
• strings(Closure)
• setReverseConverter(Closure)
• setStrict(boolean)
• skipWhiteSpace()
• setWriter(PrintWriter)
• size()
• setTargetDirectory(File)
• suite()
• skip(long)
• size()
• startPrefixMapping(String, String)
• size()
• subtractImpl(Number, Number)
• size()
• shouldFailWithCause(Class, Closure)
• size(StringBuffer)
• setUp(GroovySourceAST)
• setUp()
• setVariable(String, Object)
• setWriter(Writer)
• startDocument()
• stringValueEncoded()
• size()
• setUseReferenceDirectly(boolean)
• spreadMap(Object)
• switchToFastPath()
• subtractImpl(Number, Number)
• size()
• setUseGroovyShell(boolean)
• setRightExpression(Expression)
• swapTwoChildren(GroovySourceAST)
• setup()
• shiftExpression(int)
• setVariable(String, Object)
• setValueAt(Object, int, int)
• setSetterBlock(Statement)
• setScriptBaseClass(String)
• setSourcePosition(ASTNode)
• shortValue()
• subTuple(int, int)
• setUnresolvedSuperClass(ClassNode)
• subSequence(int, int)
• setValue(Object)
• TemplateServlet()
• setUp()
• setWrapped(boolean)
• suspiciousExpressionStatementStart()
• setType(GroovyType)
• setType(GroovyClassDoc)
• tearDown()
• setStacktrace(boolean)
• stringValueEncoded()
• setVararg(boolean)
• singleVariable(AST, AST)
• setStubdir(File)
• size()
• setUp(GroovySourceAST)
• size()
• setStatic(boolean)
• superclass()
• step(int)
• tail(Iterator<T>)
• setUsingGenerics(boolean)
• setSourceRetention(boolean)
• size()
• shouldOptimizeForInt()
• setSourceBuffer(SourceBuffer)
• tearDown()
• setTriggerBean(Object)
• setText(File, String, String)
• setWarningLevel(int)
• showScriptInOutput(EventObject)
• setStaticStarImportsWhitelist(List<String>)
• setStartLabel(Label)
• setVerbose(boolean)
• setWithBlank(boolean)
• subsequences(List<T>)
• size()
• setTargetBinding(TargetBinding)
• shuttlesort(int[], int[], int, int)
• setStatementsBlacklist(List<Class<? extends Statement>>)
• start()
• subMap(Map<K, V>, K)
• take(CharSequence, int)
• stripMargin(String, String)
• setStyleSheetFile(File)
• setText(String)
• subtract(Number, Number)
• stringOf(Closure)
• setStatementLabel(String)
• setType(ClassNode)
• setSrcdir(Path)
• size()
• sum(Iterable)
• start()
• setSpreadSafe(boolean)
• shouldSkip(String, List<String>, List<String>, boolean)
• spread(Map)
• setSafe(boolean)
• syntheticBind()
• signature()
• setValue(V)
• setTargetBinding(TargetBinding)
• setTokensWhitelist(List<Integer>)
• statement(int)
• setStrongMetaClass(MetaClass)
• specifiedClasses()
• startDocument()
• setWeakMetaClass(MetaClass)
• setVariable(String, Object)
• takeWhile(GString, Closure)
• summary()
• setWithoutCustomMetaclassCreationHandle(boolean)
• setVerbose(boolean)
• SingleKeyHashMap(boolean)
• setText(String)
• size()
• tearDown()
• shouldSkipMethodNode(MethodNode)
• switchStatement(AST)
• staticArrayAccess(Lookup, String, MethodType)
• startMethodInference(MethodNode, ErrorCollector)
• superclass()
• size()
• setTargetBinding(TargetBinding)
• setWildcard(boolean)
• splitEachLine(URL, Pattern, String, Closure<T>)
• setTokenType(int)
• setSystemPropertyFromSafe(String)
• shouldSkipClassNode(ClassNode)
• storeType(Expression, ClassNode)
• setVerbose(boolean)
• size()
• suite(String, String, String)
• tearDown()
• stringValue()
• tearDown()
• subListBorders(int)
• setSuperClass(GroovyClassDoc)
• showAbout(EventObject)
• takeRight(SortedSet<T>, int)
• shouldSkipOnDescriptor(boolean, Map, MethodNode, List<ClassNode>, List<ClassNode>)
• shouldFail(Class, Closure)
• setVariable(String, Object)
• sort(List<Object>)
• startDaemon(Thread, String, Closure)
• setStaticImportsBlacklist(List<String>)
• splitEachLine(InputStream, Pattern, Closure<T>)
• setStarImportsBlacklist(List<String>)
• specifiedPackages()
• setValueAt(Object, int, int)
• setType(ClassNode)
• setValign(String)
• setSuperClassName(String)
• swap(short[], int, int)
• subclassOf(GroovyClassDoc)
• setSourceBuffer(SourceBuffer)
• tearDown()
• setSummary(String)
• takeWhile$$bridge(CharSequence, Closure)
• tableChanged(TableModelEvent)
• size()
• setValidator(Closure)
• setVerbose(boolean)
• subList(int, int)
• setUp()
• statementListNoChild(AST, AST)
• switchToSlowPath()
• setUp()
• superclassType()
• stopThreadedReferenceManager()
• size()
• setVariableScope(VariableScope)
• setWindowtitle(String)
• setReturnType(GroovyType)
• setSrc(File)
• subtractImpl(Number, Number)
• setStaticStarImportsBlacklist(List<String>)
• test(MethodNode)
• setSpreadSafe(boolean)
• setTokensBlacklist(List<Integer>)
• setScriptBody(boolean)
• smallerFont(EventObject)
• suite(String, String, String)
• swap(int, int)
• startElement(String, String, String, Attributes)
• skipWhitespace()
• setResultSetHoldability(int)
• spread(Closure)
• statistic()
• syntheticUnbind()
• size()
• setUp()
• supportsDivision()
• systemDefault(ZoneOffset)
• subpath(int, int)
• size(JTabbedPane)
• stopThread()
• setSuperClass(ClassNode)
• setScript(boolean)
• setRowfill(boolean)
• tap(U, Closure<T>)
• setSourcePosition(ASTNode)
• size(StringBuilder)
• sha256(byte[])
• superclassType()
• shouldSkipOnDescriptorUndefinedAware(boolean, Map, MethodNode, List<ClassNode>, List<ClassNode>)
• shortValue()
• summary()
• setScriptExtension(String)
• startElement(String, String, String, Attributes)
• setRuntimeRetention(boolean)
• showScriptFreeForm(EventObject)
• setSourceLocator(String)
• stringValueEncoded()
• startRange(Label)
• subList(int, int)
• stringValue()
• size()
• setSourcepath(Path)
• size()
• storeTargetMethod(Expression, MethodNode)
• showOutputWindow(EventObject)
• simpleTypeName()
• setScriptExtensions(Set<String>)
• setTargetBinding(TargetBinding)
• size(File)
• setText(String)
• setTargetBytecode(String)
• sortClasses()
• showDialog(boolean)
• storeVar(BytecodeVariable)
• subtractImpl(Number, Number)
• showTreeView(EventObject)
• text()
• size()
• setSynthetic(boolean)
• startElement(String, String, String, Attributes)
• size()
• setRightExpression(Expression)
• setSrcdir(Path)
• statementList(AST)
• simpleTypeName()
• setUpdate(Closure)
• switchStatement(Closure)
• subSequence(int, int)
• subList(int, int)
• tails(Iterable<T>)
• setStopAtNonOption(boolean)
• subSequence(int, int)
• showScriptClass(EventObject)
• strictContextExpression(boolean)
• setValue(Object)
• shortValue()
• setSyntheticPublic(boolean)
• setShowLineNumbers(boolean)
• smallerFont(EventObject)
• setVariable(String, Object)
• startResolving(ClassNode, SourceUnit)
• syntheticBind()
• setSourcepathRef(Reference)
• setTableHeader(boolean)
• tableChanged(TableModelEvent)
• step(Number, Number, Number, Closure)
• sortByColumn(int, boolean)
• setSystemProperty(String)
• setReverseConverter(Closure)
• syntheticUnbind()
• setUseDoubleQuotes(boolean)
• sput(Object, Object, int)
• setStartColumn(long)
• setResultSetType(int)
• shortUnbox(Object)
• setValue(V)
• setValue(Object, Object, int, int)
• size()
• setStarImportsWhitelist(List<String>)
• setText(File, String, String)
• synchronizedStatement(AST)
• setScript(boolean)
• superclass()
• size()
• setVariable(String, Object)
• setTolerance(int)
• setSourceUnitValidator(Closure<Boolean>)
• setType(ClassNode)
• skipWhiteSpace(char[], int, int)
• subsequences(List<T>)
• setScriptBaseClass(String)
• setRowspan(int)
• synchronize()
• startsWithAny(CharSequence, CharSequence)
• setVariableScope(VariableScope)
• stream(float[])
• size()
• size()
• skippedEntity(String)
• switchToFastPath()
• stmt(Expression)
• setSyntheticPublic(boolean)
• size()
• shiftExpression()
• swap()
• superclass()
• subsequentVisit(GroovySourceAST)
• setSystemPropertyFrom(String)
• setupTransform(AnnotationNode)
• setStaticClass(boolean)
• sum(Iterator<T>, Object, Closure)
• spreadExpression(AST)
• targetToName(int)
• startPrefixMapping(String, String)
• size()
• setTryStatement(Statement)
• sremove(Object, int)
• setSrcdir(Path)
• setValueAt(Object, int, int)
• setType(JsonTokenType)
• shortName(Object)
• shortcut(String, def)
• text()
• startDocument()
• showExecutingMessage()
• start()
• setVariableScope(VariableScope)
• shouldHandleImplicitThisForInnerClass(ClassNode)
• shouldSkipUndefinedAware(String, List<String>, List<String>, boolean)
• syntheticUnbind()
• subtractImpl(Number, Number)
• take(String, int)
• skipWhiteSpace()
• size(File)
• setUsage(String)
• subList(int, int)
• takeWhile(Iterator<T>, Closure)
• size()
• skip(long)
• simpleTypeName()
• setVariableScope(VariableScope)
• supportsDivision()
• setType(GroovyType)
• splitEachLine(String, String, Closure<T>)
• setType(ClassNode)
• setStartLine(long)
• setReverseConverter(Closure)
• stringLog(Level, String, Closure)
• sprintf(Object, String, Object)
• setSourceBinding(SourceBinding)
• tags()
• superclassType()
• start(Thread, String, Closure)
• shouldExcludeType(Class<?>)
• showAbout(EventObject)
• split(String)
• size()
• setType(ClassNode)
• setType(ClassNode)
• supportsDivision()
• setType(ClassNode)
• sort(SortedMap<K, V>)
• size()
• size()
• setText(Object, String)
• stringValue()
• spreadMap(Closure)
• text()
• stripIndent(String, int)
• setType(JsonParserType)
• showCompilingMessage()
• setValue(Object)
• setReturnType(ClassNode)
• startingWith(char)
• setValue(Object)
• size()
• subclassOf(GroovyClassDoc)
• step(int)
• subtractImpl(Number, Number)
• size()
• singleDeclarationNoInit()
• subList(int, int)
• switchToSlowPath()
• subListBorders(int, EmptyRange)
• stringValueEncoded()
• size()
• shortValue()
• shouldFailWithCause(Class, Closure)
• subclassOf(GroovyClassDoc)
• shouldFail(String)
• step(int)
• singleton()
• stacktrace(Throwable, boolean)
• simpleTypeName()
• splitEachLine(InputStream, Pattern, Closure<T>)
• superclassType()
• setValue(Object)
• setValue(Element, String)
• setTerminalType(String, boolean)
• setTypeName(String)
• setSourceEncoding(String)
• setStatementsWhitelist(List<Class<? extends Statement>>)
• setValue(Object)
• setType(ClassNode)
• size()
• synchronizedStatement(Closure)
• sleep(Object, long, Closure)
• setup()
• startsWith(String)
• setSourceBinding(SourceBinding)
• size()
• setSourceBinding(SourceBinding)
• tearDown(GroovySourceAST)
• splitEachLine(Path, Pattern, String, Closure<T>)
• setValue(Object)
• ternaryExpression(AST)
• setValue(V)
• step(int)
• setVariableScope(VariableScope)
• setValidator(Closure)
• specifiedClasses()
• shouldOptimizeForInt()
• summary()
• statement(AST)
• setUp()
• skipWhiteSpace()
• setUpdatedProperty(String)
• size()
• setText(Path, String, String)
• setSourceBinding(SourceBinding)
• setType(ClassNode)
• superClassClause()
• setType(ClassNode)
• setResourceLoader(GroovyResourceLoader)
• setValue(Value)
• setStacktrace(boolean)
• skip(GroovySourceAST)
• staticMethodCall(MethodClosure, Closure)
• supportsDivision()
• showIndyBytecode(EventObject)
• shortValue()
• sort(Object)
• size()
• ternaryX(Expression, Expression, Expression)
• setResultSetConcurrency(int)
• spreadMapExpression(AST)
• split(String)
• showClosureClasses(EventObject)
• text(NodeList)
• setValueExpression(Expression)
• setup()
• storeInferredTypeForPropertyExpression(PropertyExpression, ClassNode)
• subclassOf(GroovyClassDoc)
• setVariables(ServletBinding)
• setup()
• size(Path)
• setVerbosity(IO.Verbosity)
• setValue(Object)
• storeInferredReturnType(ASTNode, ClassNode)
• step(int)
• size()
• tails(Iterable<T>)
• sputs(Object)
• size()
• size()
• specifiedPackages()
• setValidator(Closure)
• setStaticImportsWhitelist(List<String>)
• statementLabelPrefix()
• setSnippet(String)
• size()
• store(MethodVisitor, ClassNode, int)
• setShouldRecompile(Boolean)
• setVariableScope(VariableScope)
• sort(Closure)
• setScriptBaseClass(String)
• stringValue()
• setValue(Object)
• size()
• stripMargin(String, String)
• shortName(Class)
• storeType(Expression, ClassNode)
• silentlyVisitMethodNode(MethodNode)
• size()
• setTrimWhitespace(boolean)
• stop()
• statement()
• show()
• setSaveStreams(boolean)
• size(NodeList)
• signature()
• setTypeParameters(String)
• showMessage(String)
• skip(long)
• setUsingGenerics(boolean)
• setSourcepath(Path)
• setWidth(int)
• stripIndent(String, int)
• size()
• stop()
• setUnwrapped(boolean)
• spreadMap(Object)
• setReturnType(GroovyType)
• setRowNumAndColNum()
• setTargetBinding(TargetBinding)
• setTargetBytecode(String)
• startGroovysh(String, List<String>)
• setStatic(boolean)
• setUse(boolean)
• subList(int, int)
• size()
• superClassClause()
• text()
• setupTransform(AnnotationNode)
• staticInit(AST)
• subSequence(int, int)
• showAbout(EventObject)
• size()
• simpleTypeName()
• singleDeclaration()
• syntheticBind()
• showToolbar(EventObject)
• setUseReferenceDirectly(boolean)
• setWritingAttribute(boolean)
• snippetUnit()
• type()
• typeParameterBounds()
• toString()
• toString()
• toTimeZone(ZoneOffset)
• transformResult(def, List<Closure>)
• unaryPlusImpl(Number)
• uncapitalize(String)
• visit(ASTNode, SourceUnit)
• visit(GroovyCodeVisitor)
• visit(GroovyCodeVisitor)
• trunc(BigDecimal, int)
• toArray(T)
• usage()
• unescaped()
• transform(Expression)
• toFloat()
• toString()
• values()
• visit(GroovyCodeVisitor)
• transformExpression(ExpressionTransformer)
• unbind()
• variableDefinitions(AST, AST)
• typeName()
• toValue()
• toValue()
• transformExpression(ExpressionTransformer)
• transformExpression(ExpressionTransformer)
• touch(Object, Object)
• thrownExceptions()
• transformExpression(ExpressionTransformer)
• unwrap(Object)
• validateProperties(AbstractASTTransformation, BlockStatement, ClassNode, List<PropertyNode>)
• transformMethodCallExpression(MethodCallExpression)
• toString()
• typeName()
• unaryMinusImpl(Number)
• tokenAsSql(Token)
• transformExpression(ExpressionTransformer)
• transformVariableExpression(VariableExpression)
• verbose(String)
• transformExpression(ExpressionTransformer)
• type()
• toString()
• toString()
• unsupportedAttribute(BuilderASTTransformation, AnnotationNode, String, String)
• toString()
• toString()
• toJson(Map)
• visit(ASTNode, SourceUnit)
• visit(GroovyCodeVisitor)
• toBigInteger(String)
• transformMethodCallExpression(MethodCallExpression)
• transformExpression(ExpressionTransformer)
• toString()
• unaryMinusImpl(Number)
• unescape(String)
• verify(GroovyObject)
• toListString(Collection, int, boolean)
• visit(GroovyCodeVisitor)
• toString()
• transformCSTIntoAST(SourceUnit, Reader, SourceBuffer)
• typeArgumentsOrParametersEnd()
• visit(GroovyCodeVisitor)
• toShort(String)
• typeParameters()
• toBigInteger(Number)
• transformExpression(ExpressionTransformer)
• toString()
• toString()
• toURI(String)
• transformExpressions(List<? extends Expression>, ExpressionTransformer, Class<T>)
• visit(GroovyCodeVisitor)
• toString()
• transformExpression(ExpressionTransformer)
• toShort(String)
• toString()
• values()
• toYearMonth(Date)
• transformRangeExpression(RangeExpression)
• transformExpression(ExpressionTransformer)
• typeArgumentsDiamond()
• toLowerCase(Character)
• toArray(Object)
• tokenizeUnquoted(String)
• variableDeclarator(AST, AST)
• toSet(BaseStream<T, ? extends BaseStream>)
• toString()
• transformClosureExpression(ClosureExpression)
• updateTargetValue(Object)
• transformVariableExpression(VariableExpression)
• unexpandLine(String, int)
• throwStatement(Closure)
• valueChanged(ListSelectionEvent)
• toInteger(String)
• typeParameters()
• token(Closure<Boolean>)
• unaryPlus(Number)
• validateAttributes(AbstractASTTransformation, AnnotationNode)
• toProperties(String)
• toString()
• toInteger()
• updated(Date, Map<Object, Integer>)
• toString()
• use(List<Class>, Closure<T>)
• typeName()
• updateLocalSyntheticProperties(Map<String, TriggerBinding>)
• toString()
• unaryMinus(Number)
• toString()
• unwrap()
• transformBinaryExpression(BinaryExpression)
• visit(ASTNode, SourceUnit)
• transpose(List)
• visit(GroovyCodeVisitor)
• visit(GroovyCodeVisitor)
• throwParserException()
• toString()
• toEnum(Class<T>, int)
• upto(BigDecimal, Number, Closure)
• transformExpression(ExpressionTransformer)
• validateProperties(AbstractASTTransformation, BlockStatement, ClassNode, List<PropertyNode>)
• transformExpression(ExpressionTransformer)
• transformExpression(ExpressionTransformer)
• visit(ASTNode, SourceUnit)
• transformExpression(ExpressionTransformer)
• variableDef(AST)
• toString(Object)
• traverse(Path, Map<String, Object>)
• tryBridgeMethod(MethodNode, Expression, boolean, TupleExpression, ClassNode)
• toString()
• updateTargetValue(Object)
• toUpperCase(Character)
• toString()
• values()
• unaryPlusImpl(Number)
• toFloat(String)
• toRowResult(ResultSet)
• visit(ASTNode, SourceUnit)
• typeArgumentBounds()
• toString()
• unaryExpression(int)
• toBigDecimal()
• transformExpression(ExpressionTransformer)
• transformAnnotationConstantExpression(AnnotationConstantExpression)
• unaryMinus(Closure)
• toString(Object)
• tokenListToEvalString(List<GroovySourceToken>)
• toString()
• toString()
• variableNotAlwaysInitialized(VariableExpression)
• thrown()
• toString()
• transformInlineConstants(Expression)
• toString(Exception)
• typeDefinition()
• toString()
• throwException(String)
• visit(AnnotationNode, AnnotationNode, AnnotatedNode, SourceUnit)
• verify()
• toString()
• toString()
• tryRelease(int)
• transformCastExpression(CastExpression)
• tryCatch(Closure)
• toOffsetDateTime(Date)
• visit(GroovyCodeVisitor)
• unaryMinusImpl(Number)
• visit(ASTNode, SourceUnit)
• transform(Expression)
• text()
• tryAcquire(int)
• toString()
• toString()
• toString()
• unbind()
• tokenize(String, String)
• toEnum(Class<T>)
• toBigDecimal(Number)
• typeArgument()
• visit(ASTNode, SourceUnit)
• use(GroovyObject, Closure)
• unaryMinus(Object)
• variableReplaced(VariableExpression, VariableExpression)
• visit(ASTNode, SourceUnit)
• transformClass(ClassNode)
• typeCheckMethodArgumentWithGenerics(ClassNode, ClassNode, boolean)
• toDate(TimeZone, int, int, int, int, int, int, int)
• transformLine(Reader, Writer, Closure)
• unaryMinusImpl(Number)
• toString()
• varInitializer()
• toString()
• toString()
• toSpreadMap(Iterable)
• visit(ASTNode, SourceUnit)
• toString()
• updateTargetValue(Object)
• toString()
• token(String)
• text()
• visit(GroovyCodeVisitor)
• text()
• values(Closure)
• toString()
• visit(GroovyCodeVisitor)
• toString()
• typeArgumentsOrParametersEnd()
• values()
• visit(ASTNode, SourceUnit)
• toMilliseconds()
• values()
• visit(ASTNode, SourceUnit)
• verifyValue()
• toDayOfWeek(Date)
• uncapitalize(CharSequence)
• transformChar(Reader, Writer, Closure)
• unaryExpressionNotPlusMinus(int)
• transform(Expression)
• visit(GroovyCodeVisitor)
• typeCheckClosureCall(Expression, ClassNode, Parameter)
• visit(GroovyCodeVisitor)
• validate()
• toCharArray(String)
• text()
• toAbsolutePath()
• tryBlock()
• typeArguments()
• transformClosureExpression(ClosureExpression)
• visit(ASTNode, SourceUnit)
• typeNamePairs(AST, Token)
• toString()
• toString()
• update()
• transformListOfConstants(ListExpression, ClassNode)
• typeName()
• toListString(Collection, int)
• unwrap()
• unaryMinusImpl(Number)
• UnicodeEscapingReader(Reader, SourceBuffer)
• text()
• threadInterruption(EventObject)
• upto(Calendar, Calendar, Closure)
• toString()
• transformExpression(ExpressionTransformer)
• type()
• transformExpression(ExpressionTransformer)
• toBigInteger(String)
• value()
• toString()
• variable(String)
• toString()
• toURI(String)
• unexpand(String, int)
• visit(GroovyCodeVisitor)
• toURL(String)
• variableLengthParameterDeclaration()
• traceIn(String)
• visit(ASTNode, SourceUnit)
• toGenericTypesString(GenericsType)
• verify(List)
• transformExpression(ExpressionTransformer)
• transform(Expression)
• traverse(File, Map<String, Object>)
• toJson(Object)
• toString()
• tr(String, String, String)
• toString()
• upperBound(Closure)
• typeCheckMethodsWithGenericsOrFail(ClassNode, ClassNode, MethodNode, Expression)
• toCharArray(String)
• toUri()
• transformDeclarationExpression(DeclarationExpression)
• urlsFor(String)
• visit(ASTNode, SourceUnit)
• toString()
• visit(GroovyCodeVisitor)
• visit(GroovyCodeVisitor)
• verify()
• transformExpression(ExpressionTransformer)
• type()
• toString()
• toString()
• toBigDecimal()
• toString()
• values()
• undo(EventObject)
• toIntegerWrapper()
• transformExpression(ExpressionTransformer)
• updatePath(PropertyChangeListener, Object, Set)
• toString()
• visit(ASTNode, SourceUnit)
• toMilliseconds()
• thrownExceptionTypes()
• typeSpec(boolean)
• type()
• toString()
• unaryPlusExpression(AST)
• toString()
• unaryMinusImpl(Number)
• throwRuntimeException(Throwable)
• typeName()
• visit(GroovyCodeVisitor)
• typeParameter()
• toBigInteger()
• toYear(Date)
• updateHash(int, double[])
• visit(GroovyCodeVisitor)
• tr(String, String, String)
• toURL(String)
• toCalendar(Date)
• transformExpression(ExpressionTransformer)
• toMonth(Date)
• toLong()
• unexpand(String, int)
• trimEdits(int, int)
• type()
• toString()
• visit(ASTNode, SourceUnit)
• update()
• toString()
• visit(MethodVisitor)
• toFloat(String)
• toString()
• visit(GroovyCodeVisitor)
• toString()
• unaryPlus(Number)
• unescapeJava(Writer, String)
• transformToPrimitiveConstantIfPossible(ConstantExpression)
• toLocalDate(Date)
• toTimestamp(Date)
• toString()
• typeArgumentBounds()
• thrownExceptions()
• unbox(MethodVisitor, ClassNode)
• typeArgumentSpec()
• type()
• toCharArray()
• values()
• tryFindPossibleMethod(String, Expression)
• validateProperties(AbstractASTTransformation, BlockStatement, ClassNode, List<PropertyNode>)
• unregisterTextComponent(JTextComponent)
• varX(String, ClassNode)
• unaryPlusImpl(Number)
• visit(GroovyCodeVisitor)
• update()
• trampoline()
• update()
• visit(GroovyCodeVisitor)
• transformLine(Reader, Writer, Closure)
• toList(String)
• transform(Expression)
• transformExpression(ExpressionTransformer)
• toValue()
• toMonthDay(Date)
• toBigDecimal(String)
• validateAttributes(AbstractASTTransformation, AnnotationNode)
• updateTitle()
• toString()
• visit(GroovyCodeVisitor)
• values()
• transformExpression(ExpressionTransformer)
• transformVariableExpression(VariableExpression)
• validate()
• transformPropertyExpression(PropertyExpression)
• unaryMinus(Number)
• toArrayString(Object)
• toTypeString(Object, int)
• visit(ASTNode, SourceUnit)
• toString()
• unescapeJavaScript(Writer, String)
• toCompilerConfiguration()
• visit(GroovyCodeVisitor)
• visit(ASTNode, SourceUnit)
• variableDefinitions(AST, AST)
• toString()
• toBoolean(String)
• toLocalDateTime(Date)
• tuple(Closure)
• thrown()
• toList(String)
• toMapString(Map, int)
• throwS(Expression)
• visit(GroovyCodeVisitor)
• toString()
• unmarshal(JAXBContext, String, Class<T>)
• toString()
• transformExpression(ExpressionTransformer)
• unlock()
• toString()
• use(GroovyObject, Closure)
• validateAttributes(AbstractASTTransformation, AnnotationNode)
• traitDefinition(AST)
• toString()
• transformExpression(ExpressionTransformer)
• toDebugString()
• toList()
• value()
• toString()
• transformExpression(ExpressionTransformer)
• updated(Date, Map<Object, Integer>)
• values()
• unknownAST(AST)
• toTimestamp(Date)
• visit(ASTNode, SourceUnit)
• unwrap()
• visit(GroovyCodeVisitor)
• typeSpec(boolean)
• typeCheckAssignment(BinaryExpression, Expression, ClassNode, Expression, ClassNode)
• visit(ASTNode, SourceUnit)
• transform(Expression)
• toString()
• toMilliseconds()
• transformExpression(ExpressionTransformer)
• toStringAndRecycle()
• transformExpression(ExpressionTransformer)
• transformExpression(ExpressionTransformer)
• type()
• typeArguments()
• toString()
• unlock()
• toString()
• toBigDecimal(String)
• typeName()
• toEnum(Class<T>)
• toList(BaseStream<T, ? extends BaseStream>)
• transformToSetterCall(Expression, MethodNode, Expression, boolean, boolean, boolean, boolean, Expression)
• utc(long)
• variableDeclarator(AST, AST, Token)
• toString()
• unwrap(Object)
• toArray()
• unbind()
• transformExpression(ExpressionTransformer)
• toString()
• throwsList(AST, List<ClassNode>)
• times(Number, Closure)
• transformExpression(ExpressionTransformer)
• toString()
• tokenize(String, String)
• toBigInteger()
• toUnique(T, Closure)
• transformExpression(ExpressionTransformer)
• visit(GroovyCodeVisitor)
• toString()
• type()
• toString()
• toLong(String)
• transformBinaryConstantExpression(BinaryExpression, ClassNode)
• toString()
• update()
• toBoolean(String)
• values()
• unaryPlusImpl(Number)
• visit(GroovyCodeVisitor)
• unique(MethodNode)
• VariableScopeVisitor(SourceUnit)
• uponEOF()
• tryBlock()
• toDouble(String)
• toString()
• toString()
• visit(GroovyCodeVisitor)
• toString()
• unaryPlus(Object)
• typeDefinitionInternal(AST)
• unique(List<T>, boolean, Comparator<T>)
• visit(MethodVisitor)
• toMapString(Map, int)
• typeDefinitionStart()
• toInteger(String)
• transpose(List)
• unbind()
• unaryPlus(Closure)
• uninstallArtifact(String, String, String)
• toString()
• transformExpression(ExpressionTransformer)
• toCharArray(String)
• toList()
• upto(Calendar, Calendar, Closure)
• use(List<Class>, Closure<T>)
• toBoolean()
• visit(ASTNode, SourceUnit)
• values()
• toString()
• toString()
• throwStatement(AST)
• traditionalForClause()
• toArray(T)
• use(GroovyObject, Closure)
• toString()
• unmarshal(JAXBContext, String, Class<T>)
• unbind()
• typeCheckMethodsWithGenerics(ClassNode, ClassNode, MethodNode)
• toString()
• use(Object, Object)
• verify()
• undo()
• transformExpression(ExpressionTransformer)
• typeParameters()
• variableExpression(AST)
• visit(ASTNode, SourceUnit)
• toLong(String)
• values()
• toSet(String)
• undeclareBean(BSFDeclaredBean)
• variableNotFinal(Variable, Expression)
• toString()
• visit(AnnotationNode)
• toURI()
• transformExpression(ExpressionTransformer)
• toPrettyString()
• toFloat()
• visit(ASTNode, SourceUnit)
• toString()
• useAccessible()
• thrown()
• values()
• typeDefinitionInternal(AST)
• transformChar(Reader, Writer, Closure)
• toDouble()
• transformExpression(ExpressionTransformer)
• typeArgumentsOrDiamond()
• toArray(T)
• toString(boolean)
• unaryPlus(Object)
• type(AST)
• toEnum(Class<T>, int)
• visit(GroovyCodeVisitor)
• throwsClause()
• transformExpression(ExpressionTransformer)
• unexpandLine(String, int)
• toString()
• updateConstantMetaClass(MetaClassRegistryChangeEvent)
• toArrayString(Object, int, boolean)
• visit(ASTNode, SourceUnit)
• toJson(Object)
• toString()
• toString()
• traceOut(String)
• toLocalTime(Date)
• tryStatement(AST)
• toCharacter(String)
• typeArgumentSpec()
• transform(Expression)
• visit(GroovyCodeVisitor)
• transform(Expression)
• visit(GroovyCodeVisitor)
• toSet(String)
• toString()
• validateAttributes(AbstractASTTransformation, AnnotationNode)
• visit(GroovyCodeVisitor)
• transformBinaryExpression(BinaryExpression)
• text()
• toString()
• toDouble(String)
• thrownExceptionTypes()
• throwsClause()
• transformExpression(ExpressionTransformer)
• transformExpression(ExpressionTransformer)
• visit(GroovyCodeVisitor)
• toZoneOffset(TimeZone, Instant)
• visit(GroovyCodeVisitor)
• toString()
• toString()
• unaryExpressionNotPlusMinus()
• unaryExpression()
• type()
• tokenizeBuffer(String, List<String>, List<GroovySourceToken>)
• toString()
• visit(String, Object)
• transform(Expression)
• visit(GroovyCodeVisitor)
• toString()
• visit(MethodVisitor)
• unescaped(CharSequence)
• typeName()
• toString()
• visit(GroovyCodeVisitor)
• toOffsetTime(Date)
• unit()
• unaryPlusImpl(Number)
• variableName()
• vararg()
• toString()
• visit(GroovyCodeVisitor)
• toString()
• toCharacter(String)
• toURL()
• values()
• toFile()
• typeParameter()
• toRowResult(ResultSet)
• toArray(T)
• tryEscape(Object)
• undoableEditHappened(UndoableEditEvent)
• toString(Object)
• values()
• visit(ASTNode, SourceUnit)
• visit(GroovyCodeVisitor)
• transformExpression(ExpressionTransformer)
• toString()
• unaryMinusExpression(AST)
• toString()
• toCharArray(CharSequence)
• toString()
• visit(GroovyCodeVisitor)
• typeParameterBounds()
• toRealPath(LinkOption)
• toString()
• toCalendar(ZonedDateTime)
• updateSelected(List)
• upto(Temporal, Temporal, TemporalUnit, Closure)
• validateFiles(String)
• visit(GroovyCodeVisitor)
• visit(ASTNode, SourceUnit)
• unaryPlusImpl(Number)
• type()
• visit(GroovyCodeVisitor)
• toString()
• toDate(ZonedDateTime)
• toZonedDateTime(Date)
• values()
• validateProperties(AbstractASTTransformation, BlockStatement, ClassNode, List<PropertyNode>)
• toLong()
• toDouble()
• toValue()
• upperCaseIdent()
• varInitializer()
• toInstant(Calendar)
• transformExpression(ExpressionTransformer)
• toString()
• toString()
• tr(String, String, String)
• unbind()
• value()
• visit(AnnotationNode, AnnotationNode, AnnotatedNode, SourceUnit)
• toString()
• valueOf(String)
• visit(ASTNode, SourceUnit)
• values()
• toString()
• visit(ASTNode, SourceUnit)
• tokenType()
• toString()
• transformPropertyExpression(PropertyExpression)
• toInteger()
• variableReplaced(VariableExpression, VariableExpression)
• unaryMinus(Object)
• typeArgument()
• toString()
• unwrap(GroovyRuntimeException)
• toCalendar(Date)
• tokenize(String)
• traverse(File, Map<String, Object>)
• toString()
• type()
• toSorted(SortedMap<K, V>)
• visitArgumentlistExpression(ArgumentListExpression)
• visitEmptyStatement(EmptyStatement)
• visitLiteralVolatile(GroovySourceAST, int)
• visitBandAssign(GroovySourceAST, int)
• visitField(FieldNode)
• visitCtorCall(GroovySourceAST, int)
• visitIndexOp(GroovySourceAST, int)
• visitCaseStatement(CaseStatement)
• visitLiteralNull(GroovySourceAST, int)
• visitForLoop(ForStatement)
• visitAnnotations(GroovySourceAST, int)
• visitBlockStatement(BlockStatement)
• visitInc(GroovySourceAST, int)
• visitLiteralTrue(GroovySourceAST, int)
• visitBitwiseNegationExpression(BitwiseNegationExpression)
• visitField(FieldNode)
• visitCaseStatement(CaseStatement)
• visitDoWhileLoop(DoWhileStatement)
• visitClassDef(GroovySourceAST, int)
• visitLor(GroovySourceAST, int)
• visitLiteralBreak(GroovySourceAST, int)
• visitLiteralThrow(GroovySourceAST, int)
• visitLabeledArg(GroovySourceAST, int)
• visitBsr(GroovySourceAST, int)
• visitLiteralDouble(GroovySourceAST, int)
• visitLor(GroovySourceAST, int)
• visit(ASTNode, SourceUnit)
• visitBreakStatement(BreakStatement)
• visitGStringExpression(GStringExpression)
• visitDivAssign(GroovySourceAST, int)
• visitExtendsClause(GroovySourceAST, int)
• visitDot(GroovySourceAST, int)
• visitClassEnd()
• visitLiteralAs(GroovySourceAST, int)
• visitFieldAttribute(Attribute)
• visitLiteralIf(GroovySourceAST, int)
• visitMapEntryExpression(MapEntryExpression)
• visitLiteralShort(GroovySourceAST, int)
• visitInstanceInit(GroovySourceAST, int)
• visitLparen(GroovySourceAST, int)
• visitIincInsn(int, int)
• visitLiteralSwitch(GroovySourceAST, int)
• visitLiteralAssert(GroovySourceAST, int)
• visitForLoop(ForStatement)
• visitClass(ClassNode)
• visitIfElse(IfStatement)
• visitIfElse(IfStatement)
• visitBnot(GroovySourceAST, int)
• visitDigit(GroovySourceAST, int)
• visit(GroovyCodeVisitor)
• visitLiteralDefault(GroovySourceAST, int)
• visitInvokeDynamicInsn(String, String, Handle, Object)
• visitElist(GroovySourceAST, int)
• visitClass(ClassNode)
• visitInstanceInit(GroovySourceAST, int)
• visitMapExpression(MapExpression)
• visitInc(GroovySourceAST, int)
• visitClassCodeContainer(Statement)
• visitImplicitParameters(GroovySourceAST, int)
• visitAssertStatement(AssertStatement)
• visitConstantExpression(ConstantExpression)
• visitIfElse(IfStatement)
• visitEnumExpression(String, PropertyExpression, ClassNode)
• visitField(FieldNode)
• visitForLoop(ForStatement)
• visitDynamicMember(GroovySourceAST, int)
• visitDefault(GroovySourceAST, int)
• visitLiteralInterface(GroovySourceAST, int)
• visitBlockStatement(BlockStatement)
• visitCastExpression(CastExpression)
• visitLabeledArg(GroovySourceAST, int)
• visitListOfExpressions(List<? extends Expression>)
• visitBreakStatement(BreakStatement)
• visitConstantExpression(ConstantExpression)
• visitCtorIdent(GroovySourceAST, int)
• visitContinueStatement(ContinueStatement)
• visitCtorCall(GroovySourceAST, int)
• visitCtorCall(GroovySourceAST, int)
• visit(GroovyCodeVisitor)
• visitField(FieldNode)
• visitBorAssign(GroovySourceAST, int)
• visitForIterator(GroovySourceAST, int)
• visitExpression(String, Expression, ClassNode)
• visitLiteralThrows(GroovySourceAST, int)
• visitLiteralImport(GroovySourceAST, int)
• visitLiteralPackage(GroovySourceAST, int)
• visitLiteralDouble(GroovySourceAST, int)
• visitField(FieldNode)
• visitLiteralLong(GroovySourceAST, int)
• visitLiteralNative(GroovySourceAST, int)
• visitClass(ClassNode)
• visitBlockStatement(BlockStatement)
• visitListExpression(ListExpression)
• visitFieldExpression(FieldExpression)
• visitDeclarationExpression(DeclarationExpression)
• visitExpressionStatement(ExpressionStatement)
• visitLiteralSuper(GroovySourceAST, int)
• visitArrayExpression(ArrayExpression)
• visitBsr(GroovySourceAST, int)
• visitLiteralVolatile(GroovySourceAST, int)
• visitClass(ClassNode)
• visitArrayExpression(ArrayExpression)
• visitIndexOp(GroovySourceAST, int)
• visitExponent(GroovySourceAST, int)
• visitLiteralBoolean(GroovySourceAST, int)
• visitExpr(GroovySourceAST, int)
• visit(ASTNode, SourceUnit)
• visitBxorAssign(GroovySourceAST, int)
• visitEnumDef(GroovySourceAST, int)
• visitBytecodeExpression(BytecodeExpression)
• visitBinaryExpression(BinaryExpression)
• visitCompareTo(GroovySourceAST, int)
• visitMapExpression(MapExpression)
• visitClass(ClassNode)
• visit(ASTNode, SourceUnit)
• visitLand(GroovySourceAST, int)
• visitImplicitParameters(GroovySourceAST, int)
• visitLiteralInstanceof(GroovySourceAST, int)
• visitField(FieldNode)
• visitForInit(GroovySourceAST, int)
• visitDot(GroovySourceAST, int)
• visitClassCodeContainer(Statement)
• visitFinal(GroovySourceAST, int)
• visitLiteralByte(GroovySourceAST, int)
• visitAnnotation(GroovySourceAST, int)
• visitBreakStatement(BreakStatement)
• visitAnnotations(AnnotatedNode)
• visitLineNumber(int, Label)
• visitLiteralCase(GroovySourceAST, int)
• visitBnot(GroovySourceAST, int)
• visitBlockStatement(BlockStatement)
• visitAnnotationEnd()
• visitLiteralImport(GroovySourceAST, int)
• visitLiteralBreak(GroovySourceAST, int)
• visitLiteralThis(GroovySourceAST, int)
• visitBnot(GroovySourceAST, int)
• visitBsr(GroovySourceAST, int)
• visitInterfaceDef(GroovySourceAST, int)
• visitArrayExpression(ArrayExpression)
• visitCaseStatement(CaseStatement)
• visitClassExpression(ClassExpression)
• visitLe(GroovySourceAST, int)
• visitBreakStatement(BreakStatement)
• visitLor(GroovySourceAST, int)
• visitBlockStatement(BlockStatement)
• visitConstantExpression(ConstantExpression)
• visitLor(GroovySourceAST, int)
• visitClass(ClassNode)
• visitBinaryExpression(BinaryExpression)
• visitLiteralPrivate(GroovySourceAST, int)
• visitLiteralStatic(GroovySourceAST, int)
• visitField(FieldNode)
• visitArray(String)
• visitIfElse(IfStatement)
• visitLabeledArg(GroovySourceAST, int)
• visit(GroovyCodeVisitor)
• visitDigit(GroovySourceAST, int)
• visitDefault(GroovySourceAST, int)
• visitClosedBlock(GroovySourceAST, int)
• visitCompareTo(GroovySourceAST, int)
• visitImplicitParameters(GroovySourceAST, int)
• visitExponent(GroovySourceAST, int)
• visitLiteralAssert(GroovySourceAST, int)
• visitClosureExpression(ClosureExpression)
• visitDoWhileLoop(DoWhileStatement)
• visitLiteralContinue(GroovySourceAST, int)
• visitClosureExpression(ClosureExpression)
• visitLiteralInt(GroovySourceAST, int)
• visitGt(GroovySourceAST, int)
• visitClassExpression(ClassExpression)
• visitLiteralAs(GroovySourceAST, int)
• visitBigSuffix(GroovySourceAST, int)
• visitClass(ClassNode)
• visitArrayDeclarator(GroovySourceAST, int)
• visitLiteralVolatile(GroovySourceAST, int)
• visitDefault(GroovySourceAST, int)
• visitFieldTypeAnnotation(int, TypePath, String, boolean)
• visitLand(GroovySourceAST, int)
• visitBinaryExpression(BinaryExpression)
• visitDec(GroovySourceAST, int)
• visitFieldEnd()
• visitEnumConstantDef(GroovySourceAST, int)
• visitLetter(GroovySourceAST, int)
• visitAssertStatement(AssertStatement)
• visitIdent(GroovySourceAST, int)
• visitGStringExpression(GStringExpression)
• visitLetter(GroovySourceAST, int)
• visitIfElse(IfStatement)
• visitAnnotations(AnnotatedNode)
• visitLcurly(GroovySourceAST, int)
• visitArrayExpression(ArrayExpression)
• visitDynamicMember(GroovySourceAST, int)
• visitInterfaceDef(GroovySourceAST, int)
• visitCatchStatement(CatchStatement)
• visitArgumentlistExpression(ArgumentListExpression)
• visitForInIterable(GroovySourceAST, int)
• visitBlock(GroovySourceAST, int)
• visitLiteralDouble(GroovySourceAST, int)
• visitArrayDeclarator(GroovySourceAST, int)
• visitDefault(GroovySourceAST, int)
• visitLiteralIn(GroovySourceAST, int)
• visitBitwiseNegationExpression(BitwiseNegationExpression)
• visitCompareTo(GroovySourceAST, int)
• visitMapExpression(MapExpression)
• visitClosureListExpression(ClosureListExpression)
• visitConstantExpression(ConstantExpression)
• visitGe(GroovySourceAST, int)
• visitAnnotations(GroovySourceAST, int)
• visitDefault(GroovySourceAST, int)
• visitEmptyStat(GroovySourceAST, int)
• visitLiteralReturn(GroovySourceAST, int)
• visitExpressionStatement(ExpressionStatement)
• visitClassCodeContainer(Statement)
• visitColon(GroovySourceAST, int)
• visitAssign(GroovySourceAST, int)
• visitConstantExpression(ConstantExpression)
• visitEnumConstantDef(GroovySourceAST, int)
• visitBooleanExpression(BooleanExpression)
• visitAnnotation(GroovySourceAST, int)
• visitLiteralTry(GroovySourceAST, int)
• visitMethod(MethodNode)
• visitImport(GroovySourceAST, int)
• visitLiteralElse(GroovySourceAST, int)
• visitForIterator(GroovySourceAST, int)
• visitInsnAnnotation(int, TypePath, String, boolean)
• visitClosureExpression(ClosureExpression)
• visitBxorAssign(GroovySourceAST, int)
• visitLiteralEnum(GroovySourceAST, int)
• visitGt(GroovySourceAST, int)
• visitLiteralThreadsafe(GroovySourceAST, int)
• visitCode()
• visitMapEntryExpression(MapEntryExpression)
• visitConstantExpression(ConstantExpression)
• visitEsc(GroovySourceAST, int)
• visitField(FieldNode)
• visitListExpression(ListExpression)
• visitLiteralTry(GroovySourceAST, int)
• visitLiteralAs(GroovySourceAST, int)
• visitContinueStatement(ContinueStatement)
• visitFinal(GroovySourceAST, int)
• visitFieldExpression(FieldExpression)
• visitAnnotations(AnnotatedNode)
• visitBandAssign(GroovySourceAST, int)
• visitAssign(GroovySourceAST, int)
• visitAssertStatement(AssertStatement)
• visitGe(GroovySourceAST, int)
• visitCaseStatement(CaseStatement)
• visitClosureExpression(ClosureExpression)
• visitClosureExpression(ClosureExpression)
• visitLiteralBoolean(GroovySourceAST, int)
• visitClosureExpression(ClosureExpression)
• visitForLoop(ForStatement)
• visitContinueStatement(ContinueStatement)
• visitLiteralIn(GroovySourceAST, int)
• visitBxor(GroovySourceAST, int)
• visitMemberPointer(GroovySourceAST, int)
• visitListExpression(ListExpression)
• visitField(FieldNode)
• visitLiteralInstanceof(GroovySourceAST, int)
• visitClosedBlock(GroovySourceAST, int)
• visit(ASTNode, SourceUnit)
• visitLiteralFloat(GroovySourceAST, int)
• visitLiteralImplements(GroovySourceAST, int)
• visitLiteralIf(GroovySourceAST, int)
• visitBinaryExpression(BinaryExpression)
• visitClassExpression(ClassExpression)
• visitLiteralFloat(GroovySourceAST, int)
• visitClosureOp(GroovySourceAST, int)
• visit(GroovyCodeVisitor)
• visitImport(GroovySourceAST, int)
• visitDefault(GroovySourceAST, int)
• visitClass(ClassNode)
• visit(GroovyCodeVisitor)
• visitBooleanExpression(BooleanExpression)
• visitArrayDeclarator(GroovySourceAST, int)
• visitClosureListExpression(ClosureListExpression)
• visitForCondition(GroovySourceAST, int)
• visitLabeledArg(GroovySourceAST, int)
• visitField(FieldNode)
• visitLiteralThrow(GroovySourceAST, int)
• visitGStringExpression(GStringExpression)
• visitAt(GroovySourceAST, int)
• visitLe(GroovySourceAST, int)
• visitForLoop(ForStatement)
• visitEqual(GroovySourceAST, int)
• visitClosureListExpression(ClosureListExpression)
• visitConstantExpression(ConstantExpression)
• visitForInit(GroovySourceAST, int)
• visitInterfaceDef(GroovySourceAST, int)
• visitMethod(MethodNode)
• visitBooleanExpression(BooleanExpression)
• visitFieldExpression(FieldExpression)
• visitColon(GroovySourceAST, int)
• visitIfElse(IfStatement)
• visitClosureExpression(ClosureExpression)
• visitExpr(GroovySourceAST, int)
• visitBooleanExpression(BooleanExpression)
• visitLcurly(GroovySourceAST, int)
• visit(ASTNode, SourceUnit)
• visitImports(ModuleNode)
• visitLabeledStat(GroovySourceAST, int)
• visit(ASTNode, SourceUnit)
• visitFinal(GroovySourceAST, int)
• visitExtendsClause(GroovySourceAST, int)
• visitAnnotationArrayInit(GroovySourceAST, int)
• visitListExpression(ListExpression)
• visitLetter(GroovySourceAST, int)
• visitBxor(GroovySourceAST, int)
• visitDivAssign(GroovySourceAST, int)
• visitDeclarationExpression(DeclarationExpression)
• visitLiteralThreadsafe(GroovySourceAST, int)
• visitCaseStatement(CaseStatement)
• visitField(FieldNode)
• visitLiteralContinue(GroovySourceAST, int)
• visitMapExpression(MapExpression)
• visitEnumConstantDef(GroovySourceAST, int)
• visitDeclarationExpression(DeclarationExpression)
• visitContinueStatement(ContinueStatement)
• visitBinaryExpression(BinaryExpression)
• visitForCondition(GroovySourceAST, int)
• visitComma(GroovySourceAST, int)
• visitCatchStatement(CatchStatement)
• visitLiteralByte(GroovySourceAST, int)
• visitLiteralAs(GroovySourceAST, int)
• visitLiteralDef(GroovySourceAST, int)
• visitLiteralAssert(GroovySourceAST, int)
• visitCtorIdent(GroovySourceAST, int)
• visitBytecodeExpression(BytecodeExpression)
• visitMemberPointer(GroovySourceAST, int)
• visit(GroovyCodeVisitor)
• visit(int, int, String, String, String, String)
• visitLe(GroovySourceAST, int)
• visitLiteralTry(GroovySourceAST, int)
• visitCastExpression(CastExpression)
• visitForLoop(ForStatement)
• visitLiteralSuper(GroovySourceAST, int)
• visitClosureList(GroovySourceAST, int)
• visitCaseStatement(CaseStatement)
• visitClassDef(GroovySourceAST, int)
• visitLiteralInt(GroovySourceAST, int)
• visitLiteralFalse(GroovySourceAST, int)
• visitLiteralFor(GroovySourceAST, int)
• visitMapExpression(MapExpression)
• visitInterfaceDef(GroovySourceAST, int)
• visitForIterator(GroovySourceAST, int)
• visitLiteralThreadsafe(GroovySourceAST, int)
• visitFloatSuffix(GroovySourceAST, int)
• visitBinaryExpression(BinaryExpression)
• visitLiteralThis(GroovySourceAST, int)
• visitAssertStatement(AssertStatement)
• visitForEachClause(GroovySourceAST, int)
• visitListOfExpressions(List<? extends Expression>)
• visitBandAssign(GroovySourceAST, int)
• visitGStringExpression(GStringExpression)
• visitLabeledStat(GroovySourceAST, int)
• visitForEachClause(GroovySourceAST, int)
• visitJumpInsn(int, Label)
• visitClass(ClassNode)
• visitLiteralWhile(GroovySourceAST, int)
• visitLiteralShort(GroovySourceAST, int)
• visitExport(String, int, String)
• visitForInIterable(GroovySourceAST, int)
• visitCaseGroup(GroovySourceAST, int)
• visitMethod(MethodNode)
• visitLparen(GroovySourceAST, int)
• visitLiteralCase(GroovySourceAST, int)
• visitClass(ClassNode)
• visitDoWhileLoop(DoWhileStatement)
• visitAbstract(GroovySourceAST, int)
• visitGStringExpression(GStringExpression)
• visitLiteralLong(GroovySourceAST, int)
• visitArgumentlistExpression(ArgumentListExpression)
• visitClass(ClassNode)
• visitAttributeExpression(AttributeExpression)
• visitLocalVariable(String, String, String, Label, Label, int)
• visitDoWhileLoop(DoWhileStatement)
• visitClassAnnotation(String, boolean)
• visitLiteralIn(GroovySourceAST, int)
• visitLiteralThrows(GroovySourceAST, int)
• visitDeclarationExpression(DeclarationExpression)
• visitForEachClause(GroovySourceAST, int)
• visitAssign(GroovySourceAST, int)
• visitCaseStatement(CaseStatement)
• visitLabeledStat(GroovySourceAST, int)
• visitEsc(GroovySourceAST, int)
• visitLiteralTransient(GroovySourceAST, int)
• visitBnot(GroovySourceAST, int)
• visitEqual(GroovySourceAST, int)
• visitLiteralBreak(GroovySourceAST, int)
• visit(ASTNode, SourceUnit)
• visitLiteralWhile(GroovySourceAST, int)
• visitClosureOp(GroovySourceAST, int)
• visitIndexOp(GroovySourceAST, int)
• visitMapEntryExpression(MapEntryExpression)
• visitClass(ClassNode)
• visitAbstract(GroovySourceAST, int)
• visitLt(GroovySourceAST, int)
• visitLiteralSynchronized(GroovySourceAST, int)
• visitImport(GroovySourceAST, int)
• visitLiteralImport(GroovySourceAST, int)
• visitIfElse(IfStatement)
• visitBinaryExpression(BinaryExpression)
• visitForLoop(ForStatement)
• visit(GroovyCodeVisitor)
• visitBor(GroovySourceAST, int)
• visitFieldExpression(FieldExpression)
• visitAttributeExpression(AttributeExpression)
• visitDivAssign(GroovySourceAST, int)
• visitInc(GroovySourceAST, int)
• visitAnnotationMemberValuePair(GroovySourceAST, int)
• visitInstanceInit(GroovySourceAST, int)
• visitCatchStatement(CatchStatement)
• visitCastExpression(CastExpression)
• visitLnot(GroovySourceAST, int)
• visitLiteralNull(GroovySourceAST, int)
• visitLiteralVoid(GroovySourceAST, int)
• visitDeclarationExpression(DeclarationExpression)
• visitCtorIdent(GroovySourceAST, int)
• visitAnnotationArrayInit(GroovySourceAST, int)
• visitAnnotations(AnnotatedNode)
• visitMethod(MethodNode)
• visitFinal(GroovySourceAST, int)
• visitLiteralThreadsafe(GroovySourceAST, int)
• visitEsc(GroovySourceAST, int)
• visitContents(GroovyClassVisitor)
• visit(GroovyCodeVisitor)
• visitClosureExpression(ClosureExpression)
• visitIfElse(IfStatement)
• visitBinaryExpression(BinaryExpression)
• visitLocalVariableAnnotation(int, TypePath, Label, Label, int[], String, boolean)
• visitForCondition(GroovySourceAST, int)
• visitCtorCall(GroovySourceAST, int)
• visitAnnotationDef(GroovySourceAST, int)
• visitBooleanExpression(BooleanExpression)
• visitLiteralReturn(GroovySourceAST, int)
• visitLiteralSuper(GroovySourceAST, int)
• visitLiteralExtends(GroovySourceAST, int)
• visitElist(GroovySourceAST, int)
• visitLiteralThrows(GroovySourceAST, int)
• visitClosureList(GroovySourceAST, int)
• visitCaseStatement(CaseStatement)
• visitGenericType(GenericsType)
• visitBsr(GroovySourceAST, int)
• visitEqual(GroovySourceAST, int)
• visitConstantExpression(String, ConstantExpression, ClassNode)
• visitBigSuffix(GroovySourceAST, int)
• visitBitwiseNegationExpression(BitwiseNegationExpression)
• visitLiteralIn(GroovySourceAST, int)
• visitClosureList(GroovySourceAST, int)
• visitLiteralFalse(GroovySourceAST, int)
• visitMethod(MethodNode)
• visitBytecodeExpression(BytecodeExpression)
• visitAnnotations(AnnotatedNode)
• visitExpressionStatement(ExpressionStatement)
• visitBytecodeExpression(BytecodeExpression)
• visitBitwiseNegationExpression(BitwiseNegationExpression)
• visitFieldExpression(FieldExpression)
• visitLiteralTrue(GroovySourceAST, int)
• visitClosingBlock(BlockStatement)
• visitClosureListExpression(ClosureListExpression)
• visitDeclarationExpression(DeclarationExpression)
• visitBooleanExpression(BooleanExpression)
• visitLiteralSynchronized(GroovySourceAST, int)
• visitClassDef(GroovySourceAST, int)
• visitLiteralStatic(GroovySourceAST, int)
• visitForCondition(GroovySourceAST, int)
• visitBreakStatement(BreakStatement)
• visitInstanceofNot(BinaryExpression)
• visitClass(ClassNode)
• visitLiteralInterface(GroovySourceAST, int)
• visitImports(ModuleNode)
• visitCatchStatement(CatchStatement)
• visitBand(GroovySourceAST, int)
• visitClosureListExpression(ClosureListExpression)
• visitLnot(GroovySourceAST, int)
• visitClass(ClassNode)
• visitLiteralCatch(GroovySourceAST, int)
• visitEnumDef(GroovySourceAST, int)
• visitLiteralCase(GroovySourceAST, int)
• visitMapEntryExpression(MapEntryExpression)
• visitLiteralFinally(GroovySourceAST, int)
• visitExpressionStatement(ExpressionStatement)
• visitConstantExpression(ConstantExpression, boolean)
• visitExpressionStatement(ExpressionStatement)
• visitCastExpression(CastExpression)
• visitDoWhileLoop(DoWhileStatement)
• visitClassDef(GroovySourceAST, int)
• visitMethod(MethodNode)
• visitBlock(GroovySourceAST, int)
• visitExtendsClause(GroovySourceAST, int)
• visitDeclarationExpression(DeclarationExpression)
• visitBitwiseNegationExpression(BitwiseNegationExpression)
• visitEmptyStatement(EmptyStatement)
• visitListExpression(ListExpression)
• visitImports(ModuleNode)
• visitBytecodeExpression(BytecodeExpression)
• visitLiteralClass(GroovySourceAST, int)
• visitListExpression(ListExpression)
• visitAnnotationDef(GroovySourceAST, int)
• visitClosureExpression(ClosureExpression)
• visitLiteralDef(GroovySourceAST, int)
• visitLiteralDef(GroovySourceAST, int)
• visitForInit(GroovySourceAST, int)
• visitLiteralInterface(GroovySourceAST, int)
• visitLiteralVoid(GroovySourceAST, int)
• visitArgumentlistExpression(ArgumentListExpression)
• visitField(FieldNode)
• visitLiteralProtected(GroovySourceAST, int)
• visitLiteralThis(GroovySourceAST, int)
• visitClassExpression(ClassExpression)
• visitAnnotationDefault()
• visit(GroovyCodeVisitor)
• visitEnumDef(GroovySourceAST, int)
• visitLiteralChar(GroovySourceAST, int)
• visitAbstract(GroovySourceAST, int)
• visitArrayExpression(ArrayExpression)
• visitLparen(GroovySourceAST, int)
• visitLiteralSuper(GroovySourceAST, int)
• visitConstantExpression(ConstantExpression)
• visitLiteralSynchronized(GroovySourceAST, int)
• visitBandAssign(GroovySourceAST, int)
• visitGStringExpression(GStringExpression)
• visitClassCodeContainer(Statement)
• visitLiteralFloat(GroovySourceAST, int)
• visitIfElse(IfStatement)
• visitLiteralPublic(GroovySourceAST, int)
• visitExpressionStatement(ExpressionStatement)
• visitLiteralTransient(GroovySourceAST, int)
• visit(GroovyCodeVisitor)
• visitLiteralTransient(GroovySourceAST, int)
• visitImplementsClause(GroovySourceAST, int)
• visitForInit(GroovySourceAST, int)
• visitEqual(GroovySourceAST, int)
• visitClassExpression(ClassExpression)
• visitExpressionStatement(ExpressionStatement)
• visitClass(ClassNode)
• visitBlockStatement(BlockStatement)
• visit(GroovyCodeVisitor)
• visitLiteralNative(GroovySourceAST, int)
• visitLiteralBoolean(GroovySourceAST, int)
• visitMapEntryExpression(MapEntryExpression)
• visitClosureExpression(ClosureExpression)
• visitLiteralVolatile(GroovySourceAST, int)
• visitEof(GroovySourceAST, int)
• visitForLoop(ForStatement)
• visitMethod(MethodNode)
• visitLiteralNew(GroovySourceAST, int)
• visitExtendsClause(GroovySourceAST, int)
• visitAssign(GroovySourceAST, int)
• visitLiteralTry(GroovySourceAST, int)
• visitBinaryExpression(BinaryExpression)
• visitDefault(GroovySourceAST, int)
• visitIfElse(IfStatement)
• visitField(FieldNode)
• visitMemberPointer(GroovySourceAST, int)
• visitLiteralThrow(GroovySourceAST, int)
• visitCatchStatement(CatchStatement)
• visitDec(GroovySourceAST, int)
• visitHexDigit(GroovySourceAST, int)
• visitAt(GroovySourceAST, int)
• visitForLoop(ForStatement)
• visitAbstract(GroovySourceAST, int)
• visitClass(ClassNode)
• visitClosureExpression(ClosureExpression)
• visitClass(ClassNode)
• visitField(FieldNode)
• visitImplicitParameters(GroovySourceAST, int)
• visitAnnotations(AnnotatedNode, int)
• visitLookupSwitchInsn(Label, int[], Label)
• visitGe(GroovySourceAST, int)
• visitAnnotationMemberValuePair(GroovySourceAST, int)
• visitLiteralProtected(GroovySourceAST, int)
• visitClassExpression(ClassExpression)
• visitAttributeExpression(AttributeExpression)
• visitLiteralSynchronized(GroovySourceAST, int)
• visitForLoop(ForStatement)
• visitLiteralTrue(GroovySourceAST, int)
• visitClassExpression(ClassExpression)
• visitColon(GroovySourceAST, int)
• visitLiteralNew(GroovySourceAST, int)
• visitBigSuffix(GroovySourceAST, int)
• visitDeclarationExpression(DeclarationExpression)
• visitDigit(GroovySourceAST, int)
• visitForInIterable(GroovySourceAST, int)
• visitDeclarationExpression(DeclarationExpression)
• visitLiteralElse(GroovySourceAST, int)
• visitClass(ClassNode, SourceUnit)
• visitIdent(GroovySourceAST, int)
• visitLiteralSwitch(GroovySourceAST, int)
• visitLdcInsn(Object)
• visitLiteralWhile(GroovySourceAST, int)
• visitClosureExpression(ClosureExpression)
• visitDoWhileLoop(DoWhileStatement)
• visit(GroovyCodeVisitor)
• visitAt(GroovySourceAST, int)
• visitLiteralContinue(GroovySourceAST, int)
• visitDot(GroovySourceAST, int)
• visitForLoop(ForStatement)
• visitAnnotations(GroovySourceAST, int)
• visitDefault(GroovySourceAST, int)
• visitListExpression(String, ListExpression, ClassNode)
• visitLiteralExtends(GroovySourceAST, int)
• visitClosureListExpression(ClosureListExpression)
• visitImport(GroovySourceAST, int)
• visitClosureExpression(ClosureExpression)
• visitBsrAssign(GroovySourceAST, int)
• visitForLoop(ForStatement)
• visitBinaryExpression(BinaryExpression)
• visitClassDef(GroovySourceAST, int)
• visitLiteralProtected(GroovySourceAST, int)
• visitInc(GroovySourceAST, int)
• visitLiteralNull(GroovySourceAST, int)
• visitLand(GroovySourceAST, int)
• visitFrame(int, int, Object, int, Object)
• visitLiteralThrow(GroovySourceAST, int)
• visitAnnotationFieldDef(GroovySourceAST, int)
• visitBytecodeSequence(BytecodeSequence)
• visitAttribute(Attribute)
• visitBreakStatement(BreakStatement)
• visitAnnotationDef(GroovySourceAST, int)
• visitEnum(String, String, String)
• visitDiv(GroovySourceAST, int)
• visitBytecodeSequence(BytecodeSequence)
• visitCastExpression(CastExpression)
• visitLiteralPublic(GroovySourceAST, int)
• visitAnnotationFieldDef(GroovySourceAST, int)
• visitClosedBlock(GroovySourceAST, int)
• visitLiteralFor(GroovySourceAST, int)
• visitClass(ClassNode)
• visitField(FieldNode)
• visitDiv(GroovySourceAST, int)
• visitImplementsClause(GroovySourceAST, int)
• visitCastExpression(CastExpression)
• visitField(FieldNode)
• visitMapExpression(MapExpression)
• visitLiteralByte(GroovySourceAST, int)
• visitBytecodeExpression(BytecodeExpression)
• visitMapExpression(MapExpression)
• visitAnnotations(AnnotatedNode)
• visitDot(GroovySourceAST, int)
• visitClassCodeContainer(Statement)
• visitCtorIdent(GroovySourceAST, int)
• visitGStringExpression(GStringExpression)
• visitComma(GroovySourceAST, int)
• visitLiteralTrue(GroovySourceAST, int)
• visitBand(GroovySourceAST, int)
• visit(ASTNode, SourceUnit)
• visitBinaryExpression(BinaryExpression)
• visitExtendsClause(GroovySourceAST, int)
• visitLiteralDefault(GroovySourceAST, int)
• visitClassDef(GroovySourceAST, int)
• visitLiteralNative(GroovySourceAST, int)
• visitLiteralDefault(GroovySourceAST, int)
• visit(GroovyCodeVisitor)
• visitAssign(GroovySourceAST, int)
• visitLnot(GroovySourceAST, int)
• visitLiteralCase(GroovySourceAST, int)
• visitInsn(int)
• visitAnnotationDef(GroovySourceAST, int)
• visitForIterator(GroovySourceAST, int)
• visitLbrack(GroovySourceAST, int)
• visitLand(GroovySourceAST, int)
• visitLiteralReturn(GroovySourceAST, int)
• visitLiteralLong(GroovySourceAST, int)
• visitAnnotationExpression(String, AnnotationConstantExpression, ClassNode)
• visitExpr(GroovySourceAST, int)
• visitLiteralSwitch(GroovySourceAST, int)
• visitAssertStatement(AssertStatement)
• visitDiv(GroovySourceAST, int)
• visitAssertStatement(AssertStatement)
• visitLiteralCatch(GroovySourceAST, int)
• visitImport(ImportNode)
• visitAnnotation(GroovySourceAST, int)
• visitIfElse(IfStatement)
• visitExpressionStatement(ExpressionStatement)
• visitDivAssign(GroovySourceAST, int)
• visitClass(ClassNode)
• visitContinueStatement(ContinueStatement)
• visitLiteralNew(GroovySourceAST, int)
• visitLt(GroovySourceAST, int)
• visitLiteralProtected(GroovySourceAST, int)
• visitDynamicMember(GroovySourceAST, int)
• visitLabeledStat(GroovySourceAST, int)
• visitLiteralShort(GroovySourceAST, int)
• visitLiteralIf(GroovySourceAST, int)
• visitBitwiseNegationExpression(BitwiseNegationExpression)
• visitFloatSuffix(GroovySourceAST, int)
• visitGt(GroovySourceAST, int)
• visitDec(GroovySourceAST, int)
• visitLnot(GroovySourceAST, int)
• visitAttributeExpression(AttributeExpression)
• visitLe(GroovySourceAST, int)
• visitLiteralFor(GroovySourceAST, int)
• visitClosureExpression(ClosureExpression)
• visitLiteralStatic(GroovySourceAST, int)
• visitClosedBlock(GroovySourceAST, int)
• visitHexDigit(GroovySourceAST, int)
• visitImport(GroovySourceAST, int)
• visitImplementsClause(GroovySourceAST, int)
• visitFieldExpression(FieldExpression)
• visitClosureList(GroovySourceAST, int)
• visitLiteralNew(GroovySourceAST, int)
• visitLiteralPackage(GroovySourceAST, int)
• visitBinaryExpression(BinaryExpression)
• visitGenericType(GenericsType)
• visitGt(GroovySourceAST, int)
• visitDefault(GroovySourceAST, int)
• visitLiteralPublic(GroovySourceAST, int)
• visitFieldExpression(FieldExpression)
• visitBreakStatement(BreakStatement)
• visitLiteralReturn(GroovySourceAST, int)
• visitAnnotationMemberValuePair(GroovySourceAST, int)
• visitAssertStatement(AssertStatement)
• visitCtorIdent(GroovySourceAST, int)
• visitDoWhileLoop(DoWhileStatement)
• visitClass(ClassNode)
• visitAnnotations(AnnotatedNode)
• visitBand(GroovySourceAST, int)
• visitBorAssign(GroovySourceAST, int)
• visitClosureExpression(ClosureExpression)
• visitBor(GroovySourceAST, int)
• visitGe(GroovySourceAST, int)
• visitLiteralBoolean(GroovySourceAST, int)
• visitLcurly(GroovySourceAST, int)
• visitBlockStatement(BlockStatement)
• visitMapEntryExpression(MapEntryExpression)
• visitForLoop(ForStatement)
• visitBxorAssign(GroovySourceAST, int)
• visitCastExpression(CastExpression)
• visitAnnotationNode(AnnotationNode)
• visitBlock(GroovySourceAST, int)
• visitBooleanExpression(BooleanExpression)
• visitBlockStatement(BlockStatement)
• visitCatchStatement(CatchStatement)
• visitBlockStatement(BlockStatement)
• visitField(int, String, String, String, Object)
• visitClosureExpression(ClosureExpression)
• visitLiteralVoid(GroovySourceAST, int)
• visitDynamicMember(GroovySourceAST, int)
• visitContinueStatement(ContinueStatement)
• visitCaseStatement(CaseStatement)
• visitLiteralEnum(GroovySourceAST, int)
• visitClosureOp(GroovySourceAST, int)
• visitDoWhileLoop(DoWhileStatement)
• visitLiteralCatch(GroovySourceAST, int)
• visitCaseGroup(GroovySourceAST, int)
• visitIntInsn(int, int)
• visitExponent(GroovySourceAST, int)
• visit(ASTNode, SourceUnit)
• visit(ASTNode, SourceUnit)
• visitLiteralChar(GroovySourceAST, int)
• visitFieldInsn(int, String, String, String)
• visitExpressionStatement(ExpressionStatement)
• visitDefault(GroovySourceAST, int)
• visitEof(GroovySourceAST, int)
• visitAnnotations(AnnotatedNode)
• visitDoWhileLoop(DoWhileStatement)
• visitBytecodeExpression(BytecodeExpression)
• visitDec(GroovySourceAST, int)
• visitClosureExpression(ClosureExpression)
• visitField(FieldNode)
• visitArrayExpression(ArrayExpression)
• visitIfElse(IfStatement)
• visitGStringExpression(GStringExpression)
• visitLiteralWhile(GroovySourceAST, int)
• visitClassLiteral(MethodVisitor, ClassNode)
• visitCaseStatement(CaseStatement)
• visitClass(ClassNode, SourceUnit)
• visitArrayExpression(ArrayExpression)
• visitForLoop(ForStatement)
• visitMethod(MethodNode)
• visitLbrack(GroovySourceAST, int)
• visitLiteralTransient(GroovySourceAST, int)
• visitAnnotationMemberValuePair(GroovySourceAST, int)
• visitLiteralStatic(GroovySourceAST, int)
• visitLiteralInstanceof(GroovySourceAST, int)
• visitCatchStatement(CatchStatement)
• visitLiteralPrivate(GroovySourceAST, int)
• visit(GroovyCodeVisitor)
• visitAttributeExpression(AttributeExpression)
• visitAnnotations(GroovySourceAST, int)
• visitEnumDef(GroovySourceAST, int)
• visitBoxedArgument(Expression)
• visitContinueStatement(ContinueStatement)
• visitClass(ClassNode, SourceUnit)
• visitDollar(GroovySourceAST, int)
• visitEnumConstantDef(GroovySourceAST, int)
• visitAnnotations(AnnotatedNode)
• visitAnnotationFieldDef(GroovySourceAST, int)
• visitImplementsClause(GroovySourceAST, int)
• visitInnerClass(String, String, String, int)
• visitLiteralImplements(GroovySourceAST, int)
• visitLiteralPublic(GroovySourceAST, int)
• visitBxorAssign(GroovySourceAST, int)
• visitDiv(GroovySourceAST, int)
• visitExpressionStatement(ExpressionStatement)
• visitHexDigit(GroovySourceAST, int)
• visit(GroovyCodeVisitor)
• visitLiteralFinally(GroovySourceAST, int)
• visitLiteralInt(GroovySourceAST, int)
• visitLiteralExtends(GroovySourceAST, int)
• visitCastExpression(CastExpression)
• visitMethod(int, String, String, String, String)
• visitBreakStatement(BreakStatement)
• visitBsrAssign(GroovySourceAST, int)
• visitLt(GroovySourceAST, int)
• visitMaxs(int, int)
• visitArrayExpression(ArrayExpression)
• visitBand(GroovySourceAST, int)
• visitLiteralDefault(GroovySourceAST, int)
• visitLiteralNull(GroovySourceAST, int)
• visitBorAssign(GroovySourceAST, int)
• visitLiteralPackage(GroovySourceAST, int)
• visit(ASTNode, SourceUnit)
• visitLiteralShort(GroovySourceAST, int)
• visitArgumentlistExpression(ArgumentListExpression)
• visitForLoop(ForStatement)
• visitLiteralFalse(GroovySourceAST, int)
• visitDeclarationExpression(DeclarationExpression)
• visitDoWhileLoop(DoWhileStatement)
• visitBsrAssign(GroovySourceAST, int)
• visitListExpression(ListExpression)
• visitLiteralInstanceof(GroovySourceAST, int)
• visitClass(ClassNode, SourceUnit)
• visitLiteralVoid(GroovySourceAST, int)
• visitCaseGroup(GroovySourceAST, int)
• visitLiteralPrivate(GroovySourceAST, int)
• visitLt(GroovySourceAST, int)
• visit(GroovyCodeVisitor)
• visitAnnotationFieldDef(GroovySourceAST, int)
• visitEnumConstantDef(GroovySourceAST, int)
• visitIdent(GroovySourceAST, int)
• visitLiteralChar(GroovySourceAST, int)
• visitIfElse(IfStatement)
• visitLiteralThis(GroovySourceAST, int)
• visitAnnotationArrayInit(GroovySourceAST, int)
• visitLiteralByte(GroovySourceAST, int)
• visitContinueStatement(ContinueStatement)
• visitBxor(GroovySourceAST, int)
• visitMethod(MethodNode)
• visitMethod(MethodNode)
• visitLbrack(GroovySourceAST, int)
• visitDollar(GroovySourceAST, int)
• visitCatchStatement(CatchStatement)
• visitIndexOp(GroovySourceAST, int)
• visitForInIterable(GroovySourceAST, int)
• visitClass(ClassNode)
• visitLiteralElse(GroovySourceAST, int)
• visitLiteralSwitch(GroovySourceAST, int)
• visitCatchStatement(CatchStatement)
• visitFieldAnnotation(String, boolean)
• visitCaseGroup(GroovySourceAST, int)
• visitBitwiseNegationExpression(BitwiseNegationExpression)
• visitClassAttribute(Attribute)
• visitLiteralContinue(GroovySourceAST, int)
• visitLiteralLong(GroovySourceAST, int)
• visitBooleanExpression(BooleanExpression)
• visitForLoop(ForStatement)
• visitClass(ClassNode)
• visitBlockStatement(BlockStatement)
• visitMemberPointer(GroovySourceAST, int)
• visitIdent(GroovySourceAST, int)
• visitBinaryExpression(BinaryExpression)
• visitLiteralClass(GroovySourceAST, int)
• visitBlockStatement(BlockStatement)
• visitClosureListExpression(ClosureListExpression)
• visit(MethodVisitor)
• visitLiteralFor(GroovySourceAST, int)
• visitLiteralBreak(GroovySourceAST, int)
• visitExpr(GroovySourceAST, int)
• visitCatchStatement(CatchStatement)
• visitLiteralThrows(GroovySourceAST, int)
• visitInterfaceDef(GroovySourceAST, int)
• visitAssertStatement(AssertStatement)
• visitIfElse(IfStatement)
• visitCastExpression(CastExpression)
• visitCompareTo(GroovySourceAST, int)
• visitLiteralFinally(GroovySourceAST, int)
• visitFloatSuffix(GroovySourceAST, int)
• visitEof(GroovySourceAST, int)
• visitClassExpression(ClassExpression)
• visitForLoop(ForStatement)
• visitDeclarationExpression(DeclarationExpression)
• visitImplementsClause(GroovySourceAST, int)
• visitElist(GroovySourceAST, int)
• visitLabel(Label)
• visitDoWhileLoop(DoWhileStatement)
• visitAttributeExpression(AttributeExpression)
• visitElist(GroovySourceAST, int)
• visitBlockStatement(BlockStatement)
• visitLiteralFinally(GroovySourceAST, int)
• visitAnnotationFieldDef(GroovySourceAST, int)
• visitArgumentlistExpression(ArgumentListExpression)
• visitField(FieldNode)
• visitLiteralChar(GroovySourceAST, int)
• visitAnnotation(String, boolean)
• visitExpressionStatement(ExpressionStatement)
• visitClass(ClassNode)
• visitFieldExpression(FieldExpression)
• visitLiteralCatch(GroovySourceAST, int)
• visitLiteralFloat(GroovySourceAST, int)
• visitLiteralIf(GroovySourceAST, int)
• visitDoWhileLoop(DoWhileStatement)
• visitAnnotations(AnnotatedNode)
• visit(GroovyCodeVisitor)
• visitAnnotations(AnnotatedNode)
• visitArgumentlistExpression(ArgumentListExpression, boolean)
• visitAttributeExpression(AttributeExpression)
• visitAnnotations(AnnotatedNode)
• visitBor(GroovySourceAST, int)
• visitBitwiseNegationExpression(BitwiseNegationExpression)
• visitDefault(GroovySourceAST, int)
• visitAttributeExpression(AttributeExpression)
• visitBsrAssign(GroovySourceAST, int)
• visitCatchStatement(CatchStatement)
• visitForLoop(ForStatement)
• visitLiteralClass(GroovySourceAST, int)
• visitEnumDef(GroovySourceAST, int)
• visitMapEntryExpression(MapEntryExpression)
• visit(GroovyCodeVisitor)
• visitClassTypeAnnotation(int, TypePath, String, boolean)
• visitClass(ClassNode)
• visit(ASTNode, SourceUnit)
• visitAnnotation(GroovySourceAST, int)
• visitBor(GroovySourceAST, int)
• visitLiteralPrivate(GroovySourceAST, int)
• visitInstanceInit(GroovySourceAST, int)
• visitEmptyStat(GroovySourceAST, int)
• visitLiteralFalse(GroovySourceAST, int)
• visitLiteralAssert(GroovySourceAST, int)
• visitLiteralImplements(GroovySourceAST, int)
• visitDollar(GroovySourceAST, int)
• visitLiteralInt(GroovySourceAST, int)
• visitAnnotationDef(GroovySourceAST, int)
• visitAssertStatement(AssertStatement)
• visitBlockStatement(BlockStatement)
• visitMethod(MethodNode)
• visitBxor(GroovySourceAST, int)
• visitListExpression(ListExpression)
• visitFieldExpression(FieldExpression)
• visit(GroovyCodeVisitor)
• visitAnnotations(AnnotatedNode)
• visitBorAssign(GroovySourceAST, int)
• visitEmptyStat(GroovySourceAST, int)
• visitArrayDeclarator(GroovySourceAST, int)
• visitLiteralDouble(GroovySourceAST, int)
• visitComma(GroovySourceAST, int)
• visitLiteralNative(GroovySourceAST, int)
• visitGenericType(GenericsType)
• visitLiteralEnum(GroovySourceAST, int)
• visitClosureExpression(ClosureExpression)
• visitClassExpression(ClassExpression)
• visitSpreadMapExpression(SpreadMapExpression)
• writeStdCompare(int, boolean)
• visitWildcardType(GroovySourceAST, int)
• visitTernaryExpression(TernaryExpression)
• visitTypeParameters(GroovySourceAST, int)
• visitPrefixExpression(PrefixExpression)
• visitWhileLoop(WhileStatement)
• xyz(Object, Object, Object, String)
• visitRbrack(GroovySourceAST, int)
• visitTryCatchFinally(TryCatchStatement)
• visitSource(String, String)
• writeMinusMinus(MethodVisitor)
• writeDirectMethodCall(MethodNode, boolean, Expression, TupleExpression)
• writePlusPlus(MethodVisitor)
• visitOuterClass(String, String, String)
• visitProperty(PropertyNode)
• wildcardType()
• visitRegexFind(GroovySourceAST, int)
• visitRangeExpression(RangeExpression)
• visitNumLong(GroovySourceAST, int)
• visitStaticMethodCallExpression(StaticMethodCallExpression)
• visitSr(GroovySourceAST, int)
• visitMlComment(GroovySourceAST, int)
• visitMethodAnnotation(String, boolean)
• withObjectInputStream(InputStream, ClassLoader, Closure<T>)
• visitPlus(GroovySourceAST, int)
• writeStdOperators(int, boolean)
• visitVariableDef(GroovySourceAST, int)
• visitTypeArgument(GroovySourceAST, int)
• visitVariableExpression(VariableExpression)
• visitRangeInclusive(GroovySourceAST, int)
• warn(String)
• write(PrintWriter, Janitor)
• visitTernaryExpression(TernaryExpression)
• visitParameters(GroovySourceAST, int)
• visitNumFloat(GroovySourceAST, int)
• visitNotExpression(NotExpression)
• visitTryCatchFinally(TryCatchStatement)
• visitWildcardType(GroovySourceAST, int)
• visitMethodCall(GroovySourceAST, int)
• visitStaticImport(GroovySourceAST, int)
• visitOneNl(GroovySourceAST, int)
• visitNumInt(GroovySourceAST, int)
• visitPlus(GroovySourceAST, int)
• withReader(InputStream, String, Closure<T>)
• withOutputStream(File, Closure)
• visitStarAssign(GroovySourceAST, int)
• visitParameters(GroovySourceAST, int)
• withConfig(CompilerConfiguration, Closure)
• visitStar(GroovySourceAST, int)
• visitRegexFind(GroovySourceAST, int)
• visitThrowStatement(ThrowStatement)
• visitPackage(PackageNode)
• writePlusPlus(MethodVisitor)
• visitStringCtorStart(GroovySourceAST, int)
• withReader(Path, String, Closure<T>)
• visitNumFloat(GroovySourceAST, int)
• visitUnaryMinus(GroovySourceAST, int)
• visitStarStar(GroovySourceAST, int)
• writeClosure(ClosureExpression)
• writeIteratorHasNext(MethodVisitor)
• visitNotEqual(GroovySourceAST, int)
• visitRegexFind(GroovySourceAST, int)
• visitParameter(ASTNode, Parameter)
• visitOptionalDot(GroovySourceAST, int)
• writeObject(String, Object, CharBuf)
• visitUnaryMinusExpression(UnaryMinusExpression)
• visitMultiCatchTypes(GroovySourceAST, int)
• write(String, int, int)
• visitVariableExpression(VariableExpression)
• visitSl(GroovySourceAST, int)
• visitThrowStatement(ThrowStatement)
• visitTraitDef(GroovySourceAST, int)
• visitUnaryPlusExpression(UnaryPlusExpression)
• visitSelectSlot(GroovySourceAST, int)
• write(int)
• writeStatementLabel(Statement)
• with(U, boolean, Closure<T>)
• visitVariableDef(GroovySourceAST, int)
• visitMethodCall(GroovySourceAST, int)
• visitStrictfp(GroovySourceAST, int)
• writeExpressionStatement(ExpressionStatement)
• withStatement(Closure)
• visitSemi(GroovySourceAST, int)
• visitParameterDef(GroovySourceAST, int)
• visitMethodCallExpression(MethodCallExpression)
• visitNotExpression(NotExpression)
• visitProperty(PropertyNode)
• visitPropertyExpression(PropertyExpression)
• write(Writer, Object)
• visitProperty(PropertyNode)
• with(Closure<T>)
• visitTypeUpperBounds(GroovySourceAST, int)
• writeTo(Writer)
• visitStatement(Statement)
• writeDirectMethodCall(MethodNode, boolean, Expression, TupleExpression)
• visitStaticInit(GroovySourceAST, int)
• visitReturnStatement(ReturnStatement)
• visitMod(GroovySourceAST, int)
• writePostOrPrefixMethod(int, boolean)
• visitStringCtorStart(GroovySourceAST, int)
• writeIteratorNext(MethodVisitor)
• visitMethodPointerExpression(MethodPointerExpression)
• visitSpreadDot(GroovySourceAST, int)
• visitPackageDef(GroovySourceAST, int)
• visitUnaryPlus(GroovySourceAST, int)
• writeBreak(BreakStatement)
• visitMethodPointerExpression(MethodPointerExpression)
• visitStaticInit(GroovySourceAST, int)
• withObjectOutputStream(Path, Closure<T>)
• visitStar(GroovySourceAST, int)
• visitUnaryPlusExpression(UnaryPlusExpression)
• xorImpl(Number, Number)
• visitSpreadMapExpression(SpreadMapExpression)
• withWriter(OutputStream, String, Closure<T>)
• writePackageToOutput(GroovyPackageDoc, String)
• withObjectStreams(Socket, Closure<T>)
• visitThrowStatement(ThrowStatement)
• visitMinus(GroovySourceAST, int)
• visitPostfixExpression(PostfixExpression)
• visitTypeLowerBounds(GroovySourceAST, int)
• visitObjectInitializerStatements(ClassNode)
• visitRegexMatch(GroovySourceAST, int)
• visitTypeArgument(GroovySourceAST, int)
• writeThrow(ThrowStatement)
• visitVariableDef(GroovySourceAST, int)
• writeTo(Writer)
• visitNls(GroovySourceAST, int)
• visitWs(GroovySourceAST, int)
• visitStringLiteral(GroovySourceAST, int)
• visitMethodAttribute(Attribute)
• visitWhileLoop(WhileStatement)
• visitSlAssign(GroovySourceAST, int)
• visitMod(GroovySourceAST, int)
• visitMethod(int, String, String, String, String)
• visitRparen(GroovySourceAST, int)
• visitSynchronizedStatement(SynchronizedStatement)
• writeUnaryPlus(UnaryPlusExpression)
• visitVariableExpression(VariableExpression)
• visitStaticMethodCallExpression(StaticMethodCallExpression)
• visitModAssign(GroovySourceAST, int)
• writeToOutput(String, String, String)
• visitStaticMethodCallExpression(StaticMethodCallExpression)
• visitVariableExpression(VariableExpression)
• visitMod(GroovySourceAST, int)
• write(PrintWriter, Janitor)
• visitProperty(PropertyNode)
• visitTraitDef(GroovySourceAST, int)
• visitUnaryPlusExpression(UnaryPlusExpression)
• visitMinus(GroovySourceAST, int)
• writeForInLoop(ForStatement)
• visitSemi(GroovySourceAST, int)
• visitMethodCallExpression(MethodCallExpression)
• visitRegexpSymbol(GroovySourceAST, int)
• visitSrAssign(GroovySourceAST, int)
• visitTernaryExpression(TernaryExpression)
• visitUnusedDo(GroovySourceAST, int)
• visitMethodCallExpression(MethodCallExpression)
• withIndex(Iterator<E>, int)
• visitNumBigInt(GroovySourceAST, int)
• waitForOrKill(Process, long)
• visitUnaryPlusExpression(UnaryPlusExpression)
• visitWs(GroovySourceAST, int)
• xor(long, long)
• visitNumInt(GroovySourceAST, int)
• visitModAssign(GroovySourceAST, int)
• writeShiftOp(int, boolean)
• writePostOrPrefixMethod(int, String, Expression, Expression)
• withPrintWriter(Writer, Closure<T>)
• writeBitwiseNegate(BitwiseNegationExpression)
• visitProperty(PropertyNode)
• visitType(GroovySourceAST, int)
• visitTypeParameters(GroovySourceAST, int)
• visitUnaryMinus(GroovySourceAST, int)
• visitPrefixExpression(PrefixExpression)
• visitPlusAssign(GroovySourceAST, int)
• writePlusPlus(MethodVisitor)
• xorImpl(Number, Number)
• writeDoWhileLoop(DoWhileStatement)
• visitWhileLoop(WhileStatement)
• withBatch(int, String, Closure)
• visitNumFloat(GroovySourceAST, int)
• visitUnaryPlusExpression(UnaryPlusExpression)
• visitUnaryMinusExpression(UnaryMinusExpression)
• visitMinusAssign(GroovySourceAST, int)
• visitPackageDef(GroovySourceAST, int)
• visitMethod(MethodNode)
• visitThrowStatement(ThrowStatement)
• writeIfElse(IfStatement)
• visitNotEqual(GroovySourceAST, int)
• visitReturnStatement(ReturnStatement)
• visitUnusedConst(GroovySourceAST, int)
• visitSlist(GroovySourceAST, int)
• visitNls(GroovySourceAST, int)
• writeBlockStatement(BlockStatement)
• writeMap(Map<?, ?>, CharBuf)
• visitTernaryExpression(TernaryExpression)
• write(String, int, int)
• visitVariableExpression(VariableExpression)
• visitSwitch(SwitchStatement)
• withConstraints(ASTNode, Closure)
• withWriterAppend(File, Closure<T>)
• visitPackageDef(GroovySourceAST, int)
• visitMultiCatch(GroovySourceAST, int)
• visitReturnStatement(ReturnStatement)
• writeUnaryMinus(UnaryMinusExpression)
• writeExceptionTable(BlockRecorder, Label, String)
• visitRequire(String, int, String)
• visitWhileLoop(WhileStatement)
• visitPostDec(GroovySourceAST, int)
• write(char[], int, int)
• visitVariableExpression(VariableExpression)
• visitUnusedConst(GroovySourceAST, int)
• visitTypeArguments(GroovySourceAST, int)
• visitMlComment(GroovySourceAST, int)
• visitStaticImport(GroovySourceAST, int)
• visitRangeExpression(RangeExpression)
• writeSpaceship(int, boolean)
• x(Object, String)
• writeMinusMinus(MethodVisitor)
• withWriter(File, String, Closure<T>)
• visitTypeUpperBounds(GroovySourceAST, int)
• visitReturnStatement(ReturnStatement)
• visitSynchronizedStatement(SynchronizedStatement)
• visitWhileLoop(WhileStatement)
• visitSlComment(GroovySourceAST, int)
• visitMethodTypeAnnotation(int, TypePath, String, boolean)
• visitSpreadExpression(SpreadExpression)
• visitSr(GroovySourceAST, int)
• writeTo(Writer)
• visitTryCatchFinally(TryCatchStatement)
• visitParameterDef(GroovySourceAST, int)
• write(char[], int, int)
• visitTupleExpression(TupleExpression)
• visitRangeExpression(RangeExpression)
• visitSrAssign(GroovySourceAST, int)
• visitOneNl(GroovySourceAST, int)
• visitRangeExclusive(GroovySourceAST, int)
• visitSelectSlot(GroovySourceAST, int)
• visitMethodInsn(int, String, String, String, boolean)
• visitSpreadMapArg(GroovySourceAST, int)
• writeArray(Class<?>, Object, CharBuf)
• visitModAssign(GroovySourceAST, int)
• visitMethodCallExpression(MethodCallExpression)
• visitVariableExpression(VariableExpression)
• writeStdCompare(int, boolean)
• writeInvokeStaticMethod(StaticMethodCallExpression)
• wrapLoggingMethodCall(Expression, String, Expression)
• write(PrintWriter, Janitor)
• withEagerDefault(List<T>, Closure<T>)
• visitThrowStatement(ThrowStatement)
• visitSpreadExpression(SpreadExpression)
• write(int)
• write(Object, String, Object, String)
• visitRangeInclusive(GroovySourceAST, int)
• visitRangeExclusive(GroovySourceAST, int)
• writeUnaryPlus(UnaryPlusExpression)
• visitVariableExpression(VariableExpression)
• writeExpressionStatement(ExpressionStatement)
• visitVariableExpression(VariableExpression)
• xor(Number, Number)
• visitProperty(PropertyNode)
• visitStatement(Statement)
• visitStringCtorMiddle(GroovySourceAST, int)
• withStream(OutputStream, Closure<T>)
• writeSwitch(SwitchStatement)
• yield(String)
• visitMethod(MethodNode)
• visitNotExpression(NotExpression)
• withDataInputStream(File, Closure<T>)
• withWriter(Path, String, boolean, Closure<T>)
• visitRangeExpression(RangeExpression)
• visitNullTreeLookahead(GroovySourceAST, int)
• visitUnaryMinusExpression(UnaryMinusExpression)
• visitTypeLowerBounds(GroovySourceAST, int)
• visitNumDouble(GroovySourceAST, int)
• visitRegexpCtorEnd(GroovySourceAST, int)
• visitWhileLoop(WhileStatement)
• visitUnaryPlus(GroovySourceAST, int)
• visitTypeUpperBounds(GroovySourceAST, int)
• visitMethodCallArguments(ClassNode, ArgumentListExpression, boolean, MethodNode)
• visitWhileLoop(WhileStatement)
• withDataInputStream(File, Closure<T>)
• visitSwitch(SwitchStatement)
• visitMethodCall(GroovySourceAST, int)
• withoutNulls(String)
• wrapLoggingMethodCall(Expression, String, Expression)
• xmlDeclaration()
• visitTypeParameter(GroovySourceAST, int)
• visitSpreadExpression(SpreadExpression)
• visitStringNl(GroovySourceAST, int)
• visitQuestion(GroovySourceAST, int)
• visitVocab(GroovySourceAST, int)
• visitSynchronizedStatement(SynchronizedStatement)
• withDataOutputStream(File, Closure<T>)
• writeCharSequence(CharSequence, CharBuf)
• visitShComment(GroovySourceAST, int)
• visitTryCatchFinally(TryCatchStatement)
• visitType(GroovySourceAST, int)
• visitMethodCall(GroovySourceAST, int)
• visitTypeParameters(GroovySourceAST, int)
• wrapLoggingMethodCall(Expression, String, Expression)
• writeTo(Writer)
• visitModifiers(GroovySourceAST, int)
• visitTypeArguments(GroovySourceAST, int)
• visitPrefixExpression(PrefixExpression)
• visitPrefixExpression(PrefixExpression)
• visitStringCh(GroovySourceAST, int)
• withLazyDefault(List<T>, Closure<T>)
• writeForLoopWithClosureList(ForStatement)
• visitTupleExpression(TupleExpression)
• visitThrowStatement(ThrowStatement)
• withObjectOutputStream(OutputStream, Closure<T>)
• visitNotEqual(GroovySourceAST, int)
• writeInvokeMethod(MethodCallExpression)
• visitMethodDef(GroovySourceAST, int)
• visitSl(GroovySourceAST, int)
• visitRbrack(GroovySourceAST, int)
• visitStringCh(GroovySourceAST, int)
• visitVariableParameterDef(GroovySourceAST, int)
• visitPropertyExpression(PropertyExpression)
• writePostOrPrefixMethod(int, boolean)
• visitModAssign(GroovySourceAST, int)
• withOutputStream(Path, Closure)
• visitMethodDef(GroovySourceAST, int)
• writeWhileLoop(WhileStatement)
• visitNumBigDecimal(GroovySourceAST, int)
• visitStringCtorEnd(GroovySourceAST, int)
• writeCaseStatement(CaseStatement, int, Label, Label)
• visitType(ClassNode)
• writePostOrPrefixMethod(int, boolean)
• visitReturnStatement(ReturnStatement)
• visitRangeInclusive(GroovySourceAST, int)
• visitStaticImport(GroovySourceAST, int)
• writeMapEntry(String, Object, CharBuf)
• visitType(GroovySourceAST, int)
• visitUnusedGoto(GroovySourceAST, int)
• visitObjblock(GroovySourceAST, int)
• visitNotEqual(GroovySourceAST, int)
• visitStarAssign(GroovySourceAST, int)
• visitPlusAssign(GroovySourceAST, int)
• visitVariableExpression(VariableExpression)
• writeDivision(boolean)
• visitPropertyExpression(PropertyExpression)
• visitMultiANewArrayInsn(String, int)
• writeRoot(GroovyRootDoc, String)
• wrapBlock(Statement)
• write(char[], int, int)
• visitSwitch(SwitchStatement)
• writePostOrPrefixMethod(int, String, Expression, Expression)
• zArrayGet(boolean[], int)
• visitUnaryMinusExpression(UnaryMinusExpression)
• writeBitwiseNegate(BitwiseNegationExpression)
• visitTupleExpression(TupleExpression)
• visitRangeExpression(RangeExpression)
• wrap(MethodNode)
• withTypeChecker(Closure<R>)
• withInstance(Map<String, Object>, Closure)
• visitThrowStatement(ThrowStatement)
• visitUnaryMinusExpression(UnaryMinusExpression)
• writeForInLoop(ForStatement)
• withStreams(Socket, Closure<T>)
• visitTypeArgument(GroovySourceAST, int)
• visitSwitch(SwitchStatement)
• visitProperty(PropertyNode)
• writeTo(Writer)
• write(Object, String, Object)
• visitParameterDef(GroovySourceAST, int)
• write(PrintWriter, Janitor)
• visitModifiers(GroovySourceAST, int)
• visitSrAssign(GroovySourceAST, int)
• visitStaticMethodCallExpression(StaticMethodCallExpression)
• visitSuperCtorCall(GroovySourceAST, int)
• visitProperty(PropertyNode)
• visitNumLong(GroovySourceAST, int)
• withWriterAppend(File, Closure<T>)
• writeBlockStatement(BlockStatement)
• visitMethodCallExpression(MethodCallExpression)
• visitStringCtorEnd(GroovySourceAST, int)
• visitPackageDef(GroovySourceAST, int)
• visitRegexMatch(GroovySourceAST, int)
• visitWhileLoop(WhileStatement)
• withObjectInputStream(InputStream, ClassLoader, Closure<T>)
• visitUnusedDo(GroovySourceAST, int)
• write(PrintWriter)
• visitMinusAssign(GroovySourceAST, int)
• visitSwitch(SwitchStatement)
• visitShortTernaryExpression(ElvisOperatorExpression)
• visitPackageDef(GroovySourceAST, int)
• visitMethod(MethodNode)
• visitMultiCatchTypes(GroovySourceAST, int)
• visitNumBigInt(GroovySourceAST, int)
• visitUnusedDo(GroovySourceAST, int)
• withOutputStream(File, Closure)
• _idx(char[], int, byte[], int, int)
• withWriter(OutputStream, String, Closure<T>)
• writePlusPlus(MethodVisitor)
• writeForLoopWithClosureList(ForStatement)
• visitShComment(GroovySourceAST, int)
• visitTypecast(GroovySourceAST, int)
• write(String, int, int)
• withLazyDefault$$bridge(List<T>, Closure<T>)
• visitStringLiteral(GroovySourceAST, int)
• visitRcurly(GroovySourceAST, int)
• writeGetProperty(Expression, String, boolean, boolean, boolean)
• writeMinusMinus(MethodVisitor)
• visitTryCatchFinally(TryCatchStatement)
• visitStarStarAssign(GroovySourceAST, int)
• visitTryCatchFinally(TryCatchStatement)
• withTransaction(Closure)
• visitPostfixExpression(PostfixExpression)
• visitSpreadExpression(SpreadExpression)
• visitPrefixExpression(PrefixExpression)
• visitReturnStatement(ReturnStatement)
• visitSpreadArg(GroovySourceAST, int)
• withCloseable(Closeable, Closure<T>)
• visitTryCatchFinally(TryCatchStatement)
• visitTupleExpression(TupleExpression)
• visitRegexpCtorEnd(GroovySourceAST, int)
• writeRootDocToOutput(GroovyRootDoc, String)
• writeBitwiseOp(int, boolean)
• work()
• withTransaction(Closure)
• writeTo(Writer)
• visitPropertyExpression(PropertyExpression)
• visitSpreadDot(GroovySourceAST, int)
• visitStrictfp(GroovySourceAST, int)
• visitMethodCallExpression(MethodCallExpression)
• visitPostfixExpression(PostfixExpression)
• wrapTypeIfNecessary(ClassNode)
• visitTernaryExpression(TernaryExpression)
• visitObjblock(GroovySourceAST, int)
• visitPackage(PackageNode)
• visitMlComment(GroovySourceAST, int)
• writeNotExpression(NotExpression)
• visitStringCh(GroovySourceAST, int)
• writeTo(Writer)
• writeIterator(Iterator<?>, CharBuf)
• xy(Object, Object, String)
• visitSlComment(GroovySourceAST, int)
• visitSpreadMapExpression(SpreadMapExpression)
• visitMultiCatch(GroovySourceAST, int)
• visitRcurly(GroovySourceAST, int)
• withEagerDefault$$bridge(List<T>, Closure<T>)
• visitThrowStatement(ThrowStatement)
• visitStrictfp(GroovySourceAST, int)
• visitSynchronizedStatement(SynchronizedStatement)
• visitPrefixExpression(PrefixExpression)
• visitStaticMethodCallExpression(StaticMethodCallExpression)
• visitUnaryPlus(GroovySourceAST, int)
• visitVarInsn(int, int)
• writeAssertStatement(AssertStatement)
• visitTypeParameter(GroovySourceAST, int)
• visitThrowStatement(ThrowStatement)
• writeNumber(Class<?>, Number, CharBuf)
• visitStaticMethodCallExpression(StaticMethodCallExpression)
• writePostOrPrefixMethod(int, String, Expression, Expression)
• visitSelectSlot(GroovySourceAST, int)
• visitProperty(PropertyNode)
• visitStringLiteral(GroovySourceAST, int)
• visitQuestion(GroovySourceAST, int)
• visitVariableExpression(VariableExpression)
• visitOneNl(GroovySourceAST, int)
• yieldUnescaped(String)
• weightedSize()
• visitNumBigDecimal(GroovySourceAST, int)
• visitPostfixExpression(PostfixExpression)
• visitMethodCallExpression(MethodCallExpression)
• visitMethodCallExpression(MethodCallExpression)
• visitStarStar(GroovySourceAST, int)
• visitNls(GroovySourceAST, int)
• visitProperty(PropertyNode)
• visitWhileLoop(WhileStatement)
• write(PrintWriter)
• visitSuperCtorCall(GroovySourceAST, int)
• visitSynchronizedStatement(SynchronizedStatement)
• writeForStatement(ForStatement)
• _len(int)
• writeClassToOutput(GroovyClassDoc, String)
• withBuilder(Map, FactoryBuilderSupport, String, Closure)
• withObjectOutputStream(OutputStream, Closure<T>)
• whileStatement(AST)
• visitStarStarAssign(GroovySourceAST, int)
• visitSynchronizedStatement(SynchronizedStatement)
• visitTernaryExpression(TernaryExpression)
• visitSpreadMapArg(GroovySourceAST, int)
• wrap(Class)
• weightOf(V)
• visitMethodPointerExpression(MethodPointerExpression)
• visitStar(GroovySourceAST, int)
• writeRaw(CharSequence, CharBuf)
• visitTypeParameters(GroovySourceAST, int)
• visitMultiCatchTypes(GroovySourceAST, int)
• visitNotExpression(NotExpression)
• withPrintWriter(File, String, Closure<T>)
• visitNotExpression(NotExpression)
• visitRegexMatch(GroovySourceAST, int)
• visitSlist(GroovySourceAST, int)
• visitNode(GroovySourceAST, int)
• withPrintWriter(Path, String, Closure<T>)
• visitPropertyExpression(PropertyExpression)
• visitSelectSlot(GroovySourceAST, int)
• visitTripleDot(GroovySourceAST, int)
• write(Object, String, Object)
• visitMethod(MethodNode)
• visitStarStarAssign(GroovySourceAST, int)
• writeTryCatchFinally(TryCatchStatement)
• visitTypeLowerBounds(GroovySourceAST, int)
• write(char[], int, int)
• visitPrefixExpression(PrefixExpression)
• visitSynchronizedStatement(SynchronizedStatement)
• visitRegexpCtorEnd(GroovySourceAST, int)
• visitNumBigDecimal(GroovySourceAST, int)
• visitStringCtorEnd(GroovySourceAST, int)
• visitMultiCatchTypes(GroovySourceAST, int)
• visitSpreadArg(GroovySourceAST, int)
• write(Path, String, String, boolean)
• visitPropertyExpression(PropertyExpression)
• visualizeScriptResults(EventObject)
• visitWhileLoop(WhileStatement)
• visitModifiers(GroovySourceAST, int)
• writeToOutput(String, String, String)
• writeLine(BufferedWriter, String)
• writeInfo(Class, String, Object)
• visitProperty(PropertyNode)
• visitStaticMethodCallExpression(StaticMethodCallExpression)
• writeTo(Writer)
• writeNotExpression(NotExpression)
• visitParameters(GroovySourceAST, int)
• visitPackage(PackageNode)
• visitShortTernaryExpression(ElvisOperatorExpression)
• visitReturnStatement(ReturnStatement)
• visitVariableExpression(VariableExpression)
• writeForInLoop(ForStatement)
• visitPostDec(GroovySourceAST, int)
• withDataInputStream(Path, Closure<T>)
• writeLine(BufferedWriter, String)
• writePlusPlus(MethodVisitor)
• visitProperty(PropertyNode)
• visitUnaryMinus(GroovySourceAST, int)
• visitNullTreeLookahead(GroovySourceAST, int)
• visitMethodPointerExpression(MethodPointerExpression)
• visitStatement(Statement)
• visitMethodCall(GroovySourceAST, int)
• withObjectStreams(Socket, Closure<T>)
• visitWildcardType(GroovySourceAST, int)
• writeStdOperators(int, boolean)
• visitStringCtorMiddle(GroovySourceAST, int)
• writePackages(GroovyRootDoc, String)
• writeIfElse(IfStatement)
• visitProperty(PropertyNode)
• visitSlAssign(GroovySourceAST, int)
• withStreams(Socket, Closure<T>)
• visitProvide(String, String)
• visitMethodCallExpression(MethodCallExpression)
• visitObjectInitializerStatements(ClassNode)
• write(Writer, Writable)
• visitSwitch(SwitchStatement)
• visitNullTreeLookahead(GroovySourceAST, int)
• visitShortTernaryExpression(ElvisOperatorExpression)
• visitTypeInsn(int, String)
• xorImpl(Number, Number)
• writeDivision(boolean)
• visitMethodCallExpression(MethodCallExpression)
• visitStaticMethodCallExpression(StaticMethodCallExpression)
• visitWhileLoop(WhileStatement)
• visitPostDec(GroovySourceAST, int)
• withLocale(String)
• visitParameters(ASTNode, Parameter)
• visitRangeExclusive(GroovySourceAST, int)
• visitUnaryPlusExpression(UnaryPlusExpression)
• visitMethod(MethodNode)
• writeDivision(boolean)
• visitPropertyExpression(PropertyExpression)
• visitStaticMethodCallExpression(StaticMethodCallExpression)
• visitSpreadMapExpression(SpreadMapExpression)
• withFormatter(Appendable, Locale, Closure)
• visitUnaryPlusExpression(UnaryPlusExpression)
• visitVariableParameterDef(GroovySourceAST, int)
• visitMultiCatch(GroovySourceAST, int)
• visitNotExpression(NotExpression)
• visitRegexpSymbol(GroovySourceAST, int)
• weigher(EntryWeigher<? super K, ? super V>)
• writeToOutput(String, String, String)
• visitRangeExpression(RangeExpression)
• withBatch(int, Closure)
• visitShortTernaryExpression(ElvisOperatorExpression)
• withWriterAppend(Path, Closure<T>)
• writeClasses(GroovyRootDoc, String)
• visitSemi(GroovySourceAST, int)
• visitReturnStatement(ReturnStatement)
• visitPostInc(GroovySourceAST, int)
• visitSuperCtorCall(GroovySourceAST, int)
• visitWhileLoop(WhileStatement)
• visitOptionalDot(GroovySourceAST, int)
• visitNotExpression(NotExpression)
• visitMethodCallExpression(MethodCallExpression)
• withReader(URL, String, Closure<T>)
• waitForOrKill(long)
• visitTypecast(GroovySourceAST, int)
• withObjectOutputStream(File, Closure<T>)
• visitPostInc(GroovySourceAST, int)
• visitTripleDot(GroovySourceAST, int)
• visitParameter(String, int)
• visitVocab(GroovySourceAST, int)
• visitTypeAnnotation(int, TypePath, String, boolean)
• visitStringNl(GroovySourceAST, int)
• visitNumDouble(GroovySourceAST, int)
• visitUnaryMinusExpression(UnaryMinusExpression)
• visitNumInt(GroovySourceAST, int)
• withDataOutputStream(File, Closure<T>)
• writeMinusMinus(MethodVisitor)
• visitUse(String)
• writeIteratorHasNext(MethodVisitor)
• visitPropertyExpression(PropertyExpression)
• xorImpl(Number, Number)
• writeBlockStatement(BlockStatement)
• writeTo(Writer)
• write(PrintWriter, String)
• visitStar(GroovySourceAST, int)
• visitUnusedGoto(GroovySourceAST, int)
• withLevel(Level, String, Closure)
• withDefault$$bridge(List<T>, Closure<T>)
• writeShiftOp(int, boolean)
• visitTernaryExpression(TernaryExpression)
• write(int, boolean)
• withWriter(Process, Closure)
• writeContinue(ContinueStatement)
• write(File, String, String, boolean)
• visitTypeParameter(GroovySourceAST, int)
• visitStringLiteral(GroovySourceAST, int)
• visitVariableExpression(VariableExpression)
• visitSpreadArg(GroovySourceAST, int)
• visitSpreadMapExpression(SpreadMapExpression)
• visitProperty(PropertyNode)
• writeDoWhileLoop(DoWhileStatement)
• visitSrAssign(GroovySourceAST, int)
• visitMinusAssign(GroovySourceAST, int)
• write(char[], int, int)
• visitVariableExpression(VariableExpression, boolean)
• visitWhileLoop(WhileStatement)
• writeUnaryMinus(UnaryMinusExpression)
• writeCollectionWithClosure(Writer, Collection, Closure)
• visitShortTernaryExpression(ElvisOperatorExpression)
• visitStatement(Statement)
• visitSpreadMapArg(GroovySourceAST, int)
• withBinding(Map, String)
• visitSpreadExpression(SpreadExpression)
• visitRegexpLiteral(GroovySourceAST, int)
• waitForProcessOutput(Process, OutputStream, OutputStream)
• yield(Object)
• wildcardType()
• visitOptionalDot(GroovySourceAST, int)
• writePlusPlus(MethodVisitor)
• visitSr(GroovySourceAST, int)
• visitProperty(PropertyNode)
• visitMethodDef(GroovySourceAST, int)
• visitStarAssign(GroovySourceAST, int)
• visitSpreadDot(GroovySourceAST, int)
• writeIteratorNext(MethodVisitor)
• withInputStream(URL, Closure<T>)
• writeWhileLoop(WhileStatement)
• visitTryCatchAnnotation(int, TypePath, String, boolean)
• visitSlAssign(GroovySourceAST, int)
• visitPostfixExpression(PostfixExpression)
• visitSynchronizedStatement(SynchronizedStatement)
• writeAssert(AssertStatement)
• visitNumBigInt(GroovySourceAST, int)
• visitUnaryMinus(GroovySourceAST, int)
• writePostOrPrefixMethod(int, String, Expression, Expression)
• visitQuestion(GroovySourceAST, int)
• visitMinusAssign(GroovySourceAST, int)
• visitPlusAssign(GroovySourceAST, int)
• visitUnusedConst(GroovySourceAST, int)
• visitSpreadMapArg(GroovySourceAST, int)
• visitTypeLowerBounds(GroovySourceAST, int)
• write(int, boolean)
• visitParameterAnnotation(int, String, boolean)
• visitPropertyExpression(PropertyExpression)
• visitTupleExpression(TupleExpression)
• visitModuleEnd()
• writePlusPlus(MethodVisitor)
• visitUnaryPlusExpression(UnaryPlusExpression)
• visitNumInt(GroovySourceAST, int)
• visitPostInc(GroovySourceAST, int)
• visitSpreadExpression(SpreadExpression)
• work()
• visitPostfixExpression(PostfixExpression)
• withInputStream(Path, Closure)
• visitVariableExpression(VariableExpression)
• write(PrintWriter, Janitor)
• visitVariableExpression(VariableExpression)
• writeSpaceship(int, boolean)
• writeIndent()
• visitRegexpLiteral(GroovySourceAST, int)
• visitOptionalDot(GroovySourceAST, int)
• visitRangeExclusive(GroovySourceAST, int)
• visitPackage(PackageNode)
• visitSpreadMapExpression(SpreadMapExpression)
• wrapLoggingMethodCall(Expression, String, Expression)
• visitTraitDef(GroovySourceAST, int)
• visitSl(GroovySourceAST, int)
• visitRegexFind(GroovySourceAST, int)
• visitTypeArguments(GroovySourceAST, int)
• withPrintWriter(OutputStream, Closure<T>)
• visitTraitDef(GroovySourceAST, int)
• visitSpreadExpression(SpreadExpression)
• visitStaticMethodCallExpression(StaticMethodCallExpression)
• visitSwitch(SwitchStatement)
• visitSpreadExpression(SpreadExpression)
• visitTripleDot(GroovySourceAST, int)
• visitSynchronizedStatement(SynchronizedStatement)
• visitUnusedGoto(GroovySourceAST, int)
• visitTypeArguments(GroovySourceAST, int)
• visitSlAssign(GroovySourceAST, int)
• writeValue(Object)
• visitReturnStatement(ReturnStatement)
• writeMinusMinus(MethodVisitor)
• withTraits(Object, Class<?>)
• visitMethodCallExpression(MethodCallExpression)
• visitVariableExpression(VariableExpression)
• visitStaticImport(GroovySourceAST, int)
• yieldUnescaped(Object)
• visitSwitch(SwitchStatement)
• visitRparen(GroovySourceAST, int)
• visitRegexpSymbol(GroovySourceAST, int)
• withStream(U, Closure<T>)
• visitRangeExpression(RangeExpression)
• visitTryCatchFinally(TryCatchStatement)
• visitSpreadMapExpression(SpreadMapExpression)
• withInputStream(URL, Closure<T>)
• visitNumLong(GroovySourceAST, int)
• visitSpreadArg(GroovySourceAST, int)
• visitNumBigInt(GroovySourceAST, int)
• xmlDeclaration(Map<String, Object>)
• visitMethodDef(GroovySourceAST, int)
• wrap(Object)
• visitUnaryMinusExpression(UnaryMinusExpression)
• visitMethodCallExpression(MethodCallExpression)
• visitUnaryMinusExpression(UnaryMinusExpression)
• visitPropertyExpression(PropertyExpression)
• visitWs(GroovySourceAST, int)
• visitStaticInit(GroovySourceAST, int)
• visitMethodPointerExpression(MethodPointerExpression)
• wrapLoggingMethodCall(Expression, String, Expression)
• writeReturn(ReturnStatement)
• writeName(String)
• writeTo(Writer)
• visitVariableParameterDef(GroovySourceAST, int)
• visitPlusAssign(GroovySourceAST, int)
• writeInvokeMethod(MethodCallExpression)
• visitModule(String, int, String)
• visitObjectInitializerStatements(ClassNode)
• visitSwitch(SwitchStatement)
• visitPlus(GroovySourceAST, int)
• visitPostfixExpression(PostfixExpression)
• visitWhileLoop(WhileStatement)
• visitSlist(GroovySourceAST, int)
• visitStarStar(GroovySourceAST, int)
• visitStarStarAssign(GroovySourceAST, int)
• visitParameters(GroovySourceAST, int)
• visitRparen(GroovySourceAST, int)
• visitMethodCallExpression(MethodCallExpression)
• visitParameterDef(GroovySourceAST, int)
• withObjectInputStream(File, ClassLoader, Closure<T>)
• withReader(InputStream, String, Closure<T>)
• writeTo(Writer)
• visitPostInc(GroovySourceAST, int)
• visitTableSwitchInsn(int, int, Label, Label)
• visitPropertyExpression(PropertyExpression)
• xor(Boolean, Boolean)
• visitSlComment(GroovySourceAST, int)
• visitVariableDef(GroovySourceAST, int)
• visitShComment(GroovySourceAST, int)
• visitType(GroovySourceAST, int)
• visitPostfixExpression(PostfixExpression)
• visitPropertyExpression(PropertyExpression)
• write(File, String, String)
• visitStringNl(GroovySourceAST, int)
• wrapLoggingMethodCall(Expression, String, Expression)
• withCloseable(U, Closure<T>)
• visitObjblock(GroovySourceAST, int)
• writeSynchronized(SynchronizedStatement)
• visitTryCatchBlock(Label, Label, Label, String)
• visitPostfixExpression(PostfixExpression)
• visitVocab(GroovySourceAST, int)
• xor(long, long)
• withOutputStream(Process, Closure)
• visitMethodDef(GroovySourceAST, int)
• visitWildcardType(GroovySourceAST, int)
• visitNumDouble(GroovySourceAST, int)
• xpath(Node, String)
• visitTypecast(GroovySourceAST, int)
• visitMultiCatch(GroovySourceAST, int)
• writeMinusMinus(MethodVisitor)
• withObjectInputStream(Path, ClassLoader, Closure<T>)
• visitRcurly(GroovySourceAST, int)
• visitMethodPointerExpression(MethodPointerExpression)
• withDataOutputStream(Path, Closure<T>)
• visitTypeArgument(GroovySourceAST, int)
• visitTypeUpperBounds(GroovySourceAST, int)
• visitProperty(PropertyNode)
• visitReturnStatement(ReturnStatement)
• visitSlist(GroovySourceAST, int)
• visitMod(GroovySourceAST, int)
• visitVariableParameterDef(GroovySourceAST, int)
• visitPostDec(GroovySourceAST, int)
• visitTupleExpression(TupleExpression)
• visitStarStar(GroovySourceAST, int)
• visitRangeExpression(RangeExpression)
• visitSwitch(SwitchStatement)
• visitStarAssign(GroovySourceAST, int)
• visitStrictfp(GroovySourceAST, int)
• visitSr(GroovySourceAST, int)
• visitMethodEnd()
• weightOf(K, V)
• visitStaticInit(GroovySourceAST, int)
• visitNumBigDecimal(GroovySourceAST, int)
• visitSwitch(SwitchStatement)
• writeBitwiseOp(int, boolean)
• visitRegexMatch(GroovySourceAST, int)
• writeTo(Writer)
• writeDate(Date, CharBuf)
• write(Object, String, Object)
• visitPrefixExpression(PrefixExpression)
• write(PrintWriter, Janitor)
• visitRangeInclusive(GroovySourceAST, int)
• visitTernaryExpression(TernaryExpression)
• visitMethod(MethodNode)
• visitReturnStatement(ReturnStatement)
• visitNumDouble(GroovySourceAST, int)
• warn(Object, Throwable)
• withDefault(List<T>, Closure<T>)
• whileStatement(Closure)
• writeArray(List<Object>)
• writeTo(Writer)
• visitObjblock(GroovySourceAST, int)
• visitNumLong(GroovySourceAST, int)
• visitSl(GroovySourceAST, int)
• visitUnaryPlus(GroovySourceAST, int)
• visitVariableDef(GroovySourceAST, int)
• visitRbrack(GroovySourceAST, int)
• visitStringCtorStart(GroovySourceAST, int)
• visitModifiers(GroovySourceAST, int)
• visitPlus(GroovySourceAST, int)
• writeMinusMinus(MethodVisitor)
• visitMinus(GroovySourceAST, int)
• visitQuestion(GroovySourceAST, int)
• visitTypeParameter(GroovySourceAST, int)
• visitRegexpLiteral(GroovySourceAST, int)
• visitStringCtorMiddle(GroovySourceAST, int)
• writeShiftOp(int, boolean)
• visitPropertyExpression(PropertyExpression)
• visitSuperCtorCall(GroovySourceAST, int)
• visitTryCatchFinally(TryCatchStatement)
• visitReturnStatement(ReturnStatement)
• XmlTemplateEngine(XmlParser, GroovyShell)
• writeBitwiseOp(int, boolean)
• visitMethodPointerExpression(MethodPointerExpression)
• visitNumFloat(GroovySourceAST, int)
• visitMinus(GroovySourceAST, int)
• visitTupleExpression(TupleExpression)
• visitPrefixExpression(PrefixExpression)
• visitTraitDef(GroovySourceAST, int)
• visitTypecast(GroovySourceAST, int)
• zArraySet(boolean[], int, boolean)
• visitSpreadDot(GroovySourceAST, int)
• writeTo(Writer)
• writeReturn(ReturnStatement)