Class LessThanAnnotatedTypeFactory

    • Field Detail

      • LESS_THAN_UNKNOWN

        public final javax.lang.model.element.AnnotationMirror LESS_THAN_UNKNOWN
        The @LessThanUnknown annotation.
    • Constructor Detail

      • LessThanAnnotatedTypeFactory

        public LessThanAnnotatedTypeFactory​(BaseTypeChecker checker)
        Creates a new LessThanAnnotatedTypeFactory.
        Parameters:
        checker - the type-checker associated with this type factory
    • Method Detail

      • getValueAnnotatedTypeFactory

        public ValueAnnotatedTypeFactory getValueAnnotatedTypeFactory()
        Returns the Value Checker's annotated type factory.
        Returns:
        the Value Checker's annotated type factory
      • createSupportedTypeQualifiers

        protected java.util.Set<java.lang.Class<? extends java.lang.annotation.Annotation>> createSupportedTypeQualifiers()
        Description copied from class: AnnotatedTypeFactory
        Returns a mutable set of annotation classes that are supported by a checker.

        Subclasses may override this method to return a mutable set of their supported type qualifiers through one of the 5 approaches shown below.

        Subclasses should not call this method; they should call AnnotatedTypeFactory.getSupportedTypeQualifiers() instead.

        By default, a checker supports all annotations located in a subdirectory called qual that's located in the same directory as the checker. Note that only annotations defined with the @Target({ElementType.TYPE_USE}) meta-annotation (and optionally with the additional value of ElementType.TYPE_PARAMETER, but no other ElementType values) are automatically considered as supported annotations.

        To support a different set of annotations than those in the qual subdirectory, or that have other ElementType values, see examples below.

        In total, there are 5 ways to indicate annotations that are supported by a checker:

        1. Only support annotations located in a checker's qual directory:

          This is the default behavior. Simply place those annotations within the qual directory.

        2. Support annotations located in a checker's qual directory and a list of other annotations:

          Place those annotations within the qual directory, and override AnnotatedTypeFactory.createSupportedTypeQualifiers() by calling AnnotatedTypeFactory.getBundledTypeQualifiers(Class...) with a varargs parameter list of the other annotations. Code example:

           @Override protected Set<Class<? extends Annotation>> createSupportedTypeQualifiers() {
                return getBundledTypeQualifiers(Regex.class, PartialRegex.class, RegexBottom.class, UnknownRegex.class);
            } 
           
        3. Supporting only annotations that are explicitly listed: Override AnnotatedTypeFactory.createSupportedTypeQualifiers() and return a mutable set of the supported annotations. Code example:
           @Override protected Set<Class<? extends Annotation>> createSupportedTypeQualifiers() {
                return new HashSet<Class<? extends Annotation>>(
                        Arrays.asList(A.class, B.class));
            } 
           
          The set of qualifiers returned by AnnotatedTypeFactory.createSupportedTypeQualifiers() must be a fresh, mutable set. The methods AnnotatedTypeFactory.getBundledTypeQualifiers(Class...) must return a fresh, mutable set
        Overrides:
        createSupportedTypeQualifiers in class AnnotatedTypeFactory
        Returns:
        the type qualifiers supported this processor, or an empty set if none
      • isLessThan

        public boolean isLessThan​(com.sun.source.tree.Tree left,
                                  java.lang.String right)
        Returns true if left is less than right.
        Parameters:
        left - the first tree to compare
        right - the second tree to compare
        Returns:
        is left less than right?
      • isLessThan

        public boolean isLessThan​(javax.lang.model.element.AnnotationMirror left,
                                  java.lang.String right)
        Returns true if left is less than right.
        Parameters:
        left - the first value to compare (an annotation)
        right - the second value to compare (an expression)
        Returns:
        is left less than right?
      • isLessThanByValue

        public boolean isLessThanByValue​(com.sun.source.tree.Tree smaller,
                                         java.lang.String bigger,
                                         com.sun.source.util.TreePath path)
        Returns true if smaller < bigger.
        Parameters:
        smaller - the first value to compare
        bigger - the second value to compare
        path - used to parse expressions strings
        Returns:
        smaller < bigger, using information from the Value Checker
      • isLessThanOrEqual

        public boolean isLessThanOrEqual​(com.sun.source.tree.Tree left,
                                         java.lang.String right)
        Returns true if left is less than or equal to right.
        Parameters:
        left - the first value to compare
        right - the second value to compare
        Returns:
        is left less than or equal to right?
      • isLessThanOrEqual

        public boolean isLessThanOrEqual​(javax.lang.model.element.AnnotationMirror left,
                                         java.lang.String right)
        Returns true if left is less than or equal to right.
        Parameters:
        left - the first value to compare
        right - the second value to compare
        Returns:
        is left less than or equal to right?
      • getLessThanExpressions

        public @Nullable java.util.List<java.lang.String> getLessThanExpressions​(com.sun.source.tree.ExpressionTree expression)
        Returns a sorted, modifiable list of expressions that expression is less than. If the expression is annotated with LessThanBottom, null is returned.
        Parameters:
        expression - an expression
        Returns:
        expressions that expression is less than
      • createLessThanQualifier

        public javax.lang.model.element.AnnotationMirror createLessThanQualifier​(@Nullable java.util.List<java.lang.String> expressions)
        Creates a less than qualifier given the expressions.

        If expressions is null, LessThanBottom is returned. If expressions is empty, LessThanUnknown is returned. Otherwise, @LessThan(expressions) is returned.

        Parameters:
        expressions - a list of expressions
        Returns:
        a @LessThan qualifier with the given arguments
      • createLessThanQualifier

        public javax.lang.model.element.AnnotationMirror createLessThanQualifier​(java.lang.String expression)
        Returns @LessThan(expression).
      • getLessThanExpressions

        public @Nullable java.util.List<java.lang.String> getLessThanExpressions​(javax.lang.model.element.AnnotationMirror annotation)
        If the annotation is LessThan, returns a list of expressions in the annotation. If the annotation is LessThanBottom, returns null. If the annotation is LessThanUnknown, returns the empty list.
        Parameters:
        annotation - an annotation from the same hierarchy as LessThan
        Returns:
        the list of expressions in the annotation