Skip to main content

[jsr236-spec commits] [concurrency-ee-spec~source-code-repository:31] [maven-release-plugin] copy for tag javax.enterprise.concurrent-api-1.0-

  • From:
  • To:
  • Subject: [jsr236-spec commits] [concurrency-ee-spec~source-code-repository:31] [maven-release-plugin] copy for tag javax.enterprise.concurrent-api-1.0-
  • Date: Wed, 20 Feb 2013 01:52:03 +0000

Project:    concurrency-ee-spec
Repository: source-code-repository
Revision:   31
Author:     hzhang_jn
Date:       2013-02-20 01:52:02 UTC
Link:       

Log Message:
------------
[maven-release-plugin]  copy for tag javax.enterprise.concurrent-api-1.0-b03


Revisions:
----------
31


Added Paths:
------------
tags/javax.enterprise.concurrent-api-1.0-b03


Diffs:
------
Index: 
tags/javax.enterprise.concurrent-api-1.0-b03/src/test/java/javax/enterprise/concurrent/ManagedExecutorsTest.java
===================================================================
--- 
tags/javax.enterprise.concurrent-api-1.0-b03/src/test/java/javax/enterprise/concurrent/ManagedExecutorsTest.java
    (revision 0)
+++ 
tags/javax.enterprise.concurrent-api-1.0-b03/src/test/java/javax/enterprise/concurrent/ManagedExecutorsTest.java
    (revision 31)
