From 4eceb95409e844fdc33c9c706e1dc307bfd40303 Mon Sep 17 00:00:00 2001 From: Yohann Roussel Date: Wed, 19 Mar 2014 16:25:37 +0100 Subject: Initial Jack import. Change-Id: I953cf0a520195a7187d791b2885848ad0d5a9b43 --- jsr305/ri/.classpath | 6 ++ jsr305/ri/.project | 17 +++++ jsr305/ri/.settings/org.eclipse.jdt.core.prefs | 12 ++++ jsr305/ri/.settings/org.eclipse.jdt.ui.prefs | 3 + jsr305/ri/LICENSE | 28 ++++++++ jsr305/ri/build.xml | 35 ++++++++++ jsr305/ri/nbproject/project.xml | 78 ++++++++++++++++++++++ jsr305/ri/pom.xml | 20 ++++++ .../main/java/javax/annotation/CheckForNull.java | 16 +++++ .../main/java/javax/annotation/CheckForSigned.java | 24 +++++++ .../java/javax/annotation/CheckReturnValue.java | 17 +++++ .../src/main/java/javax/annotation/Detainted.java | 16 +++++ .../main/java/javax/annotation/MatchesPattern.java | 30 +++++++++ .../main/java/javax/annotation/Nonnegative.java | 41 ++++++++++++ .../ri/src/main/java/javax/annotation/Nonnull.java | 26 ++++++++ .../src/main/java/javax/annotation/Nullable.java | 16 +++++ .../OverridingMethodsMustInvokeSuper.java | 20 ++++++ .../annotation/ParametersAreNonnullByDefault.java | 27 ++++++++ .../annotation/ParametersAreNullableByDefault.java | 30 +++++++++ .../main/java/javax/annotation/PropertyKey.java | 15 +++++ .../ri/src/main/java/javax/annotation/RegEx.java | 42 ++++++++++++ .../ri/src/main/java/javax/annotation/Signed.java | 18 +++++ .../ri/src/main/java/javax/annotation/Syntax.java | 44 ++++++++++++ .../ri/src/main/java/javax/annotation/Tainted.java | 16 +++++ .../src/main/java/javax/annotation/Untainted.java | 15 +++++ .../src/main/java/javax/annotation/WillClose.java | 15 +++++ .../java/javax/annotation/WillCloseWhenClosed.java | 15 +++++ .../main/java/javax/annotation/WillNotClose.java | 15 +++++ .../javax/annotation/concurrent/GuardedBy.java | 38 +++++++++++ .../javax/annotation/concurrent/Immutable.java | 36 ++++++++++ .../javax/annotation/concurrent/NotThreadSafe.java | 30 +++++++++ .../javax/annotation/concurrent/ThreadSafe.java | 22 ++++++ .../main/java/javax/annotation/meta/Exclusive.java | 26 ++++++++ .../java/javax/annotation/meta/Exhaustive.java | 33 +++++++++ .../java/javax/annotation/meta/TypeQualifier.java | 27 ++++++++ .../annotation/meta/TypeQualifierDefault.java | 20 ++++++ .../annotation/meta/TypeQualifierNickname.java | 33 +++++++++ .../annotation/meta/TypeQualifierValidator.java | 21 ++++++ .../src/main/java/javax/annotation/meta/When.java | 23 +++++++ 39 files changed, 966 insertions(+) create mode 100644 jsr305/ri/.classpath create mode 100644 jsr305/ri/.project create mode 100644 jsr305/ri/.settings/org.eclipse.jdt.core.prefs create mode 100644 jsr305/ri/.settings/org.eclipse.jdt.ui.prefs create mode 100644 jsr305/ri/LICENSE create mode 100644 jsr305/ri/build.xml create mode 100644 jsr305/ri/nbproject/project.xml create mode 100644 jsr305/ri/pom.xml create mode 100644 jsr305/ri/src/main/java/javax/annotation/CheckForNull.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/CheckForSigned.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/CheckReturnValue.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/Detainted.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/MatchesPattern.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/Nonnegative.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/Nonnull.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/Nullable.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/OverridingMethodsMustInvokeSuper.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/ParametersAreNonnullByDefault.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/ParametersAreNullableByDefault.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/PropertyKey.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/RegEx.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/Signed.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/Syntax.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/Tainted.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/Untainted.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/WillClose.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/WillCloseWhenClosed.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/WillNotClose.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/concurrent/GuardedBy.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/concurrent/Immutable.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/concurrent/NotThreadSafe.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/concurrent/ThreadSafe.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/meta/Exclusive.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/meta/Exhaustive.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifier.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifierDefault.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifierNickname.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifierValidator.java create mode 100644 jsr305/ri/src/main/java/javax/annotation/meta/When.java (limited to 'jsr305/ri') diff --git a/jsr305/ri/.classpath b/jsr305/ri/.classpath new file mode 100644 index 00000000..b0f1c60e --- /dev/null +++ b/jsr305/ri/.classpath @@ -0,0 +1,6 @@ + + + + + + diff --git a/jsr305/ri/.project b/jsr305/ri/.project new file mode 100644 index 00000000..4855f3bb --- /dev/null +++ b/jsr305/ri/.project @@ -0,0 +1,17 @@ + + + JSR305-ri + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/jsr305/ri/.settings/org.eclipse.jdt.core.prefs b/jsr305/ri/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 00000000..1bb83fc0 --- /dev/null +++ b/jsr305/ri/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,12 @@ +#Wed Jun 20 13:34:34 GMT-05:00 2007 +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.5 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.5 diff --git a/jsr305/ri/.settings/org.eclipse.jdt.ui.prefs b/jsr305/ri/.settings/org.eclipse.jdt.ui.prefs new file mode 100644 index 00000000..f1d942c8 --- /dev/null +++ b/jsr305/ri/.settings/org.eclipse.jdt.ui.prefs @@ -0,0 +1,3 @@ +#Wed Jun 20 13:34:34 GMT-05:00 2007 +eclipse.preferences.version=1 +internal.default.compliance=default diff --git a/jsr305/ri/LICENSE b/jsr305/ri/LICENSE new file mode 100644 index 00000000..67366813 --- /dev/null +++ b/jsr305/ri/LICENSE @@ -0,0 +1,28 @@ +Copyright (c) 2007-2009, JSR305 expert group +All rights reserved. + +http://www.opensource.org/licenses/bsd-license.php + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + * Neither the name of the JSR305 expert group nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/jsr305/ri/build.xml b/jsr305/ri/build.xml new file mode 100644 index 00000000..ad07dec0 --- /dev/null +++ b/jsr305/ri/build.xml @@ -0,0 +1,35 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/jsr305/ri/nbproject/project.xml b/jsr305/ri/nbproject/project.xml new file mode 100644 index 00000000..e4a7852b --- /dev/null +++ b/jsr305/ri/nbproject/project.xml @@ -0,0 +1,78 @@ + + + org.netbeans.modules.ant.freeform + + + JSR305-ri + + + + JSR305-ri + + + + + java + src/main/java + UTF-8 + + + + java + src/main/resources + UTF-8 + + + + . + UTF-8 + + + + + build + + + clean + + + clean + build + + + + folder + build + build + + + + + + src/main/java + + + + src/main/resources + + + build.xml + + + + + + + + + + + + src/main/java + src/main/resources + build + 1.5 + + + + diff --git a/jsr305/ri/pom.xml b/jsr305/ri/pom.xml new file mode 100644 index 00000000..becde963 --- /dev/null +++ b/jsr305/ri/pom.xml @@ -0,0 +1,20 @@ + + + + 4.0.0 + + org.jsr-305 + jsr-305 + 0.1-SNAPSHOT + + + org.jsr-305 + ri + jar + JSR 305 Implementation + 0.1-SNAPSHOT + Implementation for JSR-305 + + + diff --git a/jsr305/ri/src/main/java/javax/annotation/CheckForNull.java b/jsr305/ri/src/main/java/javax/annotation/CheckForNull.java new file mode 100644 index 00000000..6fe52005 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/CheckForNull.java @@ -0,0 +1,16 @@ +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/jsr305/ri/src/main/java/javax/annotation/CheckForSigned.java b/jsr305/ri/src/main/java/javax/annotation/CheckForSigned.java new file mode 100644 index 00000000..f3bc5975 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/CheckForSigned.java @@ -0,0 +1,24 @@ +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/jsr305/ri/src/main/java/javax/annotation/CheckReturnValue.java b/jsr305/ri/src/main/java/javax/annotation/CheckReturnValue.java new file mode 100644 index 00000000..370fa381 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/CheckReturnValue.java @@ -0,0 +1,17 @@ +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/jsr305/ri/src/main/java/javax/annotation/Detainted.java b/jsr305/ri/src/main/java/javax/annotation/Detainted.java new file mode 100644 index 00000000..d8620f2f --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/Detainted.java @@ -0,0 +1,16 @@ +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/jsr305/ri/src/main/java/javax/annotation/MatchesPattern.java b/jsr305/ri/src/main/java/javax/annotation/MatchesPattern.java new file mode 100644 index 00000000..775d21c3 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/MatchesPattern.java @@ -0,0 +1,30 @@ +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 { + 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/jsr305/ri/src/main/java/javax/annotation/Nonnegative.java b/jsr305/ri/src/main/java/javax/annotation/Nonnegative.java new file mode 100644 index 00000000..21d17938 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/Nonnegative.java @@ -0,0 +1,41 @@ +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 { + + 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/jsr305/ri/src/main/java/javax/annotation/Nonnull.java b/jsr305/ri/src/main/java/javax/annotation/Nonnull.java new file mode 100644 index 00000000..4b7aad97 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/Nonnull.java @@ -0,0 +1,26 @@ +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 { + + public When forConstantValue(Nonnull qualifierqualifierArgument, + Object value) { + if (value == null) + return When.NEVER; + return When.ALWAYS; + } + } +} diff --git a/jsr305/ri/src/main/java/javax/annotation/Nullable.java b/jsr305/ri/src/main/java/javax/annotation/Nullable.java new file mode 100644 index 00000000..d31993db --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/Nullable.java @@ -0,0 +1,16 @@ +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/jsr305/ri/src/main/java/javax/annotation/OverridingMethodsMustInvokeSuper.java b/jsr305/ri/src/main/java/javax/annotation/OverridingMethodsMustInvokeSuper.java new file mode 100644 index 00000000..4e3344e8 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/OverridingMethodsMustInvokeSuper.java @@ -0,0 +1,20 @@ +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/jsr305/ri/src/main/java/javax/annotation/ParametersAreNonnullByDefault.java b/jsr305/ri/src/main/java/javax/annotation/ParametersAreNonnullByDefault.java new file mode 100644 index 00000000..6424b873 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/ParametersAreNonnullByDefault.java @@ -0,0 +1,27 @@ +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: + *
    + *
  • An explicit nullness annotation + *
  • The method overrides a method in a superclass (in which case the + * annotation of the corresponding parameter in the superclass applies) + *
  • there is a default parameter annotation applied to a more tightly nested + * element. + *
