Class ResolvedTypeWithMembers


  • public class ResolvedTypeWithMembers
    extends java.lang.Object
    Class that contains information about fully resolved members of a type; resolution meaning that masking is handled for methods, and all inheritable annotations are flattened using optional overrides as well ("mix-in annotations"). Instances are created by MemberResolver.

    Note that instances are not thread-safe, as the expectation is that instances will not be shared (unlike raw members or resolved types)

    • Field Detail

      • NO_RESOLVED_TYPES

        private static final ResolvedType[] NO_RESOLVED_TYPES
      • NO_RESOLVED_METHODS

        private static final ResolvedMethod[] NO_RESOLVED_METHODS
      • NO_RESOLVED_FIELDS

        private static final ResolvedField[] NO_RESOLVED_FIELDS
      • NO_RESOLVED_CONSTRUCTORS

        private static final ResolvedConstructor[] NO_RESOLVED_CONSTRUCTORS
      • DEFAULT_ANNOTATION_CONFIG

        protected static final AnnotationConfiguration DEFAULT_ANNOTATION_CONFIG
        Default annotation configuration is to ignore all annotations types.
      • _typeResolver

        protected final TypeResolver _typeResolver
        Need to be able to resolve member types still
      • _mainType

        protected final HierarchicType _mainType
        Leaf of the type hierarchy, i.e. type from which this hierarchy was generated.
      • _types

        protected final HierarchicType[] _types
        All types that hierarchy contains, in order of increasing precedence (that is, later entries override members of earlier members)
      • _fieldFilter

        protected Filter<RawField> _fieldFilter
        Filter to use for selecting fields to include
      • _constructorFilter

        protected Filter<RawConstructor> _constructorFilter
        Filter to use for selecting constructors to include
      • _methodFilter

        protected Filter<RawMethod> _methodFilter
        Filter to use for selecting methods to include
    • Method Detail

      • size

        public int size()
      • allTypesAndOverrides

        public java.util.List<HierarchicType> allTypesAndOverrides()
        Accessor for getting full type hierarchy as priority-ordered list, from the lowest precedence to highest precedence (main type, its mix-in overrides)
      • mainTypeAndOverrides

        public java.util.List<HierarchicType> mainTypeAndOverrides()
        Accessor for getting subset of type hierarchy which only contains main type and possible overrides (mix-ins) it has, but not supertypes or their overrides.
      • overridesOnly

        public java.util.List<HierarchicType> overridesOnly()
        Accessor for finding just overrides for the main type (if any).
      • getStaticFields

        public ResolvedField[] getStaticFields()
        Method for finding all static fields of the main type (except for ones possibly filtered out by filter) and applying annotation overrides, if any, to annotations.
        Since:
        1.2.0
      • getStaticMethods

        public ResolvedMethod[] getStaticMethods()
        Method for finding all static methods of the main type (except for ones possibly filtered out by filter) and applying annotation overrides, if any, to annotations.
      • resolveConstructors

        protected ResolvedConstructor[] resolveConstructors()
        Method that will actually resolve full information (types, annotations) for constructors of the main type.
      • resolveMemberFields

        protected ResolvedField[] resolveMemberFields()
        Method for fully resolving field definitions and associated annotations. Neither field definitions nor associated annotations inherit, but we may still need to add annotation overrides, as well as filter out filters and annotations that caller is not interested in.
      • resolveMemberMethods

        protected ResolvedMethod[] resolveMemberMethods()
      • resolveStaticFields

        protected ResolvedField[] resolveStaticFields()
        Method for fully resolving static field definitions and associated annotations. Neither field definitions nor associated annotations inherit, but we may still need to add annotation overrides, as well as filter out filters and annotations that caller is not interested in.
        Since:
        1.2.0
      • resolveStaticMethods

        protected ResolvedMethod[] resolveStaticMethods()
        Method that will actually resolve full information (types, annotations) for static methods, using configured filter.
      • resolveField

        protected ResolvedField resolveField​(RawField raw)
        Method for resolving individual field completely
      • resolveMethod

        protected ResolvedMethod resolveMethod​(RawMethod raw)
        Method for resolving individual method completely
      • methodCanInherit

        protected boolean methodCanInherit​(java.lang.annotation.Annotation annotation)
      • parameterCanInherit

        protected boolean parameterCanInherit​(java.lang.annotation.Annotation annotation)