@@ -0,0 +1,350 @@
+/**
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright (c) 2010-2012 Oracle and/or its affiliates. All rights reserved.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common Development
+ * and Distribution License("CDDL") (collectively, the "License").  You
+ * may not use this file except in compliance with the License.  You can
+ * obtain a copy of the License at
+ * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
+ * or packager/legal/LICENSE.txt.  See the License for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing the software, include this License Header Notice in each
+ * file and include the License file at packager/legal/LICENSE.txt.
+ *
+ * GPL Classpath Exception:
+ * Oracle designates this particular file as subject to the "Classpath"
+ * exception as provided by Oracle in the GPL Version 2 section of the 
License
+ * file that accompanied this code.
+ *
+ * Modifications:
+ * If applicable, add the following below the License Header, with the fields
+ * enclosed by brackets [] replaced by your own identifying information:
+ * "Portions Copyright [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ * If you wish your version of this file to be governed by only the CDDL or
+ * only the GPL Version 2, indicate your decision by adding "[Contributor]
+ * elects to include this software in this distribution under the [CDDL or 
GPL
+ * Version 2] license."  If you don't indicate a single choice of license, a
+ * recipient has the option to distribute your version of this file under
+ * either the CDDL, the GPL Version 2 or to extend the choice of license to
+ * its licensees as provided above.  However, if you add GPL Version 2 code
+ * and therefore, elected the GPL Version 2 license, then the option applies
+ * only if the new code is made subject to such option by the copyright
+ * holder.
+ */
+package javax.enterprise.concurrent;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import static org.junit.Assert.*;
+import org.junit.Test;
+
+public class ManagedExecutorsTest {
+    
+    /**
+     * Basic test for ManagedExecutors.managedTask(Runnable, 
ManagedTaskListener)
+     */
+    @Test
+    public void testManagedTask_Runnable_ManagedTaskListener() {
+        RunnableImpl task = new RunnableImpl();
+        ManagedTaskListenerImpl taskListener = new ManagedTaskListenerImpl();
+        
+        Runnable wrapped = ManagedExecutors.managedTask(task, taskListener);
+        ManagedTask managedTask = (ManagedTask) wrapped;
+        assertTrue(taskListener == managedTask.getManagedTaskListener());
+
+        wrapped.run();
+        assertTrue(task.ran);
+}
+
+    /**
+     * Basic test for ManagedExecutors.managedTask(Runnable, Map, 
ManagedTaskListener)
+     */
+    @Test
+    public void 
testManagedTask_Runnable_executionProperties_ManagedTaskListener() {
+        RunnableImpl task = new RunnableImpl();
+        ManagedTaskListenerImpl taskListener = new ManagedTaskListenerImpl();
+        Map<String, String> executionProperties = new HashMap<>();
+        final String TASK_NAME = "task1";
+        executionProperties.put(ManagedTask.IDENTITY_NAME, TASK_NAME);
+        executionProperties.put(ManagedTask.LONGRUNNING_HINT, "true");
+        
+        Runnable wrapped = ManagedExecutors.managedTask(task, 
executionProperties, taskListener);
+        ManagedTask managedTask = (ManagedTask) wrapped;
+        assertTrue(taskListener == managedTask.getManagedTaskListener());
+        assertEquals("true", 
managedTask.getExecutionProperties().get(ManagedTask.LONGRUNNING_HINT));
+        assertEquals(TASK_NAME, 
managedTask.getExecutionProperties().get(ManagedTask.IDENTITY_NAME));
+        
+        wrapped.run();
+        assertTrue(task.ran);
+    }
+
+    /**
+     * Test for ManagedExecutors.managedTask(Runnable, Map, 
ManagedTaskListener)
+     * but task already implements ManagedTask, and both executionProerties 
and
+     * taskListeners were passed to managedTask().
+     */
+    @Test
+    public void testManagedTask_Runnable_ManagedTask() {
+        ManagedTaskListenerImpl TASK_LISTENER = new 
ManagedTaskListenerImpl();
+        Map<String, String> EXEC_PROPERTIES = new HashMap<>();
+        EXEC_PROPERTIES.put("custom", "true");
+        EXEC_PROPERTIES.put(ManagedTask.LONGRUNNING_HINT, "false");
+        final String TASK_DESCRIPTION = "task1 description";
+        ManagedTaskRunnableImpl task = new 
ManagedTaskRunnableImpl(TASK_DESCRIPTION, EXEC_PROPERTIES, TASK_LISTENER);
+
+        ManagedTaskListenerImpl taskListener = new ManagedTaskListenerImpl();
+        Map<String, String> executionProperties = new HashMap<>();
+        final String TASK_NAME = "task1";
+        executionProperties.put(ManagedTask.IDENTITY_NAME, TASK_NAME);
+        executionProperties.put(ManagedTask.LONGRUNNING_HINT, "true");
+        
+        Runnable wrapped = ManagedExecutors.managedTask(task, 
executionProperties, taskListener);
+        ManagedTask managedTask = (ManagedTask) wrapped;
+        assertTrue(taskListener == managedTask.getManagedTaskListener());
+        assertEquals("true", 
managedTask.getExecutionProperties().get(ManagedTask.LONGRUNNING_HINT));
+        assertEquals(TASK_NAME, 
managedTask.getExecutionProperties().get(ManagedTask.IDENTITY_NAME));
+        assertEquals("true", 
managedTask.getExecutionProperties().get("custom"));
+    }
+
+    /**
+     * Test for ManagedExecutors.managedTask(Runnable, Map, 
ManagedTaskListener)
+     * but task already implements ManagedTask, and both executionProerties 
and
+     * taskListeners passed to managedTask() were null.
+     */
+    @Test
+    public void testManagedTask_Runnable_ManagedTask_null_args() {
+        ManagedTaskListenerImpl TASK_LISTENER = new 
ManagedTaskListenerImpl();
+        Map<String, String> EXEC_PROPERTIES = new HashMap<>();
+        EXEC_PROPERTIES.put("custom", "true");
+        final String TASK_DESCRIPTION = "task1 description";
+        ManagedTaskRunnableImpl task = new 
ManagedTaskRunnableImpl(TASK_DESCRIPTION, EXEC_PROPERTIES, TASK_LISTENER);
+        
+        Runnable wrapped = ManagedExecutors.managedTask(task, null, null);
+        ManagedTask managedTask = (ManagedTask) wrapped;
+        assertTrue(TASK_LISTENER == managedTask.getManagedTaskListener());
+        assertEquals("true", 
managedTask.getExecutionProperties().get("custom"));
+    }
+
+    /**
+     * Basic test for ManagedExecutors.managedTask(Callable, 
ManagedTaskListener)
+     */
+    @Test
+    public void testManagedTask_Callable_ManagedTaskListener() throws 
Exception {
+        final String RESULT = "result";
+        CallableImpl<String> task = new CallableImpl<>(RESULT);
+        ManagedTaskListenerImpl taskListener = new ManagedTaskListenerImpl();
+        
+        Callable<String> wrapped = ManagedExecutors.managedTask(task, 
taskListener);
+        ManagedTask managedTask = (ManagedTask) wrapped;
+        assertTrue(taskListener == managedTask.getManagedTaskListener());
+
+        assertEquals(RESULT, wrapped.call());
+    }
+
+    /**
+     * Basic test for ManagedExecutors.managedTask(Callable, Map, 
ManagedTaskListener)
+     */
+    @Test
+    public void 
testManagedTask_Callable_executionProperties_ManagedTaskListener() throws 
Exception {
+        final String RESULT = "result";
+        CallableImpl<String> task = new CallableImpl<>(RESULT);
+        ManagedTaskListenerImpl taskListener = new ManagedTaskListenerImpl();
+        Map<String, String> executionProperties = new HashMap<>();
+        final String TASK_NAME = "task1";
+        executionProperties.put(ManagedTask.IDENTITY_NAME, TASK_NAME);
+        executionProperties.put(ManagedTask.LONGRUNNING_HINT, "true");
+        
+        Callable<String> wrapped = ManagedExecutors.managedTask(task, 
executionProperties, taskListener);
+        ManagedTask managedTask = (ManagedTask) wrapped;
+        assertTrue(taskListener == managedTask.getManagedTaskListener());
+        assertEquals("true", 
managedTask.getExecutionProperties().get(ManagedTask.LONGRUNNING_HINT));
+        assertEquals(TASK_NAME, 
managedTask.getExecutionProperties().get(ManagedTask.IDENTITY_NAME));
+        
+        assertEquals(RESULT, wrapped.call());
+    }
+
+    /**
+     * Test for ManagedExecutors.managedTask(Callable, Map, 
ManagedTaskListener)
+     * but task already implements ManagedTask, and both executionProerties 
and
+     * taskListeners were passed to managedTask().
+     */
+    @Test
+    public void testManagedTask_Callable_ManagedTask() {
+        final String RESULT = "result";
+        ManagedTaskListenerImpl TASK_LISTENER = new 
ManagedTaskListenerImpl();
+        Map EXEC_PROPERTIES = new HashMap<>();
+        EXEC_PROPERTIES.put("custom", "true");
+        EXEC_PROPERTIES.put(ManagedTask.LONGRUNNING_HINT, "false");
+        final String TASK_DESCRIPTION = "task1 description";
+        ManagedTaskCallableImpl<String> task = new 
ManagedTaskCallableImpl(RESULT, TASK_DESCRIPTION, EXEC_PROPERTIES, 
TASK_LISTENER);
+
+        ManagedTaskListenerImpl taskListener = new ManagedTaskListenerImpl();
+        Map<String, String> executionProperties = new HashMap<>();
+        final String TASK_NAME = "task1";
+        executionProperties.put(ManagedTask.IDENTITY_NAME, TASK_NAME);
+        executionProperties.put(ManagedTask.LONGRUNNING_HINT, "true");
+        
+        Callable<String> wrapped = ManagedExecutors.managedTask(task, 
executionProperties, taskListener);
+        ManagedTask managedTask = (ManagedTask) wrapped;
+        assertTrue(taskListener == managedTask.getManagedTaskListener());
+        assertEquals("true", 
managedTask.getExecutionProperties().get(ManagedTask.LONGRUNNING_HINT));
+        assertEquals(TASK_NAME, 
managedTask.getExecutionProperties().get(ManagedTask.IDENTITY_NAME));
+        assertEquals("true", 
managedTask.getExecutionProperties().get("custom"));
+    }
+
+    /**
+     * Test for ManagedExecutors.managedTask(Callable, Map, 
ManagedTaskListener)
+     * but task already implements ManagedTask, and both executionProerties 
and
+     * taskListeners passed to managedTask() were null.
+     */
+    @Test
+    public void testManagedTask_Callable_ManagedTask_null_args() {
+        final String RESULT = "result";
+        ManagedTaskListenerImpl TASK_LISTENER = new 
ManagedTaskListenerImpl();
+        Map EXEC_PROPERTIES = new HashMap<>();
+        EXEC_PROPERTIES.put("custom", "true");
+        final String TASK_DESCRIPTION = "task1 description";
+        ManagedTaskCallableImpl<String> task = new 
ManagedTaskCallableImpl(RESULT, TASK_DESCRIPTION, EXEC_PROPERTIES, 
TASK_LISTENER);
+        
+        Callable wrapped = ManagedExecutors.managedTask(task, null, null);
+        ManagedTask managedTask = (ManagedTask) wrapped;
+        assertTrue(TASK_LISTENER == managedTask.getManagedTaskListener());
+        assertEquals("true", 
managedTask.getExecutionProperties().get("custom"));
+    }
+
+    @Test (expected = IllegalArgumentException.class)
+    public void testManagedTask_null_Runnable_task() {
+        Runnable task = null;
+        ManagedExecutors.managedTask(task, new ManagedTaskListenerImpl());
+    }
+
+    @Test (expected = IllegalArgumentException.class)
+    public void testManagedTask_null_Runnable_task_2() {
+        Runnable task = null;
+        ManagedExecutors.managedTask(task, new HashMap<String, String>(), 
new ManagedTaskListenerImpl());
+    }
+
+    @Test (expected = IllegalArgumentException.class)
+    public void testManagedTask_null_Callable_task() {
+        Callable<?> task = null;
+        ManagedExecutors.managedTask(task, new ManagedTaskListenerImpl());
+    }
+
+    @Test (expected = IllegalArgumentException.class)
+    public void testManagedTask_null_Callable_task_2() {
+        Callable<?> task = null;
+        ManagedExecutors.managedTask(task, new HashMap<String, String>(), 
new ManagedTaskListenerImpl());
+    }
+
+    static class RunnableImpl implements Runnable {
+
+        boolean ran = false;
+        
+        @Override
+        public void run() {
+            ran = true;
+        }
+        
+    }
+    
+    static class ManagedTaskRunnableImpl extends RunnableImpl implements 
ManagedTask {
+
+        final String description;
+        final ManagedTaskListener taskListener;
+        final Map<String, String> executionProperties;
+
+        public ManagedTaskRunnableImpl(String description, Map<String, 
String> executionProperties, ManagedTaskListener taskListener) {
+            this.description = description;
+            this.taskListener = taskListener;
+            this.executionProperties = executionProperties;
+        }
+        
+        public String getIdentityDescription(Locale locale) {
+            return description;
+        }
+
+        @Override
+        public ManagedTaskListener getManagedTaskListener() {
+            return taskListener;
+        }
+
+        @Override
+        public Map<String, String> getExecutionProperties() {
+            return executionProperties;
+        }
+        
+    }
+
+    static class CallableImpl<V> implements Callable<V> {
+
+        V result;
+
+        public CallableImpl(V result) {
+            this.result = result;
+        }
+        
+        @Override
+        public V call() throws Exception {
+            return result;
+        }
+        
+    }
+    
+    static class ManagedTaskCallableImpl<V> extends CallableImpl<V> 
implements ManagedTask {
+
+        final String description;
+        final ManagedTaskListener taskListener;
+        final Map<String, String> executionProperties;
+
+        public ManagedTaskCallableImpl(V result, String description, 
Map<String, String> executionProperties, ManagedTaskListener taskListener) {
+            super(result);
+            this.description = description;
+            this.taskListener = taskListener;
+            this.executionProperties = executionProperties;
+        }
+        
+        public String getIdentityDescription(Locale locale) {
+            return description;
+        }
+
+        @Override
+        public ManagedTaskListener getManagedTaskListener() {
+            return taskListener;
+        }
+
+        @Override
+        public Map<String, String> getExecutionProperties() {
+            return executionProperties;
+        }
+        
+    }
+
+    static class ManagedTaskListenerImpl implements ManagedTaskListener {
+
+        @Override
+        public void taskSubmitted(Future<?> future, ManagedExecutorService 
executor, Object task) {
+        }
+
+        @Override
+        public void taskAborted(Future<?> future, ManagedExecutorService 
executor, Object task, Throwable exception) {
+        }
+
+        @Override
+        public void taskDone(Future<?> future, ManagedExecutorService 
executor, Object task, Throwable exception) {
+        }
+
+        @Override
+        public void taskStarting(Future<?> future, ManagedExecutorService 
executor, Object task) {
+        }
+        
+    }
+}
Index: 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/AbortedException.java
===================================================================
--- 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/AbortedException.java
        (revision 0)
