Package spoon.reflect.declaration


package spoon.reflect.declaration

This package contains the meta-model part that models the declarations (program's structures such as classes, fields, etc).

Related Documentation

  • Interface Summary
    Interface
    Description
    This element represents an annotation on an element.
    This element defines an annotation method declared in an annotation type.
    This element defines an annotation type.
    This element defines an anonymous executable block declaration in a class.
    This element represents a class declaration.
    This interface represents snippets of source code that can be used in the AST to represent complex code without having to build the corresponding program model structure.
    Defines a compilation unit.
    This element defines a constructor declaration.
    This interface is the root interface for the metamodel elements (any program element).
    CtEnum<T extends Enum<?>>
    This element represents an enumeration declaration.
    Corresponds to one enum value specified in an enumeration.
    This element represents an executable element such as a method, a constructor, or an anonymous block.
    This element defines a field declaration.
    This abstract element defines a declaration that accepts formal type parameters (aka generics), such as a CtType (class A<E>), CtMethod or CtConstructor.
    This element represents an import declaration.
    This element defines an interface declaration.
    This element defines a method declaration.
    This interface defines an element that accepts modifiers.
    Represents a Java module as defined in Java 9.
    Represents a directive of a CtModule The directives of a module declaration specify the module's dependences on other modules CtModuleRequirement, the packages it makes available to other modules CtPackageExport, the services it consumes CtUsedService, and the services it provides CtProvidedService.
    Represents a require module in a Java module definition The requires directive specifies the name of a module on which the current module has a dependence.
    Defined an element with several types.
    Declares an element that has a name (a class, a method, a variable, etc).
    This element defines a package declaration.
    This element represents an package declaration.
    Represents an exported or opened package in a Java module The exports directive specifies the name of a package to be exported by the current module.
    This element defines an executable parameter declaration.
    Represents a provided service in a CtModule.
    This element represents a record declaration.
    This element represents a record component.
    A shadow element is an element that is in the Spoon model, but does not exist in the actual source code.
    This abstract element defines a super-type for classes and interfaces, which can declare methods.
    This abstract element defines a typed element.
    Returns information that can be obtained both at compile-time and run-time For CtElement, the compile-time information is given For CtTypeReference, the runtime information is given (using the Reflection API)
    This interface represents a member of a class (field, method, nested class or static/instance initializer).
    This element defines a declaration of a type parameter (aka generics).
    Represents the declaration of a used service in a CtModule The uses directive specifies a service for which the current module may discover providers via java.util.ServiceLoader.
    This abstract element defines a variable declaration.
  • Enum Summary
    Enum
    Description
    This enum specifies the element type which is annotated by the annotation
     
     
     
    Represents a modifier on the declaration of a program element such as a class, method, or field.
  • Exception Summary
    Exception
    Description
    This exception is thrown when the parent of an element has not been correctly initialized.