Class AnnotatedTypeMirror.AnnotatedIntersectionType

  • All Implemented Interfaces:
    org.plumelib.util.DeepCopyable<AnnotatedTypeMirror>
    Enclosing class:
    AnnotatedTypeMirror

    public static class AnnotatedTypeMirror.AnnotatedIntersectionType
    extends AnnotatedTypeMirror
    Represents an intersection type.

    For example: MyObject & Serializable & Comparable<MyObject>

    • Method Detail

      • removeAnnotation

        public boolean removeAnnotation​(javax.lang.model.element.AnnotationMirror a)
        Description copied from class: AnnotatedTypeMirror
        Removes a primary annotation from the type.
        Overrides:
        removeAnnotation in class AnnotatedTypeMirror
        Parameters:
        a - the annotation to remove
        Returns:
        true if the annotation was removed, false if the type's annotations were unchanged
      • accept

        public <R,​P> R accept​(AnnotatedTypeVisitor<R,​P> v,
                                    P p)
        Description copied from class: AnnotatedTypeMirror
        Applies a visitor to this type.
        Specified by:
        accept in class AnnotatedTypeMirror
        Type Parameters:
        R - the return type of the visitor's methods
        P - the type of the additional parameter to the visitor's methods
        Parameters:
        v - the visitor operating on this type
        p - additional parameter to the visitor
        Returns:
        a visitor-specified result
      • getUnderlyingType

        public javax.lang.model.type.IntersectionType getUnderlyingType()
        Description copied from class: AnnotatedTypeMirror
        Returns the underlying unannotated Java type, which this wraps.
        Overrides:
        getUnderlyingType in class AnnotatedTypeMirror
        Returns:
        the underlying type
      • deepCopy

        public AnnotatedTypeMirror.AnnotatedIntersectionType deepCopy​(boolean copyAnnotations)
        Description copied from class: AnnotatedTypeMirror
        Returns a deep copy of this type. A deep copy implies that each component type is copied recursively and the returned type refers to those copies in its component locations.

        Note: deepCopy provides two important properties in the returned copy:

        1. Structure preservation -- The exact structure of the original AnnotatedTypeMirror is preserved in the copy including all component types.
        2. Annotation preservation -- All of the annotations from the original AnnotatedTypeMirror and its components have been copied to the new type.
        If copyAnnotations is set to false, the second property, Annotation preservation, is removed. This is useful for cases in which the user may want to copy the structure of a type exactly but NOT its annotations.
        Specified by:
        deepCopy in class AnnotatedTypeMirror
        Returns:
        a deep copy
      • shallowCopy

        public AnnotatedTypeMirror.AnnotatedIntersectionType shallowCopy​(boolean copyAnnotations)
        Description copied from class: AnnotatedTypeMirror
        Returns a shallow copy of this type. A shallow copy implies that each component type in the output copy refers to the same object as the object being copied.
        Specified by:
        shallowCopy in class AnnotatedTypeMirror
        Parameters:
        copyAnnotations - whether copy should have annotations, i.e. whether field annotations should be copied.
      • directSupertypes

        public java.util.List<? extends AnnotatedTypeMirror> directSupertypes()
        This method returns a list of AnnotatedTypeMirrors where the Java type of each ATM is an immediate supertype (class or interface) of the Java type of this. The interface types, if any, appear at the end of the list. If the directSuperType has type arguments, then the annotations on those type arguments are taken with proper translation from the declaration of the Java type of this.

        For example,

         class B<T> { ... } 
         class A extends B<@NonNull String> { ... } 
         @Nullable A a;
         
        The direct supertype of the ATM @Nullable A is @Nullable B<@NonNull String>.

        An example with more complex type arguments:

         class D<Q,R> { ... } 
         class A<T,S> extends D<S,T> { ... } 
         @Nullable A<@NonNull String, @NonNull Object> a;
         
        The direct supertype of the ATM @Nullable A<@NonNull String, @NonNull Object> is @Nullable B<@NonNull Object, @NonNull String>.

        An example with more than one direct supertype:

         class B<T> implements List<Integer> { ... } 
         class A extends B<@NonNull String> implements List<Integer> { ... } 
         @Nullable A a;
         
        The direct supertypes of the ATM @Nullable A are @Nullable B <@NonNull String> and @Nullable List<@NonNull Integer>.

        This returns the same types as getBounds().

        Overrides:
        directSupertypes in class AnnotatedTypeMirror
        Returns:
        the direct super types of this
        See Also:
        Types.directSupertypes(TypeMirror)
      • getBounds

        public java.util.List<AnnotatedTypeMirror> getBounds()
        This returns the bounds of the intersection type. Although only declared types can appear in an explicitly written intersections, during capture conversion, intersections with other kinds of types are created.

        This returns the same types as directSupertypes().

        Returns:
        the bounds of this, which are also the direct super types of this
      • setBounds

        public void setBounds​(java.util.List<AnnotatedTypeMirror> bounds)
        Sets the bounds.
        Parameters:
        bounds - a list of bounds to be captured by this method
      • copyIntersectionBoundAnnotations

        public void copyIntersectionBoundAnnotations()
        Copy the first annotation (in each hierarchy) on a bound to the primary annotation location of the intersection type.

        For example, in the type @NonNull Object & @Initialized @Nullable Serializable, @Nullable and @Initialized are copied to the primary annotation location.