+++ 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/AbortedException.java
        (revision 31)
@@ -0,0 +1,104 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright (c) 2010-2011 Oracle and/or its affiliates. All rights reserved.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common Development
+ * and Distribution License("CDDL") (collectively, the "License").  You
+ * may not use this file except in compliance with the License.  You can
+ * obtain a copy of the License at
+ * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
+ * or packager/legal/LICENSE.txt.  See the License for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing the software, include this License Header Notice in each
+ * file and include the License file at packager/legal/LICENSE.txt.
+ *
+ * GPL Classpath Exception:
+ * Oracle designates this particular file as subject to the "Classpath"
+ * exception as provided by Oracle in the GPL Version 2 section of the 
License
+ * file that accompanied this code.
+ *
+ * Modifications:
+ * If applicable, add the following below the License Header, with the fields
+ * enclosed by brackets [] replaced by your own identifying information:
+ * "Portions Copyright [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ * If you wish your version of this file to be governed by only the CDDL or
+ * only the GPL Version 2, indicate your decision by adding "[Contributor]
+ * elects to include this software in this distribution under the [CDDL or 
GPL
+ * Version 2] license."  If you don't indicate a single choice of license, a
+ * recipient has the option to distribute your version of this file under
+ * either the CDDL, the GPL Version 2 or to extend the choice of license to
+ * its licensees as provided above.  However, if you add GPL Version 2 code
+ * and therefore, elected the GPL Version 2 license, then the option applies
+ * only if the new code is made subject to such option by the copyright
+ * holder.
+ */
+package javax.enterprise.concurrent;
+
+import java.util.concurrent.ExecutionException;
+
+/**
+ * Exception indicating that the result of a task cannot be retrieved 
+ * because the task failed to run for some reason other than being cancelled.
+ * <p>
+ * Use the {@link Throwable#getCause()} method to determine why the task was 
aborted.
+ *
+ * @since 1.0
+ */
+public class AbortedException extends ExecutionException implements 
java.io.Serializable {
+
+  private static final long serialVersionUID = -8248124070283019190L;
+
+/**
+   * Constructs an AbortedException with <code>null</code> as its detail 
message. 
+   * 
+   * The cause is not initialized, and may subsequently be initialized by a 
call to 
+   * {@link Throwable#initCause(java.lang.Throwable)}.
+   */
+  public AbortedException() {
+       super();
+  }
+
+  /**
+   * Constructs an AbortedException exception with the specified detail 
message and cause.
+   * <p>
+   * Note that the detail message associated with cause is not automatically 
incorporated 
+   * in this exception's detail message.
+   *  
+   * @param message the detail message (which is saved for later retrieval 
by the {@link Throwable#getMessage()}
+   *                method).
+   * @param cause the cause (which is saved for later retrieval by the 
{@link Throwable#getCause()} method). 
+   *              (A null value is permitted, and indicates that the cause 
is nonexistent or unknown.)
+   */
+  public AbortedException(String message, Throwable cause) {
+       super(message, cause);  
+  }
+  
+  /**
+   * Constructs an AbortedException exception with the specified detail 
message.
+   * <p>
+   * The cause is not initialized, and may subsequently be initialized by a 
call to 
+   * {@link Throwable#initCause(java.lang.Throwable)}.
+   *  
+   * @param message the detail message (which is saved for later retrieval 
by the {@link Throwable#getMessage()}
+   *                method).
+   */
+  public AbortedException(String message) {
+       super(message);  
+  }
+  
+  /**
+   * Constructs an AbortedException exception with the specified cause and a 
detail message of 
+   * (cause==null ? null : cause.toString()) (which typically contains the 
class and detail message of cause).
+   * 
+   * @param cause the cause (which is saved for later retrieval by the 
{@link Throwable#getCause()} method). 
+   *              (A null value is permitted, and indicates that the cause 
is nonexistent or unknown.)
+   */
+  public AbortedException(Throwable cause) {
+       super(cause);  
+  }
+}
Index: 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/ExecutorNotAvailableException.java
===================================================================
--- 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/ExecutorNotAvailableException.java
   (revision 0)
