diff options
Diffstat (limited to 'sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation')
29 files changed, 961 insertions, 0 deletions
diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/AllowsPassByReference.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/AllowsPassByReference.java new file mode 100644 index 0000000000..3350e9413b --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/AllowsPassByReference.java @@ -0,0 +1,39 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @AllowsPassByReference annotation is used on implementations + * of remotable interfaces to indicate that interactions with the + * service from a client within the same address space are allowed + * to use pass by reference data exchange semantics. + * + * The implementation promises that its by-value semantics will be + * maintained even if the parameters and return values are actually + * passed by-reference. This means that the service will not modify + * any operation input parameter or return value, even after returning + * from the operation. + * + * Either a whole class implementing a remotable service or an individual + * remotable service method implementation can be annotated using the + * {@literal @AllowsPassByReference} annotation. + * + * {@literal @AllowsPassByReference} has no attributes. + */ +@Target({TYPE, METHOD, FIELD, PARAMETER}) +@Retention(RUNTIME) +public @interface AllowsPassByReference { + + boolean value() default true; +} + diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/AsyncFault.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/AsyncFault.java new file mode 100644 index 0000000000..278e8ead57 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/AsyncFault.java @@ -0,0 +1,27 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @AsyncFault annotation is used to indicate the faults/exceptions which are returned by + * the asynchronous service method which it annotates. + * + */ +@Inherited +@Target({METHOD}) +@Retention(RUNTIME) +public @interface AsyncFault { + + Class<?>[] value() default {}; + +} + diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/AsyncInvocation.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/AsyncInvocation.java new file mode 100644 index 0000000000..c6a4147afd --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/AsyncInvocation.java @@ -0,0 +1,29 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import static org.oasisopen.sca.Constants.SCA_PREFIX; + +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @AsyncInvocation annotation is used to indicate that the operations of a Java interface + * uses the long-running request-response pattern as described in the SCA Assembly specification. + * + */ +@Inherited +@Target({TYPE, METHOD}) +@Retention(RUNTIME) +@Intent(AsyncInvocation.ASYNCINVOCATION) +public @interface AsyncInvocation { + String ASYNCINVOCATION = SCA_PREFIX + "asyncInvocation"; + + boolean value() default true; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Authentication.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Authentication.java new file mode 100644 index 0000000000..2b18388c8b --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Authentication.java @@ -0,0 +1,51 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import static org.oasisopen.sca.Constants.SCA_PREFIX; + +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Authentication annotation is used to indicate that the + * invocation requires authentication. + */ +@Inherited +@Target({TYPE, FIELD, METHOD, PARAMETER}) +@Retention(RUNTIME) +@Intent(Authentication.AUTHENTICATION) +public @interface Authentication { + /** + * The serialized QName of the authentication policy intent, + * for use with the SCA @Requires annotation. + */ + String AUTHENTICATION = SCA_PREFIX + "authentication"; + /** + * The serialized QName of the authentication.message policy + * intent, for use with the SCA @Requires annotation. + */ + String AUTHENTICATION_MESSAGE = AUTHENTICATION + ".message"; + /** + * The serialized QName of the authentication.transport policy + * intent, for use with the SCA @Requires annotation. + */ + String AUTHENTICATION_TRANSPORT = AUTHENTICATION + ".transport"; + + /** + * List of authentication qualifiers (such as "message" + * or "transport"). + * + * @return authentication qualifiers + */ + @Qualifier + String[] value() default ""; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Authorization.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Authorization.java new file mode 100644 index 0000000000..6893f6196a --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Authorization.java @@ -0,0 +1,32 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import static org.oasisopen.sca.Constants.SCA_PREFIX; + +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Authorization annotation is used to indicate that + * an authorization policy is required. + */ +@Inherited +@Target({TYPE, FIELD, METHOD, PARAMETER}) +@Retention(RUNTIME) +@Intent(Authorization.AUTHORIZATION) +public @interface Authorization { + /** + * The serialized QName of the authorization policy intent, + * for use with the SCA @Requires annotation. + */ + String AUTHORIZATION = SCA_PREFIX + "authorization"; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Callback.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Callback.java new file mode 100644 index 0000000000..cc68baaba9 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Callback.java @@ -0,0 +1,29 @@ +/* + * Copyright(C) OASIS(R) 2005, 2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Callback annotation is used to annotate a service interface + * with a callback interface, which takes the Java Class object of + * the callback interface as a parameter. + */ +@Target({TYPE, METHOD, FIELD}) +@Retention(RUNTIME) +public @interface Callback { + + /** + * The name of a Java class file containing the callback interface. + * + * @return the callback interface + */ + Class<?> value() default Void.class; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/ComponentName.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/ComponentName.java new file mode 100644 index 0000000000..5ea768a9ca --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/ComponentName.java @@ -0,0 +1,21 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @ComponentName annotation is used to denote a Java class field + * or setter method that is used to inject the component name. + */ +@Target({METHOD, FIELD}) +@Retention(RUNTIME) +public @interface ComponentName { + +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Confidentiality.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Confidentiality.java new file mode 100644 index 0000000000..df5c3c502e --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Confidentiality.java @@ -0,0 +1,50 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import static org.oasisopen.sca.Constants.SCA_PREFIX; + +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Confidentiality annotation is used to indicate that the + * invocation requires confidentiality. + */ +@Inherited +@Target({TYPE, FIELD, METHOD, PARAMETER}) +@Retention(RUNTIME) +@Intent(Confidentiality.CONFIDENTIALITY) +public @interface Confidentiality { + /** + * The serialized QName of the confidentiality policy intent, + * for use with the SCA @Requires annotation. + */ + String CONFIDENTIALITY = SCA_PREFIX + "confidentiality"; + /** + * The serialized QName of the confidentiality.message policy intent, + * for use with the SCA @Requires annotation. + */ + String CONFIDENTIALITY_MESSAGE = CONFIDENTIALITY + ".message"; + /** + * The serialized QName of the confidentiality.transport policy intent, + * for use with the SCA @Requires annotation. + */ + String CONFIDENTIALITY_TRANSPORT = CONFIDENTIALITY + ".transport"; + + /** + * List of confidentiality qualifiers (such as "message" or "transport"). + * + * @return confidentiality qualifiers + */ + @Qualifier + String[] value() default ""; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Constructor.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Constructor.java new file mode 100644 index 0000000000..0b068febd3 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Constructor.java @@ -0,0 +1,23 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.CONSTRUCTOR; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Constructor annotation is used to mark a particular + * constructor to use when instantiating a Java component + * implementation. If this constructor has parameters, each + * of these parameters MUST have either a @Property annotation + * or a @Reference annotation. + */ +@Target(CONSTRUCTOR) +@Retention(RUNTIME) +public @interface Constructor { + +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Context.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Context.java new file mode 100644 index 0000000000..90cf9b81ce --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Context.java @@ -0,0 +1,26 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Context annotation is used to denote a Java class field + * or a setter method that is used to inject a composite context + * for the component. The type of context to be injected is defined + * by the type of the Java class field or type of the setter method + * input argument; the type is either ComponentContext or RequestContext. + * + * The @Context annotation has no attributes. + */ +@Target({METHOD, FIELD}) +@Retention(RUNTIME) +public @interface Context { + +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Destroy.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Destroy.java new file mode 100644 index 0000000000..b4d3cd4369 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Destroy.java @@ -0,0 +1,22 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Destroy annotation is used to denote a single Java class method + * that will be called when the scope defined for the implementation + * class ends. The method MAY have any access modifier and MUST have a + * void return type and no arguments. + */ +@Target(METHOD) +@Retention(RUNTIME) +public @interface Destroy { + +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/EagerInit.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/EagerInit.java new file mode 100644 index 0000000000..e4cd03ea4b --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/EagerInit.java @@ -0,0 +1,22 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @EagerInit annotation is used to annotate the Java class of a + * COMPOSITE scoped implementation for eager initialization. When marked + * for eager initialization, the composite scoped instance is created + * when its containing component is started. + */ +@Target(TYPE) +@Retention(RUNTIME) +public @interface EagerInit { + +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Init.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Init.java new file mode 100644 index 0000000000..b4b420c175 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Init.java @@ -0,0 +1,22 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Init annotation is used to denote a single Java class method + * that is called when the scope defined for the implementation class + * starts. The method MAY have any access modifier and MUST have a + * void return type and no arguments. + */ +@Target(METHOD) +@Retention(RUNTIME) +public @interface Init { + +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Integrity.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Integrity.java new file mode 100644 index 0000000000..e9918533d9 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Integrity.java @@ -0,0 +1,51 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import static org.oasisopen.sca.Constants.SCA_PREFIX; + +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Integrity annotation is used to indicate that the invocation + * requires integrity (ie no tampering of the messages between client + * and service). + */ +@Inherited +@Target({TYPE, FIELD, METHOD, PARAMETER}) +@Retention(RUNTIME) +@Intent(Integrity.INTEGRITY) +public @interface Integrity { + /** + * The serialized QName of the integrity policy intent, + * for use with the SCA @Requires annotation. + */ + String INTEGRITY = SCA_PREFIX + "integrity"; + /** + * The serialized QName of the integrity.message policy intent, + * for use with the SCA @Requires annotation. + */ + String INTEGRITY_MESSAGE = INTEGRITY + ".message"; + /** + * The serialized QName of the integrity.transport policy intent, + * for use with the SCA @Requires annotation. + */ + String INTEGRITY_TRANSPORT = INTEGRITY + ".transport"; + + /** + * List of integrity qualifiers (such as "message" or "transport"). + * + * @return integrity qualifiers + */ + @Qualifier + String[] value() default ""; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Intent.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Intent.java new file mode 100644 index 0000000000..593ae56e67 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Intent.java @@ -0,0 +1,38 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.ANNOTATION_TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Intent annotation is used for the creation of new annotations + * for specific intents. It is not expected that the @Intent annotation + * will be used in application code. + */ +@Target({ANNOTATION_TYPE}) +@Retention(RUNTIME) +public @interface Intent { + /** + * The qualified name of the intent, in the form defined by + * javax.xml.namespace.QName.toString(). + * @return the qualified name of the intent + */ + String value() default ""; + + /** + * The XML namespace for the intent. + * @return the XML namespace for the intent + */ + String targetNamespace() default ""; + + /** + * The name of the intent within its namespace. + * @return name of the intent within its namespace + */ + String localPart() default ""; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/ManagedSharedTransaction.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/ManagedSharedTransaction.java new file mode 100644 index 0000000000..ba6b086756 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/ManagedSharedTransaction.java @@ -0,0 +1,32 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import static org.oasisopen.sca.Constants.SCA_PREFIX; + +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @ManagedSharedTransaction annotation is used to indicate that + * a distributed ACID transaction is required. + */ +@Inherited +@Target({TYPE, FIELD, METHOD, PARAMETER}) +@Retention(RUNTIME) +@Intent(ManagedSharedTransaction.MANAGEDSHAREDTRANSACTION) +public @interface ManagedSharedTransaction { + /** + * The serialized QName of the managedSharedTransaction policy intent, + * for use with the SCA @Requires annotation. + */ + String MANAGEDSHAREDTRANSACTION = SCA_PREFIX + "managedSharedTransaction"; +}
\ No newline at end of file diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/ManagedTransaction.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/ManagedTransaction.java new file mode 100644 index 0000000000..db28ea043c --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/ManagedTransaction.java @@ -0,0 +1,50 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import static org.oasisopen.sca.Constants.SCA_PREFIX; + +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @ManagedTransaction annotation is used to indicate the + * need for an ACID transaction environment. + */ +@Inherited +@Target({TYPE, FIELD, METHOD, PARAMETER}) +@Retention(RUNTIME) +@Intent(ManagedTransaction.MANAGEDTRANSACTION) +public @interface ManagedTransaction { + /** + * The serialized QName of the managedTransaction policy intent, + * for use with the SCA @Requires annotation. + */ + String MANAGEDTRANSACTION = SCA_PREFIX + "managedTransaction"; + /** + * The serialized QName of the managedTransaction.local policy intent, + * for use with the SCA @Requires annotation. + */ + String MANAGEDTRANSACTION_LOCAL = MANAGEDTRANSACTION + ".local"; + /** + * The serialized QName of the managedTransaction.global policy intent, + * for use with the SCA @Requires annotation. + */ + String MANAGEDTRANSACTION_GLOBAL = MANAGEDTRANSACTION + ".global"; + + /** + * List of managedTransaction qualifiers (such as "global" or "local"). + * + * @return managedTransaction qualifiers + */ + @Qualifier + String[] value() default ""; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/MutualAuthentication.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/MutualAuthentication.java new file mode 100644 index 0000000000..9a4bf86053 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/MutualAuthentication.java @@ -0,0 +1,32 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import static org.oasisopen.sca.Constants.SCA_PREFIX; + +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @MutualAuthentication annotation is used to indicate that + * a mutual authentication policy is needed. + */ +@Inherited +@Target({TYPE, FIELD, METHOD, PARAMETER}) +@Retention(RUNTIME) +@Intent(MutualAuthentication.MUTUALAUTHENTICATION) +public @interface MutualAuthentication { + /** + * The serialized QName of the mutualAuthentication policy intent, + * for use with the SCA @Requires annotation. + */ + String MUTUALAUTHENTICATION = SCA_PREFIX + "mutualAuthentication"; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/NoManagedTransaction.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/NoManagedTransaction.java new file mode 100644 index 0000000000..5c31fbc99f --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/NoManagedTransaction.java @@ -0,0 +1,32 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import static org.oasisopen.sca.Constants.SCA_PREFIX; + +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @NoManagedTransaction annotation is used to indicate that + * a non-transactional environment is needed. + */ +@Inherited +@Target({TYPE, FIELD, METHOD, PARAMETER}) +@Retention(RUNTIME) +@Intent(NoManagedTransaction.NOMANAGEDTRANSACTION) +public @interface NoManagedTransaction { + /** + * The serialized QName of the noManagedTransaction policy intent, + * for use with the SCA @Requires annotation. + */ + String NOMANAGEDTRANSACTION = SCA_PREFIX + "noManagedTransaction"; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/OneWay.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/OneWay.java new file mode 100644 index 0000000000..1fbf83458e --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/OneWay.java @@ -0,0 +1,23 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @OneWay annotation is used on a Java interface or class method + * to indicate that invocations will be dispatched in a non-blocking + * fashion as described in the section on Asynchronous Programming. + * + * The @OneWay annotation has no attributes. + */ +@Target(METHOD) +@Retention(RUNTIME) +public @interface OneWay { + +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/PolicySets.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/PolicySets.java new file mode 100644 index 0000000000..2f9fe9a098 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/PolicySets.java @@ -0,0 +1,30 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @PolicySets annotation is used to attach one or more + * SCA Policy Sets to a Java implementation class or to one + * of its subelements. + */ +@Target({TYPE, FIELD, METHOD, PARAMETER}) +@Retention(RUNTIME) +public @interface PolicySets { + /** + * Returns the policy sets to be applied. + * + * @return the policy sets to be applied + */ + String[] value() default ""; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Property.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Property.java new file mode 100644 index 0000000000..6a8c8a0e04 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Property.java @@ -0,0 +1,58 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Property annotation is used to denote a Java class field, + * a setter method, or a constructor parameter that is used to + * inject an SCA property value. The type of the property injected, + * which can be a simple Java type or a complex Java type, is defined + * by the type of the Java class field or the type of the input + * parameter of the setter method or constructor. + * + * The @Property annotation can be used on fields, on setter methods + * or on a constructor method parameter. However, the @Property annotation + * MUST NOT be used on a class field that is declared as final. + * + * Properties can also be injected via setter methods even when + * the @Property annotation is not present. However, the @Property + * annotation must be used in order to inject a property onto a + * non-public field. In the case where there is no @Property + * annotation, the name of the property is the same as the name of the + * field or setter. + * + * Where there is both a setter method and a field for a property, the + * setter method is used. + */ +@Target({METHOD, FIELD, PARAMETER}) +@Retention(RUNTIME) +public @interface Property { + + /** + * The name of the property. For a field annotation, the default is + * the name of the field of the Java class. For a setter method annotation, + * the default is the JavaBeans property name corresponding to the setter + * method name. For a constructor parameter annotation, there is no + * default and the name attribute MUST be present. + * + * @return the name of the property + */ + String name() default ""; + + /** + * Specifies whether injection is required, defaults to true. For a + * constructor parameter annotation, this attribute MUST have the value true. + * + * @return true if injection is required + */ + boolean required() default true; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Qualifier.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Qualifier.java new file mode 100644 index 0000000000..dd002d27c7 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Qualifier.java @@ -0,0 +1,24 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Qualifier annotation is applied to an attribute of a + * specific intent annotation definition, defined using the @Intent + * annotation, to indicate that the attribute provides qualifiers + * for the intent. The @Qualifier annotation MUST be used in a + * specific intent annotation definition where the intent has qualifiers. + */ +@Target(METHOD) +@Retention(RUNTIME) +public @interface Qualifier { + +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Reference.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Reference.java new file mode 100644 index 0000000000..4dbf9412fc --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Reference.java @@ -0,0 +1,56 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Reference annotation type is used to annotate a Java class field, + * a setter method, or a constructor parameter that is used to inject a + * service that resolves the reference. The interface of the service + * injected is defined by the type of the Java class field or the type + * of the input parameter of the setter method or constructor. + * + * The @Reference annotation MUST NOT be used on a class field that is + * declared as final. + * + * References can also be injected via setter methods even when + * the @Reference annotation is not present. However, the @Reference + * annotation must be used in order to inject a reference onto a non-public + * field. In the case where there is no @Reference annotation, the name + * of the reference is the same as the name of the field or setter. + * + * Where there is both a setter method and a field for a reference, the + * setter method is used. + */ +@Target({METHOD, FIELD, PARAMETER}) +@Retention(RUNTIME) +public @interface Reference { + + /** + * The name of the reference. For a field annotation, the default is + * the name of the field of the Java class. For a setter method + * annotation, the default is the JavaBeans property name corresponding + * to the setter method name. For a constructor parameter annotation, + * there is no default and the name attribute MUST be present. + * + * @return the name of the reference + */ + String name() default ""; + + /** + * Specifies whether injection of service or services is required. + * Defaults to true. For a constructor parameter annotation, this + * attribute MUST have the value true. + * + * @return true if injection is required + */ + boolean required() default true; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Remotable.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Remotable.java new file mode 100644 index 0000000000..e7ddbace7d --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Remotable.java @@ -0,0 +1,26 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Remotable annotation is used to specify a Java service + * interface as remotable. A remotable service can be published + * externally as a service and must be translatable into a WSDL portType. + * + * The @Remotable annotation has no attributes. + */ +@Target({TYPE,METHOD,FIELD,PARAMETER}) +@Retention(RUNTIME) +public @interface Remotable { + +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Requires.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Requires.java new file mode 100644 index 0000000000..b5d485e016 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Requires.java @@ -0,0 +1,32 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Requires annotation supports general purpose intents + * specified as strings. Users can also define specific intent + * annotations using the @Intent annotation. + */ +@Inherited +@Retention(RUNTIME) +@Target({TYPE, METHOD, FIELD, PARAMETER}) +public @interface Requires { + /** + * Returns the attached intents. + * + * @return the attached intents + */ + String[] value() default ""; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Scope.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Scope.java new file mode 100644 index 0000000000..087f589168 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Scope.java @@ -0,0 +1,36 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Scope annotation MUST only be used on a service's implementation + * class. It is an error to use this annotation on an interface. + */ +@Target(TYPE) +@Retention(RUNTIME) +public @interface Scope { + + /** + * The name of the scope. + * + * For 'STATELESS' implementations, a different implementation + * instance can be used to service each request. Implementation + * instances can be newly created or be drawn from a pool of instances. + * + * SCA defines the following scope names, but others can be defined + * by particular Java-based implementation types: + * STATELESS + * COMPOSITE + * The default value is STATELESS. + * + * @return the name of the scope + */ + String value() default "STATELESS"; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Service.java b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Service.java new file mode 100644 index 0000000000..5c2600ff12 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/Service.java @@ -0,0 +1,45 @@ +/* + * Copyright(C) OASIS(R) 2005,2010. All Rights Reserved. + * OASIS trademark, IPR and other policies apply. + */ +package org.oasisopen.sca.annotation; + +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * The @Service annotation is used on a component implementation + * class to specify the SCA services offered by the implementation. + * + * The class need not be declared as implementing all of the + * interfaces implied by the services, but all methods of the service + * interfaces must be present. + * + * A class used as the implementation of a service is not required + * to have a @Service annotation. If a class has no @Service annotation, + * then the rules determining which services are offered and what + * interfaces those services have are determined by the specific + * implementation type. + */ +@Target(TYPE) +@Retention(RUNTIME) +public @interface Service { + + /** + * The value is an array of interface or class objects that should be + * exposed as services by this component. + * + * @return the services of this component + */ + Class<?>[] value(); + + /** + * The value is an array of strings which are used as the service names + * for each of the interfaces declared in the value array. + * + * @return the service names + */ + String[] names() default {}; +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/package.html b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/package.html new file mode 100644 index 0000000000..b29df75b5f --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/sca-api/src/main/java/org/oasisopen/sca/annotation/package.html @@ -0,0 +1,3 @@ +<body>
+Provides SCA common annotation definitions for Java.
+</body>
|