diff options
Diffstat (limited to 'ri/src')
31 files changed, 0 insertions, 767 deletions
diff --git a/ri/src/main/java/javax/annotation/CheckForNull.java b/ri/src/main/java/javax/annotation/CheckForNull.java deleted file mode 100644 index 6fe5200..0000000 --- a/ri/src/main/java/javax/annotation/CheckForNull.java +++ /dev/null @@ -1,16 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -import javax.annotation.meta.TypeQualifierNickname; -import javax.annotation.meta.When; - -@Documented -@TypeQualifierNickname -@Nonnull(when = When.MAYBE) -@Retention(RetentionPolicy.RUNTIME) -public @interface CheckForNull { - -} diff --git a/ri/src/main/java/javax/annotation/CheckForSigned.java b/ri/src/main/java/javax/annotation/CheckForSigned.java deleted file mode 100644 index f3bc597..0000000 --- a/ri/src/main/java/javax/annotation/CheckForSigned.java +++ /dev/null @@ -1,24 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -import javax.annotation.meta.TypeQualifierNickname; -import javax.annotation.meta.When; - -/** - * Used to annotate a value that may be either negative or nonnegative, and - * indicates that uses of it should check for - * negative values before using it in a way that requires the value to be - * nonnegative, and check for it being nonnegative before using it in a way that - * requires it to be negative. - */ - -@Documented -@TypeQualifierNickname -@Nonnegative(when = When.MAYBE) -@Retention(RetentionPolicy.RUNTIME) -public @interface CheckForSigned { - -} diff --git a/ri/src/main/java/javax/annotation/CheckReturnValue.java b/ri/src/main/java/javax/annotation/CheckReturnValue.java deleted file mode 100644 index 370fa38..0000000 --- a/ri/src/main/java/javax/annotation/CheckReturnValue.java +++ /dev/null @@ -1,17 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -import javax.annotation.meta.When; - -@Documented -@Target( { ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.TYPE, - ElementType.PACKAGE }) -@Retention(RetentionPolicy.RUNTIME) -public @interface CheckReturnValue { - When when() default When.ALWAYS; -} diff --git a/ri/src/main/java/javax/annotation/Detainted.java b/ri/src/main/java/javax/annotation/Detainted.java deleted file mode 100644 index d8620f2..0000000 --- a/ri/src/main/java/javax/annotation/Detainted.java +++ /dev/null @@ -1,16 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -import javax.annotation.meta.TypeQualifierNickname; -import javax.annotation.meta.When; - -@Documented -@TypeQualifierNickname -@Untainted(when = When.ALWAYS) -@Retention(RetentionPolicy.RUNTIME) -public @interface Detainted { - -} diff --git a/ri/src/main/java/javax/annotation/MatchesPattern.java b/ri/src/main/java/javax/annotation/MatchesPattern.java deleted file mode 100644 index 775d21c..0000000 --- a/ri/src/main/java/javax/annotation/MatchesPattern.java +++ /dev/null @@ -1,30 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.util.regex.Pattern; - -import javax.annotation.meta.TypeQualifier; -import javax.annotation.meta.TypeQualifierValidator; -import javax.annotation.meta.When; - -@Documented -@TypeQualifier(applicableTo = String.class) -@Retention(RetentionPolicy.RUNTIME) -public @interface MatchesPattern { - @RegEx - String value(); - - int flags() default 0; - - static class Checker implements TypeQualifierValidator<MatchesPattern> { - public When forConstantValue(MatchesPattern annotation, Object value) { - Pattern p = Pattern.compile(annotation.value(), annotation.flags()); - if (p.matcher(((String) value)).matches()) - return When.ALWAYS; - return When.NEVER; - } - - } -} diff --git a/ri/src/main/java/javax/annotation/Nonnegative.java b/ri/src/main/java/javax/annotation/Nonnegative.java deleted file mode 100644 index 21d1793..0000000 --- a/ri/src/main/java/javax/annotation/Nonnegative.java +++ /dev/null @@ -1,41 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -import javax.annotation.meta.TypeQualifier; -import javax.annotation.meta.TypeQualifierValidator; -import javax.annotation.meta.When; - -/** Used to annotate a value that should only contain nonnegative values */ -@Documented -@TypeQualifier(applicableTo = Number.class) -@Retention(RetentionPolicy.RUNTIME) -public @interface Nonnegative { - When when() default When.ALWAYS; - - class Checker implements TypeQualifierValidator<Nonnegative> { - - public When forConstantValue(Nonnegative annotation, Object v) { - if (!(v instanceof Number)) - return When.NEVER; - boolean isNegative; - Number value = (Number) v; - if (value instanceof Long) - isNegative = value.longValue() < 0; - else if (value instanceof Double) - isNegative = value.doubleValue() < 0; - else if (value instanceof Float) - isNegative = value.floatValue() < 0; - else - isNegative = value.intValue() < 0; - - if (isNegative) - return When.NEVER; - else - return When.ALWAYS; - - } - } -} diff --git a/ri/src/main/java/javax/annotation/Nonnull.java b/ri/src/main/java/javax/annotation/Nonnull.java deleted file mode 100644 index 4b7aad9..0000000 --- a/ri/src/main/java/javax/annotation/Nonnull.java +++ /dev/null @@ -1,26 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -import javax.annotation.meta.TypeQualifier; -import javax.annotation.meta.TypeQualifierValidator; -import javax.annotation.meta.When; - -@Documented -@TypeQualifier -@Retention(RetentionPolicy.RUNTIME) -public @interface Nonnull { - When when() default When.ALWAYS; - - static class Checker implements TypeQualifierValidator<Nonnull> { - - public When forConstantValue(Nonnull qualifierqualifierArgument, - Object value) { - if (value == null) - return When.NEVER; - return When.ALWAYS; - } - } -} diff --git a/ri/src/main/java/javax/annotation/Nullable.java b/ri/src/main/java/javax/annotation/Nullable.java deleted file mode 100644 index d31993d..0000000 --- a/ri/src/main/java/javax/annotation/Nullable.java +++ /dev/null @@ -1,16 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -import javax.annotation.meta.TypeQualifierNickname; -import javax.annotation.meta.When; - -@Documented -@TypeQualifierNickname -@Nonnull(when = When.UNKNOWN) -@Retention(RetentionPolicy.RUNTIME) -public @interface Nullable { - -} diff --git a/ri/src/main/java/javax/annotation/OverridingMethodsMustInvokeSuper.java b/ri/src/main/java/javax/annotation/OverridingMethodsMustInvokeSuper.java deleted file mode 100644 index 4e3344e..0000000 --- a/ri/src/main/java/javax/annotation/OverridingMethodsMustInvokeSuper.java +++ /dev/null @@ -1,20 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * When this annotation is applied to a method, it indicates that if this method - * is overridden in a subclass, the overriding method should invoke this method - * (through method invocation on super). - * - */ -@Documented -@Target( { ElementType.METHOD }) -@Retention(RetentionPolicy.RUNTIME) -public @interface OverridingMethodsMustInvokeSuper { - -} diff --git a/ri/src/main/java/javax/annotation/ParametersAreNonnullByDefault.java b/ri/src/main/java/javax/annotation/ParametersAreNonnullByDefault.java deleted file mode 100644 index 6424b87..0000000 --- a/ri/src/main/java/javax/annotation/ParametersAreNonnullByDefault.java +++ /dev/null @@ -1,27 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -import javax.annotation.meta.TypeQualifierDefault; - -/** - * This annotation can be applied to a package, class or method to indicate that - * the method parameters in that element are nonnull by default unless there is: - * <ul> - * <li>An explicit nullness annotation - * <li>The method overrides a method in a superclass (in which case the - * annotation of the corresponding parameter in the superclass applies) - * <li> there is a default parameter annotation applied to a more tightly nested - * element. - * </ul> - * - */ -@Documented -@Nonnull -@TypeQualifierDefault(ElementType.PARAMETER) -@Retention(RetentionPolicy.RUNTIME) -public @interface ParametersAreNonnullByDefault { -} diff --git a/ri/src/main/java/javax/annotation/ParametersAreNullableByDefault.java b/ri/src/main/java/javax/annotation/ParametersAreNullableByDefault.java deleted file mode 100644 index 01d4d80..0000000 --- a/ri/src/main/java/javax/annotation/ParametersAreNullableByDefault.java +++ /dev/null @@ -1,30 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -import javax.annotation.meta.TypeQualifierDefault; - -/** - * This annotation can be applied to a package, class or method to indicate that - * the method parameters in that element are nullable by default unless there is: - * <ul> - * <li>An explicit nullness annotation - * <li>The method overrides a method in a superclass (in which case the - * annotation of the corresponding parameter in the superclass applies) - * <li> there is a default parameter annotation applied to a more tightly nested - * element. - * </ul> - * <p>This annotation implies the same "nullness" as no annotation. However, it is different - * than having no annotation, as it is inherited and it can override a ParametersAreNonnullByDefault - * annotation at an outer scope. - * - */ -@Documented -@Nullable -@TypeQualifierDefault(ElementType.PARAMETER) -@Retention(RetentionPolicy.RUNTIME) -public @interface ParametersAreNullableByDefault { -} diff --git a/ri/src/main/java/javax/annotation/PropertyKey.java b/ri/src/main/java/javax/annotation/PropertyKey.java deleted file mode 100644 index 780782d..0000000 --- a/ri/src/main/java/javax/annotation/PropertyKey.java +++ /dev/null @@ -1,15 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -import javax.annotation.meta.TypeQualifier; -import javax.annotation.meta.When; - -@Documented -@TypeQualifier -@Retention(RetentionPolicy.RUNTIME) -public @interface PropertyKey { - When when() default When.ALWAYS; -} diff --git a/ri/src/main/java/javax/annotation/RegEx.java b/ri/src/main/java/javax/annotation/RegEx.java deleted file mode 100644 index 21697a7..0000000 --- a/ri/src/main/java/javax/annotation/RegEx.java +++ /dev/null @@ -1,42 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.util.regex.Pattern; -import java.util.regex.PatternSyntaxException; - -import javax.annotation.meta.TypeQualifierNickname; -import javax.annotation.meta.TypeQualifierValidator; -import javax.annotation.meta.When; - -/** - * This qualifier is used to denote String values that should be a Regular - * expression. - * - */ -@Documented -@Syntax("RegEx") -@TypeQualifierNickname -@Retention(RetentionPolicy.RUNTIME) -public @interface RegEx { - When when() default When.ALWAYS; - - static class Checker implements TypeQualifierValidator<RegEx> { - - public When forConstantValue(RegEx annotation, Object value) { - if (!(value instanceof String)) - return When.NEVER; - - try { - Pattern.compile((String) value); - } catch (PatternSyntaxException e) { - return When.NEVER; - } - return When.ALWAYS; - - } - - } - -} diff --git a/ri/src/main/java/javax/annotation/Signed.java b/ri/src/main/java/javax/annotation/Signed.java deleted file mode 100644 index 2c2fa06..0000000 --- a/ri/src/main/java/javax/annotation/Signed.java +++ /dev/null @@ -1,18 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -import javax.annotation.meta.TypeQualifierNickname; -import javax.annotation.meta.When; - -/** Used to annotate a value of unknown sign */ - -@Documented -@TypeQualifierNickname -@Nonnegative(when = When.UNKNOWN) -@Retention(RetentionPolicy.RUNTIME) -public @interface Signed { - -} diff --git a/ri/src/main/java/javax/annotation/Syntax.java b/ri/src/main/java/javax/annotation/Syntax.java deleted file mode 100644 index 5491093..0000000 --- a/ri/src/main/java/javax/annotation/Syntax.java +++ /dev/null @@ -1,44 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -import javax.annotation.meta.TypeQualifier; -import javax.annotation.meta.When; - -/** - * This annotation a value that is of a particular syntax, such as Java syntax - * or regular expression syntax. This can be used to provide syntax checking of - * constant values at compile time, run time checking at runtime, and can assist - * IDEs in deciding how to interpret String constants (e.g., should a - * refactoring that renames method x() to y() update the String constant "x()"). - * - * - */ -@Documented -@TypeQualifier(applicableTo = String.class) -@Retention(RetentionPolicy.RUNTIME) -public @interface Syntax { - /** - * Value indicating the particular syntax denoted by this annotation. - * Different tools will recognize different syntaxes, but some proposed - * canonical values are: - * <ul> - * <li> "Java" - * <li> "RegEx" - * <li> "JavaScript" - * <li> "Ruby" - * <li> "Groovy" - * <li> "SQL" - * <li> "FormatString" - * </ul> - * - * Syntax names can be followed by a colon and a list of key value pairs, - * separated by commas. For example, "SQL:dialect=Oracle,version=2.3". Tools - * should ignore any keys they don't recognize. - */ - String value(); - - When when() default When.ALWAYS; -} diff --git a/ri/src/main/java/javax/annotation/Tainted.java b/ri/src/main/java/javax/annotation/Tainted.java deleted file mode 100644 index 6715d70..0000000 --- a/ri/src/main/java/javax/annotation/Tainted.java +++ /dev/null @@ -1,16 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -import javax.annotation.meta.TypeQualifierNickname; -import javax.annotation.meta.When; - -@Documented -@TypeQualifierNickname -@Untainted(when = When.MAYBE) -@Retention(RetentionPolicy.RUNTIME) -public @interface Tainted { - -} diff --git a/ri/src/main/java/javax/annotation/Untainted.java b/ri/src/main/java/javax/annotation/Untainted.java deleted file mode 100644 index 4a26a49..0000000 --- a/ri/src/main/java/javax/annotation/Untainted.java +++ /dev/null @@ -1,15 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -import javax.annotation.meta.TypeQualifier; -import javax.annotation.meta.When; - -@Documented -@TypeQualifier -@Retention(RetentionPolicy.RUNTIME) -public @interface Untainted { - When when() default When.ALWAYS; -} diff --git a/ri/src/main/java/javax/annotation/WillClose.java b/ri/src/main/java/javax/annotation/WillClose.java deleted file mode 100644 index 9ea70cf..0000000 --- a/ri/src/main/java/javax/annotation/WillClose.java +++ /dev/null @@ -1,15 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -@Documented -@Retention(RetentionPolicy.RUNTIME) -/** - * Used to annotate a method parameter to indicate that this method will close - * the resource. - */ -public @interface WillClose { - -} diff --git a/ri/src/main/java/javax/annotation/WillCloseWhenClosed.java b/ri/src/main/java/javax/annotation/WillCloseWhenClosed.java deleted file mode 100644 index 13c927d..0000000 --- a/ri/src/main/java/javax/annotation/WillCloseWhenClosed.java +++ /dev/null @@ -1,15 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -@Documented -@Retention(RetentionPolicy.RUNTIME) -/** - * Used to annotate a constructor/factory parameter to indicate that returned - * object (X) will close the resource when X is closed. - */ -public @interface WillCloseWhenClosed { - -} diff --git a/ri/src/main/java/javax/annotation/WillNotClose.java b/ri/src/main/java/javax/annotation/WillNotClose.java deleted file mode 100644 index d698b7c..0000000 --- a/ri/src/main/java/javax/annotation/WillNotClose.java +++ /dev/null @@ -1,15 +0,0 @@ -package javax.annotation; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -@Documented -@Retention(RetentionPolicy.RUNTIME) -/** - * Used to annotate a method parameter to indicate that this method will not - * close the resource. - */ -public @interface WillNotClose { - -} diff --git a/ri/src/main/java/javax/annotation/concurrent/GuardedBy.java b/ri/src/main/java/javax/annotation/concurrent/GuardedBy.java deleted file mode 100644 index 9d6641d..0000000 --- a/ri/src/main/java/javax/annotation/concurrent/GuardedBy.java +++ /dev/null @@ -1,38 +0,0 @@ -package javax.annotation.concurrent; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/* - * Copyright (c) 2005 Brian Goetz - * Released under the Creative Commons Attribution License - * (http://creativecommons.org/licenses/by/2.5) - * Official home: http://www.jcip.net - */ - -/** - * GuardedBy - * - * The field or method to which this annotation is applied can only be accessed - * when holding a particular lock, which may be a built-in (synchronization) - * lock, or may be an explicit java.util.concurrent.Lock. - * - * The argument determines which lock guards the annotated field or method: this : - * The string literal "this" means that this field is guarded by the class in - * which it is defined. class-name.this : For inner classes, it may be necessary - * to disambiguate 'this'; the class-name.this designation allows you to specify - * which 'this' reference is intended itself : For reference fields only; the - * object to which the field refers. field-name : The lock object is referenced - * by the (instance or static) field specified by field-name. - * class-name.field-name : The lock object is reference by the static field - * specified by class-name.field-name. method-name() : The lock object is - * returned by calling the named nil-ary method. class-name.class : The Class - * object for the specified class should be used as the lock object. - */ -@Target( { ElementType.FIELD, ElementType.METHOD }) -@Retention(RetentionPolicy.CLASS) -public @interface GuardedBy { - String value(); -} diff --git a/ri/src/main/java/javax/annotation/concurrent/Immutable.java b/ri/src/main/java/javax/annotation/concurrent/Immutable.java deleted file mode 100644 index 03f1cb5..0000000 --- a/ri/src/main/java/javax/annotation/concurrent/Immutable.java +++ /dev/null @@ -1,36 +0,0 @@ -package javax.annotation.concurrent; - -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/* - * Copyright (c) 2005 Brian Goetz - * Released under the Creative Commons Attribution License - * (http://creativecommons.org/licenses/by/2.5) - * Official home: http://www.jcip.net - */ - -/** - * Immutable - * - * The class to which this annotation is applied is immutable. This means that - * its state cannot be seen to change by callers. Of necessity this means that - * all public fields are final, and that all public final reference fields refer - * to other immutable objects, and that methods do not publish references to any - * internal state which is mutable by implementation even if not by design. - * Immutable objects may still have internal mutable state for purposes of - * performance optimization; some state variables may be lazily computed, so - * long as they are computed from immutable state and that callers cannot tell - * the difference. - * - * Immutable objects are inherently thread-safe; they may be passed between - * threads or published without synchronization. - */ -@Documented -@Target(ElementType.TYPE) -@Retention(RetentionPolicy.CLASS) -public @interface Immutable { -} diff --git a/ri/src/main/java/javax/annotation/concurrent/NotThreadSafe.java b/ri/src/main/java/javax/annotation/concurrent/NotThreadSafe.java deleted file mode 100644 index d948142..0000000 --- a/ri/src/main/java/javax/annotation/concurrent/NotThreadSafe.java +++ /dev/null @@ -1,30 +0,0 @@ -package javax.annotation.concurrent; - -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/* - * Copyright (c) 2005 Brian Goetz - * Released under the Creative Commons Attribution License - * (http://creativecommons.org/licenses/by/2.5) - * Official home: http://www.jcip.net - */ - -/** - * NotThreadSafe - * - * The class to which this annotation is applied is not thread-safe. This - * annotation primarily exists for clarifying the non-thread-safety of a class - * that might otherwise be assumed to be thread-safe, despite the fact that it - * is a bad idea to assume a class is thread-safe without good reason. - * - * @see ThreadSafe - */ -@Documented -@Target(ElementType.TYPE) -@Retention(RetentionPolicy.CLASS) -public @interface NotThreadSafe { -} diff --git a/ri/src/main/java/javax/annotation/concurrent/ThreadSafe.java b/ri/src/main/java/javax/annotation/concurrent/ThreadSafe.java deleted file mode 100644 index 3c86128..0000000 --- a/ri/src/main/java/javax/annotation/concurrent/ThreadSafe.java +++ /dev/null @@ -1,22 +0,0 @@ -package javax.annotation.concurrent; - -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * ThreadSafe - * - * The class to which this annotation is applied is thread-safe. This means that - * no sequences of accesses (reads and writes to public fields, calls to public - * methods) may put the object into an invalid state, regardless of the - * interleaving of those actions by the runtime, and without requiring any - * additional synchronization or coordination on the part of the caller. - */ -@Documented -@Target(ElementType.TYPE) -@Retention(RetentionPolicy.CLASS) -public @interface ThreadSafe { -} diff --git a/ri/src/main/java/javax/annotation/meta/Exclusive.java b/ri/src/main/java/javax/annotation/meta/Exclusive.java deleted file mode 100644 index d018c33..0000000 --- a/ri/src/main/java/javax/annotation/meta/Exclusive.java +++ /dev/null @@ -1,26 +0,0 @@ -package javax.annotation.meta; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -/** - * This annotation can be applied to the value() element of an annotation that - * is annotated as a TypeQualifier. - * - * For example, the following defines a type qualifier such that if you know a - * value is {@literal @Foo(1)}, then the value cannot be {@literal @Foo(2)} or {{@literal @Foo(3)}. - * - * <code> - * @TypeQualifier @interface Foo { - * @Exclusive int value(); - * } - * </code> - * - */ - -@Documented -@Retention(RetentionPolicy.RUNTIME) -public @interface Exclusive { - -} diff --git a/ri/src/main/java/javax/annotation/meta/Exhaustive.java b/ri/src/main/java/javax/annotation/meta/Exhaustive.java deleted file mode 100644 index dc75f06..0000000 --- a/ri/src/main/java/javax/annotation/meta/Exhaustive.java +++ /dev/null @@ -1,33 +0,0 @@ -package javax.annotation.meta; - -import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -/** - * This annotation can be applied to the value() element of an annotation that - * is annotated as a TypeQualifier. This is only appropriate if the value field - * returns a value that is an Enumeration. - * - * Applications of the type qualifier with different values are exclusive, and - * the enumeration is an exhaustive list of the possible values. - * - * For example, the following defines a type qualifier such that if you know a - * value is neither {@literal @Foo(Color.Red)} or {@literal @Foo(Color.Blue)}, - * then the value must be {@literal @Foo(Color.Green)}. And if you know it is - * {@literal @Foo(Color.Green)}, you know it cannot be - * {@literal @Foo(Color.Red)} or {@literal @Foo(Color.Blue)} - * - * <code> - * @TypeQualifier @interface Foo { - * enum Color {RED, BLUE, GREEN}; - * @Exhaustive Color value(); - * } - * </code> - */ - -@Documented -@Retention(RetentionPolicy.RUNTIME) -public @interface Exhaustive { - -} diff --git a/ri/src/main/java/javax/annotation/meta/TypeQualifier.java b/ri/src/main/java/javax/annotation/meta/TypeQualifier.java deleted file mode 100644 index 99f6312..0000000 --- a/ri/src/main/java/javax/annotation/meta/TypeQualifier.java +++ /dev/null @@ -1,27 +0,0 @@ -package javax.annotation.meta; - -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * This qualifier is applied to an annotation to denote that the annotation - * should be treated as a type qualifier. - */ - -@Documented -@Target(ElementType.ANNOTATION_TYPE) -@Retention(RetentionPolicy.RUNTIME) -public @interface TypeQualifier { - - /** - * Describes the kinds of values the qualifier can be applied to. If a - * numeric class is provided (e.g., Number.class or Integer.class) then the - * annotation can also be applied to the corresponding primitive numeric - * types. - */ - Class<?> applicableTo() default Object.class; - -} diff --git a/ri/src/main/java/javax/annotation/meta/TypeQualifierDefault.java b/ri/src/main/java/javax/annotation/meta/TypeQualifierDefault.java deleted file mode 100644 index 0c8bd52..0000000 --- a/ri/src/main/java/javax/annotation/meta/TypeQualifierDefault.java +++ /dev/null @@ -1,20 +0,0 @@ -package javax.annotation.meta; - -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * This qualifier is applied to an annotation to denote that the annotation - * defines a default type qualifier that is visible within the scope of the - * element it is applied to. - */ - -@Documented -@Target(ElementType.ANNOTATION_TYPE) -@Retention(RetentionPolicy.RUNTIME) -public @interface TypeQualifierDefault { - ElementType[] value() default {}; -} diff --git a/ri/src/main/java/javax/annotation/meta/TypeQualifierNickname.java b/ri/src/main/java/javax/annotation/meta/TypeQualifierNickname.java deleted file mode 100644 index 40c9983..0000000 --- a/ri/src/main/java/javax/annotation/meta/TypeQualifierNickname.java +++ /dev/null @@ -1,33 +0,0 @@ -package javax.annotation.meta; - -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Target; - -/** - * - * This annotation is applied to a annotation, and marks the annotation as being - * a qualifier nickname. Applying a nickname annotation X to a element Y should - * be interpreted as having the same meaning as applying all of annotations of X - * (other than QualifierNickname) to Y. - * - * <p> - * Thus, you might define a qualifier SocialSecurityNumber as follows: - * </p> - * - * - * <code> - @Documented - @TypeQualifierNickname @Pattern("[0-9]{3}-[0-9]{2}-[0-9]{4}") - @Retention(RetentionPolicy.RUNTIME) - public @interface SocialSecurityNumber { - } - </code> - * - * - */ -@Documented -@Target(ElementType.ANNOTATION_TYPE) -public @interface TypeQualifierNickname { - -} diff --git a/ri/src/main/java/javax/annotation/meta/TypeQualifierValidator.java b/ri/src/main/java/javax/annotation/meta/TypeQualifierValidator.java deleted file mode 100644 index 8053011..0000000 --- a/ri/src/main/java/javax/annotation/meta/TypeQualifierValidator.java +++ /dev/null @@ -1,21 +0,0 @@ -package javax.annotation.meta; - -import java.lang.annotation.Annotation; - -import javax.annotation.Nonnull; - -public interface TypeQualifierValidator<A extends Annotation> { - /** - * Given a type qualifier, check to see if a known specific constant value - * is an instance of the set of values denoted by the qualifier. - * - * @param annotation - * the type qualifier - * @param value - * the value to check - * @return a value indicating whether or not the value is an member of the - * values denoted by the type qualifier - */ - public @Nonnull - When forConstantValue(@Nonnull A annotation, Object value); -} diff --git a/ri/src/main/java/javax/annotation/meta/When.java b/ri/src/main/java/javax/annotation/meta/When.java deleted file mode 100644 index ec8a1bc..0000000 --- a/ri/src/main/java/javax/annotation/meta/When.java +++ /dev/null @@ -1,23 +0,0 @@ -package javax.annotation.meta; - -/** - * Used to describe the relationship between a qualifier T and the set of values - * S possible on an annotated element. - * - * In particular, an issues should be reported if an ALWAYS or MAYBE value is - * used where a NEVER value is required, or if a NEVER or MAYBE value is used - * where an ALWAYS value is required. - * - * - */ -public enum When { - /** S is a subset of T */ - ALWAYS, - /** nothing definitive is known about the relation between S and T */ - UNKNOWN, - /** S intersection T is non empty and S - T is nonempty */ - MAYBE, - /** S intersection T is empty */ - NEVER; - -} |