+++ 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/ExecutorNotAvailableException.java
   (revision 31)
@@ -0,0 +1,120 @@
+/**
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright (c) 2010-2011 Oracle and/or its affiliates. All rights reserved.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common Development
+ * and Distribution License("CDDL") (collectively, the "License").  You
+ * may not use this file except in compliance with the License.  You can
+ * obtain a copy of the License at
+ * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
+ * or packager/legal/LICENSE.txt.  See the License for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing the software, include this License Header Notice in each
+ * file and include the License file at packager/legal/LICENSE.txt.
+ *
+ * GPL Classpath Exception:
+ * Oracle designates this particular file as subject to the "Classpath"
+ * exception as provided by Oracle in the GPL Version 2 section of the 
License
+ * file that accompanied this code.
+ *
+ * Modifications:
+ * If applicable, add the following below the License Header, with the fields
+ * enclosed by brackets [] replaced by your own identifying information:
+ * "Portions Copyright [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ * If you wish your version of this file to be governed by only the CDDL or
+ * only the GPL Version 2, indicate your decision by adding "[Contributor]
+ * elects to include this software in this distribution under the [CDDL or 
GPL
+ * Version 2] license."  If you don't indicate a single choice of license, a
+ * recipient has the option to distribute your version of this file under
+ * either the CDDL, the GPL Version 2 or to extend the choice of license to
+ * its licensees as provided above.  However, if you add GPL Version 2 code
+ * and therefore, elected the GPL Version 2 license, then the option applies
+ * only if the new code is made subject to such option by the copyright
+ * holder.
+ */
+package javax.enterprise.concurrent;
+
+import java.io.Serializable;
+import java.util.concurrent.ExecutionException;
+
+/**
+ * Exception indicating that the result of a value-producing task 
+ * cannot be retrieved because the remote executor that the task 
+ * is running on is no longer available.
+ * <p>
+ * Use the {@link Throwable#getCause()} method to determine why 
+ * the executor is no longer available.
+ * 
+ * @since 1.0
+ */
+public class ExecutorNotAvailableException extends ExecutionException
+    implements Serializable {
+
+  /**
+   * 
+   */
+  private static final long serialVersionUID = -5383397667254815571L;
+
+  /**
+   * Constructs an ExecutorNotAvailableException with null as its detail 
+   * message. The cause is not initialized, and may subsequently be 
+   * initialized by a call to {@link 
Throwable#initCause(java.lang.Throwable)}. 
+   */
+  public ExecutorNotAvailableException() {
+       super();
+  }
+
+  /**
+   * Constructs an ExecutorNotAvailableException exception with the 
specified 
+   * detail message.
+   * <p>
+   * The cause is not initialized, and may subsequently be initialized by a 
+   * call to {@link Throwable#initCause(java.lang.Throwable)}.
+   * 
+   * @param message the detail message (which is saved for later retrieval 
+   *                by the {@link Throwable#getMessage()} method).
+
+
+   */
+  public ExecutorNotAvailableException(String message) {
+       super(message);
+  }
+
+  /**
+   * Constructs an ExecutorNotAvailableException exception with the 
specified 
+   * detail message and cause.
+   * <p>
+   * Note that the detail message associated with cause is not automatically 
+   * incorporated in this exception's detail message.
+   *  
+   * @param message the detail message (which is saved for later retrieval 
+   *                by the {@link Throwable#getMessage()} method).
+   * @param cause the cause (which is saved for later retrieval by the 
+   *              {@link Throwable#getCause()} method). 
+   *              (A null value is permitted, and indicates that the cause 
+   *              is nonexistent or unknown.)
+   */
+  public ExecutorNotAvailableException(String message, Throwable cause) {
+       super(message, cause);
+  }
+
+  /**
+   * Constructs an ExecutorNotAvailableException exception with the 
specified 
+   * cause and a detail message of (cause==null ? null : cause.toString()) 
+   * (which typically contains the class and detail message of cause).
+   *  
+   * @param cause the cause (which is saved for later retrieval by the 
+   *              {@link Throwable#getCause()} method). 
+   *              (A null value is permitted, and indicates that the cause 
+   *              is nonexistent or unknown.)
+   */
+  public ExecutorNotAvailableException(Throwable cause) {
+       super(cause);
+  }
+
+}
Index: 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/ManagedTask.java
===================================================================
--- 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/ManagedTask.java
     (revision 0)
