diff options
Diffstat (limited to 'ri')
39 files changed, 966 insertions, 0 deletions
diff --git a/ri/.classpath b/ri/.classpath new file mode 100644 index 0000000..b0f1c60 --- /dev/null +++ b/ri/.classpath @@ -0,0 +1,6 @@ +<?xml version="1.0" encoding="UTF-8"?> +<classpath> + <classpathentry kind="src" path="src/main/java"/> + <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/> + <classpathentry kind="output" path="build/classes"/> +</classpath> diff --git a/ri/.project b/ri/.project new file mode 100644 index 0000000..4855f3b --- /dev/null +++ b/ri/.project @@ -0,0 +1,17 @@ +<?xml version="1.0" encoding="UTF-8"?> +<projectDescription> + <name>JSR305-ri</name> + <comment></comment> + <projects> + </projects> + <buildSpec> + <buildCommand> + <name>org.eclipse.jdt.core.javabuilder</name> + <arguments> + </arguments> + </buildCommand> + </buildSpec> + <natures> + <nature>org.eclipse.jdt.core.javanature</nature> + </natures> +</projectDescription> diff --git a/ri/.settings/org.eclipse.jdt.core.prefs b/ri/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..1bb83fc --- /dev/null +++ b/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/ri/.settings/org.eclipse.jdt.ui.prefs b/ri/.settings/org.eclipse.jdt.ui.prefs new file mode 100644 index 0000000..f1d942c --- /dev/null +++ b/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/ri/LICENSE b/ri/LICENSE new file mode 100644 index 0000000..6736681 --- /dev/null +++ b/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/ri/build.xml b/ri/build.xml new file mode 100644 index 0000000..ad07dec --- /dev/null +++ b/ri/build.xml @@ -0,0 +1,35 @@ + +<project name="JSR305-ri" default="build"> + + + <target name="build" depends="clean,classes,jars"/> + <target name="classes"> + <mkdir dir="build/classes"/> + <javac destdir="build/classes" source="1.5" target="1.5" debug="on"> + <src path="src/main/java"/> + <classpath> + <pathelement location="build/classes"/> + </classpath> + </javac> + </target> + + <target name="clean"> + <delete dir="build/classes"/> + </target> + <target name="jars" depends="classes"> + <delete quiet="true"> + <fileset dir="build/jsr305.jar"/> + <fileset dir="build/jsr305-src.jar"/> + </delete> + <jar destfile="build/jsr305.jar"> + <fileset dir="src/main/java"/> + <fileset dir="build/classes"/> + </jar> + <jar destfile="build/jsr305-src.jar"> + <fileset dir="src/main/java"/> + <fileset dir="src/main/resources"/> + </jar> + </target> +</project> + +<!-- vim:set ts=4: --> diff --git a/ri/nbproject/project.xml b/ri/nbproject/project.xml new file mode 100644 index 0000000..e4a7852 --- /dev/null +++ b/ri/nbproject/project.xml @@ -0,0 +1,78 @@ +<?xml version="1.0" encoding="UTF-8"?> +<project xmlns="http://www.netbeans.org/ns/project/1"> + <type>org.netbeans.modules.ant.freeform</type> + <configuration> + <general-data xmlns="http://www.netbeans.org/ns/freeform-project/1"> + <name>JSR305-ri</name> + </general-data> + <general-data xmlns="http://www.netbeans.org/ns/freeform-project/2"> + <!-- Do not use Project Properties customizer when editing this file manually. --> + <name>JSR305-ri</name> + <properties/> + <folders> + <source-folder> + <label>src/main/java</label> + <type>java</type> + <location>src/main/java</location> + <encoding>UTF-8</encoding> + </source-folder> + <source-folder> + <label>src/main/resources</label> + <type>java</type> + <location>src/main/resources</location> + <encoding>UTF-8</encoding> + </source-folder> + <source-folder> + <label>JSR305-ri</label> + <location>.</location> + <encoding>UTF-8</encoding> + </source-folder> + </folders> + <ide-actions> + <action name="build"> + <target>build</target> + </action> + <action name="clean"> + <target>clean</target> + </action> + <action name="rebuild"> + <target>clean</target> + <target>build</target> + </action> + </ide-actions> + <export> + <type>folder</type> + <location>build</location> + <build-target>build</build-target> + </export> + <view> + <items> + <source-folder style="packages"> + <label>src/main/java</label> + <location>src/main/java</location> + </source-folder> + <source-folder style="packages"> + <label>src/main/resources</label> + <location>src/main/resources</location> + </source-folder> + <source-file> + <location>build.xml</location> + </source-file> + </items> + <context-menu> + <ide-action name="build"/> + <ide-action name="rebuild"/> + <ide-action name="clean"/> + </context-menu> + </view> + </general-data> + <java-data xmlns="http://www.netbeans.org/ns/freeform-project-java/1"> + <compilation-unit> + <package-root>src/main/java</package-root> + <package-root>src/main/resources</package-root> + <built-to>build</built-to> + <source-level>1.5</source-level> + </compilation-unit> + </java-data> + </configuration> +</project> diff --git a/ri/pom.xml b/ri/pom.xml new file mode 100644 index 0000000..becde96 --- /dev/null +++ b/ri/pom.xml @@ -0,0 +1,20 @@ +<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.jsr-305</groupId>
+ <artifactId>jsr-305</artifactId>
+ <version>0.1-SNAPSHOT</version>
+ </parent>
+
+ <groupId>org.jsr-305</groupId>
+ <artifactId>ri</artifactId>
+ <packaging>jar</packaging>
+ <name>JSR 305 Implementation</name>
+ <version>0.1-SNAPSHOT</version>
+ <description>Implementation for JSR-305</description>
+
+
+</project>
diff --git a/ri/src/main/java/javax/annotation/CheckForNull.java b/ri/src/main/java/javax/annotation/CheckForNull.java new file mode 100644 index 0000000..6fe5200 --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/CheckForSigned.java b/ri/src/main/java/javax/annotation/CheckForSigned.java new file mode 100644 index 0000000..f3bc597 --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/CheckReturnValue.java b/ri/src/main/java/javax/annotation/CheckReturnValue.java new file mode 100644 index 0000000..370fa38 --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/Detainted.java b/ri/src/main/java/javax/annotation/Detainted.java new file mode 100644 index 0000000..d8620f2 --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/MatchesPattern.java b/ri/src/main/java/javax/annotation/MatchesPattern.java new file mode 100644 index 0000000..775d21c --- /dev/null +++ b/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<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 new file mode 100644 index 0000000..21d1793 --- /dev/null +++ b/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<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 new file mode 100644 index 0000000..4b7aad9 --- /dev/null +++ b/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<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 new file mode 100644 index 0000000..d31993d --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/OverridingMethodsMustInvokeSuper.java b/ri/src/main/java/javax/annotation/OverridingMethodsMustInvokeSuper.java new file mode 100644 index 0000000..4e3344e --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/ParametersAreNonnullByDefault.java b/ri/src/main/java/javax/annotation/ParametersAreNonnullByDefault.java new file mode 100644 index 0000000..6424b87 --- /dev/null +++ b/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: + * <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 new file mode 100644 index 0000000..01d4d80 --- /dev/null +++ b/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: + * <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 new file mode 100644 index 0000000..780782d --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/RegEx.java b/ri/src/main/java/javax/annotation/RegEx.java new file mode 100644 index 0000000..21697a7 --- /dev/null +++ b/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<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 new file mode 100644 index 0000000..2c2fa06 --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/Syntax.java b/ri/src/main/java/javax/annotation/Syntax.java new file mode 100644 index 0000000..5491093 --- /dev/null +++ b/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: + * <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 new file mode 100644 index 0000000..6715d70 --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/Untainted.java b/ri/src/main/java/javax/annotation/Untainted.java new file mode 100644 index 0000000..4a26a49 --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/WillClose.java b/ri/src/main/java/javax/annotation/WillClose.java new file mode 100644 index 0000000..9ea70cf --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/WillCloseWhenClosed.java b/ri/src/main/java/javax/annotation/WillCloseWhenClosed.java new file mode 100644 index 0000000..13c927d --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/WillNotClose.java b/ri/src/main/java/javax/annotation/WillNotClose.java new file mode 100644 index 0000000..d698b7c --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/concurrent/GuardedBy.java b/ri/src/main/java/javax/annotation/concurrent/GuardedBy.java new file mode 100644 index 0000000..9d6641d --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/concurrent/Immutable.java b/ri/src/main/java/javax/annotation/concurrent/Immutable.java new file mode 100644 index 0000000..03f1cb5 --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/concurrent/NotThreadSafe.java b/ri/src/main/java/javax/annotation/concurrent/NotThreadSafe.java new file mode 100644 index 0000000..d948142 --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/concurrent/ThreadSafe.java b/ri/src/main/java/javax/annotation/concurrent/ThreadSafe.java new file mode 100644 index 0000000..3c86128 --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/meta/Exclusive.java b/ri/src/main/java/javax/annotation/meta/Exclusive.java new file mode 100644 index 0000000..d018c33 --- /dev/null +++ b/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)}. + * + * <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 new file mode 100644 index 0000000..dc75f06 --- /dev/null +++ b/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)} + * + * <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 new file mode 100644 index 0000000..99f6312 --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/meta/TypeQualifierDefault.java b/ri/src/main/java/javax/annotation/meta/TypeQualifierDefault.java new file mode 100644 index 0000000..0c8bd52 --- /dev/null +++ b/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/ri/src/main/java/javax/annotation/meta/TypeQualifierNickname.java b/ri/src/main/java/javax/annotation/meta/TypeQualifierNickname.java new file mode 100644 index 0000000..40c9983 --- /dev/null +++ b/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. + * + * <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 new file mode 100644 index 0000000..8053011 --- /dev/null +++ b/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<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 new file mode 100644 index 0000000..ec8a1bc --- /dev/null +++ b/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; + +} |