+ * + */ +@Documented +@Nonnull +@TypeQualifierDefault(ElementType.PARAMETER) +@Retention(RetentionPolicy.RUNTIME) +public @interface ParametersAreNonnullByDefault { +} diff --git a/jsr305/ri/src/main/java/javax/annotation/ParametersAreNullableByDefault.java b/jsr305/ri/src/main/java/javax/annotation/ParametersAreNullableByDefault.java new file mode 100644 index 00000000..01d4d806 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/ParametersAreNullableByDefault.java @@ -0,0 +1,30 @@ +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: + *
    + *
  • An explicit nullness annotation + *
  • The method overrides a method in a superclass (in which case the + * annotation of the corresponding parameter in the superclass applies) + *
  • there is a default parameter annotation applied to a more tightly nested + * element. + *
+ *

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/jsr305/ri/src/main/java/javax/annotation/PropertyKey.java b/jsr305/ri/src/main/java/javax/annotation/PropertyKey.java new file mode 100644 index 00000000..780782d9 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/PropertyKey.java @@ -0,0 +1,15 @@ +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/jsr305/ri/src/main/java/javax/annotation/RegEx.java b/jsr305/ri/src/main/java/javax/annotation/RegEx.java new file mode 100644 index 00000000..21697a76 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/RegEx.java @@ -0,0 +1,42 @@ +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 { + + 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/jsr305/ri/src/main/java/javax/annotation/Signed.java b/jsr305/ri/src/main/java/javax/annotation/Signed.java new file mode 100644 index 00000000..2c2fa062 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/Signed.java @@ -0,0 +1,18 @@ +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/jsr305/ri/src/main/java/javax/annotation/Syntax.java b/jsr305/ri/src/main/java/javax/annotation/Syntax.java new file mode 100644 index 00000000..54910936 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/Syntax.java @@ -0,0 +1,44 @@ +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: + *

    + *
  • "Java" + *
  • "RegEx" + *
  • "JavaScript" + *
  • "Ruby" + *
  • "Groovy" + *
  • "SQL" + *
  • "FormatString" + *
+ * + * 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/jsr305/ri/src/main/java/javax/annotation/Tainted.java b/jsr305/ri/src/main/java/javax/annotation/Tainted.java new file mode 100644 index 00000000..6715d700 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/Tainted.java @@ -0,0 +1,16 @@ +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/jsr305/ri/src/main/java/javax/annotation/Untainted.java b/jsr305/ri/src/main/java/javax/annotation/Untainted.java new file mode 100644 index 00000000..4a26a492 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/Untainted.java @@ -0,0 +1,15 @@ +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/jsr305/ri/src/main/java/javax/annotation/WillClose.java b/jsr305/ri/src/main/java/javax/annotation/WillClose.java new file mode 100644 index 00000000..9ea70cfb --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/WillClose.java @@ -0,0 +1,15 @@ +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/jsr305/ri/src/main/java/javax/annotation/WillCloseWhenClosed.java b/jsr305/ri/src/main/java/javax/annotation/WillCloseWhenClosed.java new file mode 100644 index 00000000..13c927d6 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/WillCloseWhenClosed.java @@ -0,0 +1,15 @@ +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/jsr305/ri/src/main/java/javax/annotation/WillNotClose.java b/jsr305/ri/src/main/java/javax/annotation/WillNotClose.java new file mode 100644 index 00000000..d698b7c2 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/WillNotClose.java @@ -0,0 +1,15 @@ +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/jsr305/ri/src/main/java/javax/annotation/concurrent/GuardedBy.java b/jsr305/ri/src/main/java/javax/annotation/concurrent/GuardedBy.java new file mode 100644 index 00000000..9d6641da --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/concurrent/GuardedBy.java @@ -0,0 +1,38 @@ +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/jsr305/ri/src/main/java/javax/annotation/concurrent/Immutable.java b/jsr305/ri/src/main/java/javax/annotation/concurrent/Immutable.java new file mode 100644 index 00000000..03f1cb58 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/concurrent/Immutable.java @@ -0,0 +1,36 @@ +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/jsr305/ri/src/main/java/javax/annotation/concurrent/NotThreadSafe.java b/jsr305/ri/src/main/java/javax/annotation/concurrent/NotThreadSafe.java new file mode 100644 index 00000000..d9481426 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/concurrent/NotThreadSafe.java @@ -0,0 +1,30 @@ +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/jsr305/ri/src/main/java/javax/annotation/concurrent/ThreadSafe.java b/jsr305/ri/src/main/java/javax/annotation/concurrent/ThreadSafe.java new file mode 100644 index 00000000..3c861289 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/concurrent/ThreadSafe.java @@ -0,0 +1,22 @@ +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/jsr305/ri/src/main/java/javax/annotation/meta/Exclusive.java b/jsr305/ri/src/main/java/javax/annotation/meta/Exclusive.java new file mode 100644 index 00000000..d018c33b --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/meta/Exclusive.java @@ -0,0 +1,26 @@ +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)}. + * + * + * @TypeQualifier @interface Foo { + * @Exclusive int value(); + * } + * + * + */ + +@Documented +@Retention(RetentionPolicy.RUNTIME) +public @interface Exclusive { + +} diff --git a/jsr305/ri/src/main/java/javax/annotation/meta/Exhaustive.java b/jsr305/ri/src/main/java/javax/annotation/meta/Exhaustive.java new file mode 100644 index 00000000..dc75f06b --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/meta/Exhaustive.java @@ -0,0 +1,33 @@ +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)} + * + * + * @TypeQualifier @interface Foo { + * enum Color {RED, BLUE, GREEN}; + * @Exhaustive Color value(); + * } + * + */ + +@Documented +@Retention(RetentionPolicy.RUNTIME) +public @interface Exhaustive { + +} diff --git a/jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifier.java b/jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifier.java new file mode 100644 index 00000000..99f63127 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifier.java @@ -0,0 +1,27 @@ +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/jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifierDefault.java b/jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifierDefault.java new file mode 100644 index 00000000..0c8bd528 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifierDefault.java @@ -0,0 +1,20 @@ +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/jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifierNickname.java b/jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifierNickname.java new file mode 100644 index 00000000..40c99838 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifierNickname.java @@ -0,0 +1,33 @@ +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. + * + *

+ * Thus, you might define a qualifier SocialSecurityNumber as follows: + *

+ * + * + * + @Documented + @TypeQualifierNickname @Pattern("[0-9]{3}-[0-9]{2}-[0-9]{4}") + @Retention(RetentionPolicy.RUNTIME) + public @interface SocialSecurityNumber { + } + + * + * + */ +@Documented +@Target(ElementType.ANNOTATION_TYPE) +public @interface TypeQualifierNickname { + +} diff --git a/jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifierValidator.java b/jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifierValidator.java new file mode 100644 index 00000000..80530112 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/meta/TypeQualifierValidator.java @@ -0,0 +1,21 @@ +package javax.annotation.meta; + +import java.lang.annotation.Annotation; + +import javax.annotation.Nonnull; + +public interface TypeQualifierValidator { + /** + * 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/jsr305/ri/src/main/java/javax/annotation/meta/When.java b/jsr305/ri/src/main/java/javax/annotation/meta/When.java new file mode 100644 index 00000000..ec8a1bc7 --- /dev/null +++ b/jsr305/ri/src/main/java/javax/annotation/meta/When.java @@ -0,0 +1,23 @@ +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; + +} -- cgit v1.2.3