+++ 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/ManagedTask.java
     (revision 31)
@@ -0,0 +1,144 @@
+/**
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright (c) 2010-2011 Oracle and/or its affiliates. All rights reserved.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common Development
+ * and Distribution License("CDDL") (collectively, the "License").  You
+ * may not use this file except in compliance with the License.  You can
+ * obtain a copy of the License at
+ * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
+ * or packager/legal/LICENSE.txt.  See the License for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing the software, include this License Header Notice in each
+ * file and include the License file at packager/legal/LICENSE.txt.
+ *
+ * GPL Classpath Exception:
+ * Oracle designates this particular file as subject to the "Classpath"
+ * exception as provided by Oracle in the GPL Version 2 section of the 
License
+ * file that accompanied this code.
+ *
+ * Modifications:
+ * If applicable, add the following below the License Header, with the fields
+ * enclosed by brackets [] replaced by your own identifying information:
+ * "Portions Copyright [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ * If you wish your version of this file to be governed by only the CDDL or
+ * only the GPL Version 2, indicate your decision by adding "[Contributor]
+ * elects to include this software in this distribution under the [CDDL or 
GPL
+ * Version 2] license."  If you don't indicate a single choice of license, a
+ * recipient has the option to distribute your version of this file under
+ * either the CDDL, the GPL Version 2 or to extend the choice of license to
+ * its licensees as provided above.  However, if you add GPL Version 2 code
+ * and therefore, elected the GPL Version 2 license, then the option applies
+ * only if the new code is made subject to such option by the copyright
+ * holder.
+ */
+package javax.enterprise.concurrent;
+
+import java.util.Map;
+
+/**
+ * A task submitted to an {@link ManagedExecutorService} or 
+ * {@link ManagedScheduledExecutorService} can optionally implement this 
+ * interface to provide identifying information about the task, to provide
+ * a {@link ManagedTaskListener} to get notification of lifecycle events of
+ * the task, or to provide additional execution properties.
+ * <p>
+ * See also {@link 
ManagedExecutors#managedTask(java.util.concurrent.Callable, java.util.Map, 
javax.enterprise.concurrent.ManagedTaskListener) 
ManagedExecutors.managedTask()}.
+ * <p>
+ * 
+ * @since 1.0
+ */
+public interface ManagedTask {
+
+  /**
+   * Execution property to be returned in {@link #getExecutionProperties()} 
or
+   * {@link ContextService#createContextualProxy(java.lang.Object, 
java.util.Map, java.lang.Class) ContextService.createContextualProxy()}
+   * to provide hint about whether the task could take a long time to 
complete.
+   * Java&trade; EE Product Providers may make use of this hint value to 
+   * decide how to allocate thread resource for running this task.
+   * Valid values are "true" or "false".
+   */
+  public static final String LONGRUNNING_HINT = 
"javax.enterprise.concurrent.LONGRUNNING_HINT";
+  
+  /**
+   * Execution property to be returned in {@link #getExecutionProperties()} 
or
+   * {@link ContextService#createContextualProxy(java.lang.Object, 
java.util.Map, java.lang.Class) ContextService.createContextualProxy()}
+   * to inform the Java&trade; EE Product Provider under which transaction 
+   * should the task or proxy method of contextual proxy object be executed
+   * in.
+   * 
+   * Valid values are:
+   * <p>
+   * "SUSPEND" (the default if unspecified) - Any transaction that is 
currently
+   * active on the thread will be suspended and a 
+   * {@link javax.transaction.UserTransaction} (accessible in the local 
+   * JNDI namespace as "java:comp/UserTransaction") will be available. The 
+   * original transaction, if any was active on the thread, will be resumed
+   * when the task or contextual proxy object method returns.
+   * 
+   * <p>
+   * "USE_TRANSACTION_OF_EXECUTION_THREAD" - The contextual proxy object 
method
+   * will run within the transaction (if any) of the execution thread. A
+   * {@link javax.transaction.UserTransaction} will only be available if it 
is 
+   * also available in the execution thread (for example, when the proxy 
method
+   * is invoked from a Servlet or Bean Managed Transaction EJB). When there 
is
+   * no existing transaction on the execution thread, such as when running 
tasks
+   * that are submitted to a {@link ManagedExecutorService} or a
+   * {@link ManagedScheduledExecutorService}, a 
+   * {@link javax.transaction.UserTransaction} will be available.
+   * <P>
+   */
+  public static final String TRANSACTION = 
"javax.enterprise.concurrent.TRANSACTION";
+
+  /**
+   * Constant for the "SUSPEND" value of the TRANSACTION execution property.
+   * See {@link ManagedTask#TRANSACTION}.
+   */
+  public static final String SUSPEND = "SUSPEND";
+  
+  /**
+   * Constant for the "USE_TRANSACTION_OF_EXECUTION_THREAD" value of the 
+   * TRANSACTION execution property.
+   * See {@link ManagedTask#TRANSACTION}.
+   */
+  public static final String USE_TRANSACTION_OF_EXECUTION_THREAD = 
"USE_TRANSACTION_OF_EXECUTION_THREAD";
+  
+  /**
+   * Execution property to be returned in {@link #getExecutionProperties()} 
or
+   * {@link ContextService#createContextualProxy(java.lang.Object, 
java.util.Map, java.lang.Class) ContextService.createContextualProxy()}
+   * to provide a String that identifies the task. It may be the name or ID 
that
+   * allow management facilities to inspect the task to determine the intent 
+   * of the task and its state. Implementations should not depend upon 
+   * any thread execution context and should typically return only 
+   * readily-available instance data to identify the task.
+   */
+  public static final String IDENTITY_NAME = 
"javax.enterprise.concurrent.IDENTITY_NAME";
+  
+  /**
+   * The {@link ManagedTaskListener} to receive notification of lifecycle
+   * events of this task.
+   * 
+   * @return The {@link ManagedTaskListener} to receive notification of 
+   * lifecycle events of this task, or null if it is not necessary to get
+   * notified of such events.
+   */
+  public ManagedTaskListener getManagedTaskListener();
+  
+  /**
+   * Provides additional information to the {@link ManagedExecutorService} or
+   * {@link ManagedScheduledExecutorService} when executing this task.<p>
+   * 
+   * Some standard property keys are defined in this class. 
+   * Custom property keys may be defined but must not begin with 
+   * "javax.enterprise.concurrent.".
+   * 
+   * @return A Map&lt;String, String&gt; containing additional execution 
properties, or
+   * null if no additional information is provided for this task.
+   */
+  public Map<String, String> getExecutionProperties();
+}
Index: 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/Trigger.java
===================================================================
--- 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/Trigger.java
 (revision 0)
+++ 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/Trigger.java
 (revision 31)
@@ -0,0 +1,155 @@
+/**
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright (c) 2010-2012 Oracle and/or its affiliates. All rights reserved.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common Development
+ * and Distribution License("CDDL") (collectively, the "License").  You
+ * may not use this file except in compliance with the License.  You can
+ * obtain a copy of the License at
+ * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
+ * or packager/legal/LICENSE.txt.  See the License for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing the software, include this License Header Notice in each
+ * file and include the License file at packager/legal/LICENSE.txt.
+ *
+ * GPL Classpath Exception:
+ * Oracle designates this particular file as subject to the "Classpath"
+ * exception as provided by Oracle in the GPL Version 2 section of the 
License
+ * file that accompanied this code.
+ *
+ * Modifications:
+ * If applicable, add the following below the License Header, with the fields
+ * enclosed by brackets [] replaced by your own identifying information:
+ * "Portions Copyright [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ * If you wish your version of this file to be governed by only the CDDL or
+ * only the GPL Version 2, indicate your decision by adding "[Contributor]
+ * elects to include this software in this distribution under the [CDDL or 
GPL
+ * Version 2] license."  If you don't indicate a single choice of license, a
+ * recipient has the option to distribute your version of this file under
+ * either the CDDL, the GPL Version 2 or to extend the choice of license to
+ * its licensees as provided above.  However, if you add GPL Version 2 code
+ * and therefore, elected the GPL Version 2 license, then the option applies
+ * only if the new code is made subject to such option by the copyright
+ * holder.
+ */
+package javax.enterprise.concurrent;
+
+/**
+ * Triggers allow application developers to plug in rules for when 
+ * and how often a task should run. The trigger can be as simple as 
+ * a single, absolute date-time or can include Java&trade; EE business 
+ * calendar logic. A Trigger implementation is created by the 
+ * application developer (or may be supplied to the application 
+ * externally) and is registered with a task when it is submitted 
+ * to a {@link ManagedScheduledExecutorService} using any of the 
+ * schedule methods. Each method will run with unspecified context. 
+ * The methods can be made contextual through creating contextual
+ * proxy objects using {@link ContextService}.
+ * <p>
+ * Each Trigger instance will be invoked within the same process 
+ * in which it was registered.
+ * <p>
+ * 
+ * Example:
+ * <pre>
+ * &#47;**
+ *  * A trigger that only returns a single date.
+ *  *&#47;
+ *  public class SingleDateTrigger implements Trigger {
+ *      private Date fireTime;
+ *      
+ *      public TriggerSingleDate(Date newDate) {
+ *          fireTime = newDate;
+ *      }
+ *
+ *      public Date getNextRunTime(
+ *         LastExecution lastExecutionInfo, Date taskScheduledTime) {
+ *         
+ *         if(taskScheduledTime.after(fireTime)) {
+ *             return null;
+ *         }
+ *         return fireTime;
+ *      }
+ *
+ *      public boolean skipRun(LastExecution lastExecutionInfo, Date 
scheduledRunTime) {
+ *          return scheduledRunTime.after(fireTime);
+ *      }
+ *  }
+ *
+ * &#47;**
+ *  * A fixed-rate trigger that will skip any runs if
+ *  * the latencyAllowance threshold is exceeded (the task
+ *  * ran too late).
+ *  *&#47;
+ *  public class TriggerFixedRateLatencySensitive implements Trigger {
+ *      private Date startTime;
+ *      private long delta;
+ *      private long latencyAllowance;
+ *
+ *      public TriggerFixedRateLatencySensitive(Date startTime, long delta, 
long latencyAllowance) {
+ *          this.startTime = startTime;
+ *          this.delta = delta;
+ *          this.latencyAllowance = latencyAllowance;
+ *      }
+ *
+ *      public Date getNextRunTime(LastExecution lastExecutionInfo, 
+ *                                 Date taskScheduledTime) {
+ *          if(lastExecutionInfo==null) {
+ *              return startTime;
+ *          }
+ *          return new Date(lastExecutionInfo.getScheduledStart().getTime() 
+ delta);
+ *      }
+ *
+ *      public boolean skipRun(LastExecution lastExecutionInfo, Date 
scheduledRunTime) {
+ *          return System.currentTimeMillis() - scheduledRunTime.getTime() > 
latencyAllowance;
+ *      }
+ *  }
+ *
+ * </pre>
+ * <P>
+ *
+ * @since 1.0
+ */
+public interface Trigger {
+
+  /**
+   * Retrieve the next time that the task should run after.
+   * 
+   * @param lastExecutionInfo information about the last execution of the 
task. 
+   *                   This value will be null if the task has not yet run.
+   * @param taskScheduledTime the date/time in which the task was scheduled 
using
+   *                          the {@code 
ManagedScheduledExecutorService.schedule} 
+   *                          method.
+   * @return the date/time in which the next task iteration should execute 
on or 
+   *         after.
+
+
+   */
+  public java.util.Date getNextRunTime(LastExecution lastExecutionInfo,
+                                       java.util.Date taskScheduledTime);
+  
+  /**
+   * Return true if this run instance should be skipped.
+   * <p>
+   * This is useful if the task shouldn't run because it is late or if the 
task 
+   * is paused or suspended.
+   * <p>
+   * Once this task is skipped, the state of it's Future's result will throw 

+   * {@link SkippedException}. Unchecked exceptions will be wrapped in a 
+   * <code>SkippedException</code>.
+   * 
+   * @param lastExecutionInfo information about the last execution of the 
task. 
+   *                   This value will be null if the task has not yet run.
+   * @param scheduledRunTime the date/time that the task was originally 
scheduled 
+   *                         to run.
+   * @return true if the task should be skipped and rescheduled.
+   */
+  public boolean skipRun(LastExecution lastExecutionInfo,
+                         java.util.Date scheduledRunTime);
+  
+}
Index: 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/ManageableThread.java
===================================================================
--- 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/ManageableThread.java
        (revision 0)
+++ 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/ManageableThread.java
        (revision 31)
@@ -0,0 +1,62 @@
+/**
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright (c) 2010-2012 Oracle and/or its affiliates. All rights reserved.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common Development
+ * and Distribution License("CDDL") (collectively, the "License").  You
+ * may not use this file except in compliance with the License.  You can
+ * obtain a copy of the License at
+ * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
+ * or packager/legal/LICENSE.txt.  See the License for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing the software, include this License Header Notice in each
+ * file and include the License file at packager/legal/LICENSE.txt.
+ *
+ * GPL Classpath Exception:
+ * Oracle designates this particular file as subject to the "Classpath"
+ * exception as provided by Oracle in the GPL Version 2 section of the 
License
+ * file that accompanied this code.
+ *
+ * Modifications:
+ * If applicable, add the following below the License Header, with the fields
+ * enclosed by brackets [] replaced by your own identifying information:
+ * "Portions Copyright [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ * If you wish your version of this file to be governed by only the CDDL or
+ * only the GPL Version 2, indicate your decision by adding "[Contributor]
+ * elects to include this software in this distribution under the [CDDL or 
GPL
+ * Version 2] license."  If you don't indicate a single choice of license, a
+ * recipient has the option to distribute your version of this file under
+ * either the CDDL, the GPL Version 2 or to extend the choice of license to
+ * its licensees as provided above.  However, if you add GPL Version 2 code
+ * and therefore, elected the GPL Version 2 license, then the option applies
+ * only if the new code is made subject to such option by the copyright
+ * holder.
+ */
+package javax.enterprise.concurrent;
+
+/**
+ *
+ * Interface to be implemented by the Java&trade; EE product providers on 
threads
+ * that are created by calling 
+ * {@link ManagedThreadFactory#newThread(java.lang.Runnable) }.
+ * 
+ * @since 1.0
+ */
+public interface ManageableThread {
+
+    /**
+     * This method is used by the application component provider to check 
+     * whether a thread created by the {@code newThread} method of 
+     * {@link ManagedThreadFactory} has been marked for shut down. 
+     * If the value is true, the application component provider should finish
+     * any work on this thread as soon as possible.
+     * 
+     * @return true if this thread has been marked for shutdown.
+     */
+    public boolean isShutdown();
+}
Index: 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/package-info.java
===================================================================
--- 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/package-info.java
    (revision 0)
+++ 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/package-info.java
    (revision 31)
@@ -0,0 +1,45 @@
+/**
+ * Classes and interfaces for concurrent programming in Java EE&trade; 
applications. 
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright (c) 2010-2011 Oracle and/or its affiliates. All rights reserved.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common Development
+ * and Distribution License("CDDL") (collectively, the "License").  You
+ * may not use this file except in compliance with the License.  You can
+ * obtain a copy of the License at
+ * http://glassfish.java.net/public/CDDL+GPL_1_1.html
+ * or packager/legal/LICENSE.txt.  See the License for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing the software, include this License Header Notice in each
+ * file and include the License file at packager/legal/LICENSE.txt.
+ *
+ * GPL Classpath Exception:
+ * Oracle designates this particular file as subject to the "Classpath"
+ * exception as provided by Oracle in the GPL Version 2 section of the 
License
+ * file that accompanied this code.
+ *
+ * Modifications:
+ * If applicable, add the following below the License Header, with the fields
+ * enclosed by brackets [] replaced by your own identifying information:
+ * "Portions Copyright [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ * If you wish your version of this file to be governed by only the CDDL or
+ * only the GPL Version 2, indicate your decision by adding "[Contributor]
+ * elects to include this software in this distribution under the [CDDL or 
GPL
+ * Version 2] license."  If you don't indicate a single choice of license, a
+ * recipient has the option to distribute your version of this file under
+ * either the CDDL, the GPL Version 2 or to extend the choice of license to
+ * its licensees as provided above.  However, if you add GPL Version 2 code
+ * and therefore, elected the GPL Version 2 license, then the option applies
+ * only if the new code is made subject to such option by the copyright
+ * holder.
+ */
+/**
+ * Classes and interfaces for concurrent programming in Java EE&trade; 
applications. 
+ */
+package javax.enterprise.concurrent;
Index: 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/ContextService.java
===================================================================
--- 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/ContextService.java
  (revision 0)
+++ 
tags/javax.enterprise.concurrent-api-1.0-b03/src/main/java/javax/enterprise/concurrent/ContextService.java
  (revision 31)
@@ -0,0 +1,311 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright (c) 2010-2011 Oracle and/or its affiliates. All rights reserved.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common Development
+ * and Distribution License("CDDL") (collectively, the "License").  You
+ * may not use this file except in compliance with the License.  You can
+ * obtain a copy of the License at
+ * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
+ * or packager/legal/LICENSE.txt.  See the License for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing the software, include this License Header Notice in each
+ * file and include the License file at packager/legal/LICENSE.txt.
+ *
+ * GPL Classpath Exception:
+ * Oracle designates this particular file as subject to the "Classpath"
+ * exception as provided by Oracle in the GPL Version 2 section of the 
License
+ * file that accompanied this code.
+ *
+ * Modifications:
+ * If applicable, add the following below the License Header, with the fields
+ * enclosed by brackets [] replaced by your own identifying information:
+ * "Portions Copyright [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ * If you wish your version of this file to be governed by only the CDDL or
+ * only the GPL Version 2, indicate your decision by adding "[Contributor]
+ * elects to include this software in this distribution under the [CDDL or 
GPL
+ * Version 2] license."  If you don't indicate a single choice of license, a
+ * recipient has the option to distribute your version of this file under
+ * either the CDDL, the GPL Version 2 or to extend the choice of license to
+ * its licensees as provided above.  However, if you add GPL Version 2 code
+ * and therefore, elected the GPL Version 2 license, then the option applies
+ * only if the new code is made subject to such option by the copyright
+ * holder.
+ */
+package javax.enterprise.concurrent;
+
+import java.util.Map;
+
+/**
+ * The ContextService provides methods for creating dynamic proxy objects
+ * (as defined by {@link java.lang.reflect.Proxy java.lang.reflect.Proxy}) 
with
+ * the addition of context typically associated with applications executing 
in a
+ * Java&trade; EE environment. 
+ * Examples of such context are classloading, namespace, security, etc.
+ * <p>
+ *
+ * The proxy objects follow the same rules as defined for the
+ * {@link java.lang.reflect.Proxy java.lang.reflect.Proxy} class with the 
following additions:
+ * <ul>
+ * <li>The proxy instance will retain the context of the creator's
+ *     thread.
+ * <li>The proxy instance will implement all of the interfaces specified on 
the
+ *     {@code createContextualProxy} methods.
+ * <li>The object to have a proxy instance created for should not be a 
+ *     component managed by the Java&trade; EE Product Provider, such as a 
web
+ *     component or an EJB.
+ * <li>All interface method invocations on a proxy instance run in the
+ *     creator's context with the exception of {@code hashCode}, 
+ *     {@code equals}, {@code toString} and all other methods declared in 
+ *     {@link java.lang.Object}.
+ * <li>The proxy instance must implement {@link java.io.Serializable}.
+ * <li>The proxied object instance must implement
+ *     {@link java.io.Serializable} if the proxy instance is serialized.
+ * <li>Execution properties can be stored with the proxy instance. Custom
+ *     property keys must not begin with "javax.enterprise.concurrent.".
+ * <li>Execution properties are to be used for controlling how various 
contextual
+ *     information is retrieved and applied to the thread. Although 
application
+ *     components can store arbitrary property keys and values, it is not
+ *     recommended. Java&trade; EE product providers may impose limits to 
the 
+ *     size of the keys and values.
+ * </ul>
+ * <P>
+ * 
+ * @since 1.0
+ */
+public interface ContextService {
+
+  /**
+   * Creates a new contextual object proxy for the input object instance.
+   * <p>
+   * Each method invocation will have the context of the application 
component
+   * instance that created the contextual object proxy.
+   * <p>
+   * The contextual object is useful when developing or using Java&trade; SE
+   * threading mechanisms propagating events to other component instances or
+   * communicating with component instance
[truncated due to length]



[jsr236-spec commits] [concurrency-ee-spec~source-code-repository:31] [maven-release-plugin] copy for tag javax.enterprise.concurrent-api-1.0-

hzhang_jn 02/20/2013
 
 
Close
loading
Please Confirm
Close