harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ndbe...@apache.org
Subject svn commit: r434296 [1/19] - in /incubator/harmony/enhanced/classlib/trunk: make/ modules/concurrent/ modules/concurrent/.settings/ modules/concurrent/META-INF/ modules/concurrent/make/ modules/concurrent/src/ modules/concurrent/src/main/ modules/concu...
Date Thu, 24 Aug 2006 03:42:33 GMT
Author: ndbeyer
Date: Wed Aug 23 20:42:25 2006
New Revision: 434296

URL: http://svn.apache.org/viewvc?rev=434296&view=rev
Log:
Initial commit of the concurrent module (tests are currently disabled).

Added:
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.classpath   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.project   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.core.prefs
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.ui.prefs
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.pde.core.prefs
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/META-INF/
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/META-INF/MANIFEST.MF
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/README.txt   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/build.xml   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/hyproperties.xml   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/patternset.txt   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ConcurrentHashMap.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ConcurrentLinkedQueue.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ConcurrentMap.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CopyOnWriteArraySet.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CountDownLatch.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CyclicBarrier.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/DelayQueue.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Delayed.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Exchanger.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ExecutionException.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Executor.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ExecutorCompletionService.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ExecutorService.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Executors.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Future.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/FutureTask.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/LinkedBlockingQueue.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/PriorityBlockingQueue.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/RejectedExecutionException.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/RejectedExecutionHandler.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ScheduledExecutorService.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ScheduledFuture.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ScheduledThreadPoolExecutor.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Semaphore.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/SynchronousQueue.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ThreadFactory.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ThreadPoolExecutor.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/TimeUnit.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/TimeoutException.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicBoolean.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicInteger.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicIntegerArray.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLong.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLongArray.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLongFieldUpdater.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicMarkableReference.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReference.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReferenceArray.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicStampedReference.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/package.html   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/Condition.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/Lock.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/LockSupport.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/ReadWriteLock.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/ReentrantLock.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/ReentrantReadWriteLock.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/package.html   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/package.html   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/resources/
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AbstractExecutorServiceTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AbstractQueueTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AbstractQueuedSynchronizerTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ArrayBlockingQueueTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicBooleanTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicIntegerArrayTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicIntegerFieldUpdaterTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicIntegerTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicLongArrayTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicLongFieldUpdaterTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicLongTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicMarkableReferenceTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicReferenceArrayTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicReferenceFieldUpdaterTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicReferenceTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicStampedReferenceTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ConcurrentHashMapTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ConcurrentLinkedQueueTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/CopyOnWriteArrayListTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/CopyOnWriteArraySetTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/CountDownLatchTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/CyclicBarrierTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/DelayQueueTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExchangerTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExecutorCompletionServiceTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExecutorsTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/FutureTaskTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/JSR166TestCase.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LinkedBlockingQueueTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LinkedListTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LockSupportTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/PriorityBlockingQueueTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/PriorityQueueTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ReentrantLockTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ReentrantReadWriteLockTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ScheduledExecutorTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/SemaphoreTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/SynchronousQueueTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/SystemTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ThreadLocalTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ThreadPoolExecutorTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ThreadTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/TimeUnitTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/resources/
    incubator/harmony/enhanced/classlib/trunk/modules/luni-kernel/src/main/java/sun/
    incubator/harmony/enhanced/classlib/trunk/modules/luni-kernel/src/main/java/sun/misc/
    incubator/harmony/enhanced/classlib/trunk/modules/luni-kernel/src/main/java/sun/misc/Unsafe.java   (with props)
Modified:
    incubator/harmony/enhanced/classlib/trunk/make/build-java.xml
    incubator/harmony/enhanced/classlib/trunk/modules/luni-kernel/META-INF/MANIFEST.MF
    incubator/harmony/enhanced/classlib/trunk/modules/luni-kernel/make/patternset.txt

Modified: incubator/harmony/enhanced/classlib/trunk/make/build-java.xml
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/make/build-java.xml?rev=434296&r1=434295&r2=434296&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/make/build-java.xml (original)
+++ incubator/harmony/enhanced/classlib/trunk/make/build-java.xml Wed Aug 23 20:42:25 2006
@@ -106,10 +106,12 @@
             <src path="modules/awt/src/main/java/${hy.os}" />
             <src path="modules/awt/src/main/java/common" />
             <src path="modules/beans/src/main/java" />
+            <src path="modules/concurrent/src/main/java/" />
             <src path="modules/crypto/src/main/java" />
             <src path="modules/instrument/src/main/java" />
             <src path="modules/jndi/src/main/java" />
             <src path="modules/logging/src/main/java" />
+            <src path="modules/lang-management/src/main/java/" />
             <src path="modules/luni-kernel/src/main/java" />
             <src path="modules/luni/src/main/java" />
             <src path="modules/math/src/main/java" />
@@ -128,8 +130,6 @@
             <src path="modules/swing/src/main/java/common" />
             <src path="modules/text/src/main/java" />
             <src path="modules/x-net/src/main/java/" />
-            <src path="modules/lang-management/src/main/java/" />
-
             <classpath location="${build.output}" />
             <classpath>
                 <fileset dir="${depends.jars}">

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/
------------------------------------------------------------------------------
--- svn:ignore (added)
+++ svn:ignore Wed Aug 23 20:42:25 2006
@@ -0,0 +1 @@
+bin

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.classpath
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.classpath?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.classpath (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.classpath Wed Aug 23 20:42:25 2006
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry output="bin/main" kind="src" path="src/main/java"/>
+	<classpathentry output="bin/main" kind="src" path="src/main/resources"/>
+	<classpathentry output="bin/test" kind="src" path="src/test/java"/>
+	<classpathentry output="bin/test" kind="src" path="src/test/resources"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry sourcepath="JUNIT_SRC_HOME/junitsrc.zip" kind="var" path="JUNIT_HOME/junit.jar"/>
+	<classpathentry kind="output" path="bin/main"/>
+</classpath>

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.classpath
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.project
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.project?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.project (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.project Wed Aug 23 20:42:25 2006
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>concurrent</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.project
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.core.prefs
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.core.prefs?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.core.prefs (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.core.prefs Wed Aug 23 20:42:25 2006
@@ -0,0 +1,12 @@
+#Wed Aug 23 22:35:26 CDT 2006
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.5

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.ui.prefs
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.ui.prefs?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.ui.prefs (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.ui.prefs Wed Aug 23 20:42:25 2006
@@ -0,0 +1,3 @@
+#Wed Aug 23 22:35:26 CDT 2006
+eclipse.preferences.version=1
+internal.default.compliance=default

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.pde.core.prefs
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.pde.core.prefs?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.pde.core.prefs (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.pde.core.prefs Wed Aug 23 20:42:25 2006
@@ -0,0 +1,3 @@
+#Thu Dec 15 00:50:33 GMT 2005
+eclipse.preferences.version=1
+pluginProject.extensions=false

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/META-INF/MANIFEST.MF
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/META-INF/MANIFEST.MF?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/META-INF/MANIFEST.MF (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/META-INF/MANIFEST.MF Wed Aug 23 20:42:25 2006
@@ -0,0 +1,19 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Harmony Concurrent
+Bundle-SymbolicName: org.apache.harmony.concurrent
+Bundle-Version: 1.0.0
+Bundle-ClassPath: .
+Eclipse-JREBundle: true
+Import-Package: 
+ java.io,
+ java.lang,
+ java.lang.reflect,
+ java.math,
+ java.net,
+ java.security,
+ java.util,
+ sun.misc
+Export-Package: java.util.concurrent,
+ java.util.concurrent.atomic,
+ java.util.concurrent.locks

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/README.txt
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/README.txt?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/README.txt (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/README.txt Wed Aug 23 20:42:25 2006
@@ -0,0 +1,4 @@
+The majority of this code base is sourced from the Concurrency Interest site and the 
+associated ViewCVS server.
+
+URL: http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/?only_with_tag=JSR166_PFD
\ No newline at end of file

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/README.txt
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/build.xml
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/build.xml?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/build.xml (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/build.xml Wed Aug 23 20:42:25 2006
@@ -0,0 +1,150 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Copyright 2006 The Apache Software Foundation or its
+    licensors, as applicable.
+  
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+  
+       http://www.apache.org/licenses/LICENSE-2.0
+  
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+
+<project name="CONCURRENT Build" default="build" basedir=".">
+    <description>Build for CONCURRENT component</description>
+
+    <!-- import common properties -->
+    <import file="${basedir}/../../make/properties.xml" />
+
+    <!-- set global properties for this build. -->
+    <xmlproperty file="make/hyproperties.xml" semanticAttributes="true" />
+
+    <fileset id="classes" dir="${hy.build}">
+        <includesfile name="${hy.concurrent}/make/patternset.txt" />
+        <excludesfile name="${hy.hdk}/build/patternsets/luni-kernel.txt" />
+        <excludesfile name="${hy.hdk}/build/patternsets/security-kernel.txt" />
+    </fileset>
+
+    <!-- Set build.compiler to "org.eclipse.jdt.core.JDTCompilerAdapter" to
+         use the Eclipse Java compiler. -->
+    <property name="build.compiler" value="modern" />
+
+    <target name="build" depends="compile.java, build.jar" />
+
+    <target name="test" ><!-- depends="build, compile.tests, run.tests" --></target>
+
+    <target name="clean">
+        <delete failonerror="false">
+            <fileset refid="classes" />
+            <fileset dir="${hy.concurrent.bin.test}" />
+        </delete>
+    </target>
+
+    <target name="compile.java">
+        <echo message="Compiling CONCURRENT classes" />
+
+        <mkdir dir="${hy.build}" />
+
+        <javac sourcepath=""
+               srcdir="${hy.concurrent.src.main.java}"
+               destdir="${hy.build}"
+               source="${hy.javac.source}"
+               target="${hy.javac.target}"
+               debug="${hy.javac.debug}">
+
+            <bootclasspath>
+                <fileset dir="${hy.jdk}/jre/lib/boot">
+                    <include name="**/*.jar" />
+                </fileset>
+            </bootclasspath>
+        </javac>
+    </target>
+
+    <target name="build.jar" depends="svn-info">
+        <jar destfile="${hy.jdk}/jre/lib/boot/${hy.concurrent.packaging.jarname}.jar"
+             manifest="${hy.concurrent}/META-INF/MANIFEST.MF">
+            <fileset refid="classes" />
+            <manifest>
+                <attribute name="Implementation-Version" value="${svn.info}"/> 
+            </manifest>
+        </jar>
+    </target>
+
+    <target name="compile.tests">
+        <echo message="Compiling CONCURRENT tests" />
+
+        <mkdir dir="${hy.concurrent.bin.test}" />
+
+        <javac srcdir="${hy.concurrent.src.test.java}"
+               destdir="${hy.concurrent.bin.test}"
+               sourcepath=""
+               source="${hy.javac.source}"
+               target="${hy.javac.target}"
+               debug="${hy.javac.debug}">
+
+            <bootclasspath>
+                <fileset dir="${hy.jdk}/jre/lib/boot">
+                    <include name="**/*.jar" />
+                </fileset>
+            </bootclasspath>
+            <classpath location="../../build/tests" />
+            <classpath location="${hy.hdk}/build/test/support.jar" />
+        </javac>
+    </target>
+
+    <target name="run.tests">
+
+        <mkdir dir="${hy.tests.reports}" />
+
+        <property name="test.jre.home" value="${hy.jdk}/jre" />
+
+        <junit fork="yes"
+               forkmode="once"
+               printsummary="withOutAndErr"
+               errorproperty="test.errors"
+               failureproperty="test.failures"
+               showoutput="on"
+               dir="${basedir}"
+               jvm="${test.jre.home}/bin/java">
+
+            <jvmarg value="-showversion"/>
+
+            <env key="JAVA_HOME" value="${test.jre.home}"/>
+
+            <classpath>
+                <pathelement path="${hy.concurrent.bin.test}"/>
+            </classpath>
+            <classpath location="${hy.hdk}/build/test/support.jar" />
+
+            <formatter type="xml" />
+
+            <test name="${test.case}" todir="${hy.tests.reports}"
+                 if="test.case" />
+
+            <batchtest todir="${hy.tests.reports}" haltonfailure="no"
+                unless="test.case">
+
+                <fileset dir="${hy.concurrent.src.test.java}"/>
+            </batchtest>
+        </junit>
+        <antcall target="touch-failures-file" />
+        <antcall target="touch-errors-file" />
+    </target>
+
+    <target name="touch-failures-file" if="test.failures">
+        <echo file="${hy.tests.reports}/test.failures"
+            append="true">concurrent${line.separator}</echo>
+    </target>
+
+    <target name="touch-errors-file" if="test.errors">
+        <echo file="${hy.tests.reports}/test.errors"
+            append="true">concurrent${line.separator}</echo>
+    </target>
+
+</project>

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/build.xml
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/hyproperties.xml
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/hyproperties.xml?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/hyproperties.xml (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/hyproperties.xml Wed Aug 23 20:42:25 2006
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Copyright 2006 The Apache Software Foundation or its licensors, as applicable.
+  
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+  
+       http://www.apache.org/licenses/LICENSE-2.0
+  
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+
+<hy>
+   <concurrent location=".">
+      <src>
+         <main>
+            <java location="src/main/java" />
+            <resources location="src/main/resources" />
+         </main>
+         <test>
+            <java location="src/test/java" />
+            <resources location="src/test/resources" />
+         </test>
+      </src>
+      <bin>
+        <main location="bin/main" />
+        <test location="bin/test" />
+      </bin>
+      <packaging>
+        <jarname>concurrent</jarname>
+      </packaging>
+   </concurrent>
+
+   <hdk location="../../deploy" />
+   <jdk location="../../deploy/jdk" />
+   <build location="../../build/classes" />
+
+   <tests>
+      <reports location="../../build/test_report" />
+   </tests>
+</hy>

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/hyproperties.xml
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/patternset.txt
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/patternset.txt?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/patternset.txt (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/patternset.txt Wed Aug 23 20:42:25 2006
@@ -0,0 +1,17 @@
+# Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+ 
+java/util/concurrent/*
+java/util/concurrent/atomic/*
+java/util/concurrent/locks/*

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/patternset.txt
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,223 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/licenses/publicdomain
+ */
+
+package java.util.concurrent;
+
+import java.util.*;
+
+/**
+ * Provides default implementation of {@link ExecutorService}
+ * execution methods. This class implements the <tt>submit</tt>,
+ * <tt>invokeAny</tt> and <tt>invokeAll</tt> methods using the default
+ * {@link FutureTask} class provided in this package.  For example,
+ * the implementation of <tt>submit(Runnable)</tt> creates an
+ * associated <tt>FutureTask</tt> that is executed and
+ * returned. Subclasses overriding these methods to use different
+ * {@link Future} implementations should do so consistently for each
+ * of these methods.
+ *
+ * @since 1.5
+ * @author Doug Lea
+ */
+public abstract class AbstractExecutorService implements ExecutorService {
+
+    public Future<?> submit(Runnable task) {
+        if (task == null) throw new NullPointerException();
+        FutureTask<Object> ftask = new FutureTask<Object>(task, null);
+        execute(ftask);
+        return ftask;
+    }
+
+    public <T> Future<T> submit(Runnable task, T result) {
+        if (task == null) throw new NullPointerException();
+        FutureTask<T> ftask = new FutureTask<T>(task, result);
+        execute(ftask);
+        return ftask;
+    }
+
+    public <T> Future<T> submit(Callable<T> task) {
+        if (task == null) throw new NullPointerException();
+        FutureTask<T> ftask = new FutureTask<T>(task);
+        execute(ftask);
+        return ftask;
+    }
+
+    /**
+     * the main mechanics of invokeAny.
+     */
+    private <T> T doInvokeAny(Collection<Callable<T>> tasks,
+                            boolean timed, long nanos)
+        throws InterruptedException, ExecutionException, TimeoutException {
+        if (tasks == null)
+            throw new NullPointerException();
+        int ntasks = tasks.size();
+        if (ntasks == 0)
+            throw new IllegalArgumentException();
+        List<Future<T>> futures= new ArrayList<Future<T>>(ntasks);
+        ExecutorCompletionService<T> ecs = 
+            new ExecutorCompletionService<T>(this);
+
+        // For efficiency, especially in executors with limited
+        // parallelism, check to see if previously submitted tasks are
+        // done before submitting more of them. This interleaving
+        // plus the exception mechanics account for messiness of main
+        // loop.
+
+        try {
+            // Record exceptions so that if we fail to obtain any
+            // result, we can throw the last exception we got.
+            ExecutionException ee = null;
+            long lastTime = (timed)? System.nanoTime() : 0;
+            Iterator<Callable<T>> it = tasks.iterator();
+
+            // Start one task for sure; the rest incrementally
+            futures.add(ecs.submit(it.next()));
+            --ntasks;
+            int active = 1;
+
+            for (;;) {
+                Future<T> f = ecs.poll(); 
+                if (f == null) {
+                    if (ntasks > 0) {
+                        --ntasks;
+                        futures.add(ecs.submit(it.next()));
+                        ++active;
+                    }
+                    else if (active == 0) 
+                        break;
+                    else if (timed) {
+                        f = ecs.poll(nanos, TimeUnit.NANOSECONDS);
+                        if (f == null)
+                            throw new TimeoutException();
+                        long now = System.nanoTime();
+                        nanos -= now - lastTime;
+                        lastTime = now;
+                    }
+                    else 
+                        f = ecs.take();
+                }
+                if (f != null) {
+                    --active;
+                    try {
+                        return f.get();
+                    } catch(InterruptedException ie) {
+                        throw ie;
+                    } catch(ExecutionException eex) {
+                        ee = eex;
+                    } catch(RuntimeException rex) {
+                        ee = new ExecutionException(rex);
+                    }
+                }
+            }    
+
+            if (ee == null)
+                ee = new ExecutionException();
+            throw ee;
+
+        } finally {
+            for (Future<T> f : futures) 
+                f.cancel(true);
+        }
+    }
+
+    public <T> T invokeAny(Collection<Callable<T>> tasks)
+        throws InterruptedException, ExecutionException {
+        try {
+            return doInvokeAny(tasks, false, 0);
+        } catch (TimeoutException cannotHappen) {
+            assert false;
+            return null;
+        }
+    }
+
+    public <T> T invokeAny(Collection<Callable<T>> tasks, 
+                           long timeout, TimeUnit unit) 
+        throws InterruptedException, ExecutionException, TimeoutException {
+        return doInvokeAny(tasks, true, unit.toNanos(timeout));
+    }
+
+    public <T> List<Future<T>> invokeAll(Collection<Callable<T>> tasks)
+        throws InterruptedException {
+        if (tasks == null)
+            throw new NullPointerException();
+        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
+        boolean done = false;
+        try {
+            for (Callable<T> t : tasks) {
+                FutureTask<T> f = new FutureTask<T>(t);
+                futures.add(f);
+                execute(f);
+            }
+            for (Future<T> f : futures) {
+                if (!f.isDone()) {
+                    try { 
+                        f.get(); 
+                    } catch(CancellationException ignore) {
+                    } catch(ExecutionException ignore) {
+                    }
+                }
+            }
+            done = true;
+            return futures;
+        } finally {
+            if (!done)
+                for (Future<T> f : futures) 
+                    f.cancel(true);
+        }
+    }
+
+    public <T> List<Future<T>> invokeAll(Collection<Callable<T>> tasks, 
+                                         long timeout, TimeUnit unit) 
+        throws InterruptedException {
+        if (tasks == null || unit == null)
+            throw new NullPointerException();
+        long nanos = unit.toNanos(timeout);
+        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
+        boolean done = false;
+        try {
+            for (Callable<T> t : tasks) 
+                futures.add(new FutureTask<T>(t));
+
+            long lastTime = System.nanoTime();
+
+            // Interleave time checks and calls to execute in case
+            // executor doesn't have any/much parallelism.
+            Iterator<Future<T>> it = futures.iterator();
+            while (it.hasNext()) {
+                execute((Runnable)(it.next()));
+                long now = System.nanoTime();
+                nanos -= now - lastTime;
+                lastTime = now;
+                if (nanos <= 0)
+                    return futures; 
+            }
+
+            for (Future<T> f : futures) {
+                if (!f.isDone()) {
+                    if (nanos <= 0) 
+                        return futures; 
+                    try { 
+                        f.get(nanos, TimeUnit.NANOSECONDS); 
+                    } catch(CancellationException ignore) {
+                    } catch(ExecutionException ignore) {
+                    } catch(TimeoutException toe) {
+                        return futures;
+                    }
+                    long now = System.nanoTime();
+                    nanos -= now - lastTime;
+                    lastTime = now;
+                }
+            }
+            done = true;
+            return futures;
+        } finally {
+            if (!done)
+                for (Future<T> f : futures) 
+                    f.cancel(true);
+        }
+    }
+
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,685 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/licenses/publicdomain
+ */
+
+package java.util.concurrent;
+import java.util.concurrent.locks.*;
+import java.util.*;
+
+/**
+ * A bounded {@linkplain BlockingQueue blocking queue} backed by an
+ * array.  This queue orders elements FIFO (first-in-first-out).  The
+ * <em>head</em> of the queue is that element that has been on the
+ * queue the longest time.  The <em>tail</em> of the queue is that
+ * element that has been on the queue the shortest time. New elements
+ * are inserted at the tail of the queue, and the queue retrieval
+ * operations obtain elements at the head of the queue.
+ *
+ * <p>This is a classic &quot;bounded buffer&quot;, in which a
+ * fixed-sized array holds elements inserted by producers and
+ * extracted by consumers.  Once created, the capacity cannot be
+ * increased.  Attempts to offer an element to a full queue will
+ * result in the offer operation blocking; attempts to retrieve an
+ * element from an empty queue will similarly block.
+ *
+ * <p> This class supports an optional fairness policy for ordering
+ * waiting producer and consumer threads.  By default, this ordering
+ * is not guaranteed. However, a queue constructed with fairness set
+ * to <tt>true</tt> grants threads access in FIFO order. Fairness
+ * generally decreases throughput but reduces variability and avoids
+ * starvation.
+ *
+ * <p>This class implements all of the <em>optional</em> methods
+ * of the {@link Collection} and {@link Iterator} interfaces.
+ *
+ * <p>This class is a member of the
+ * <a href="{@docRoot}/../guide/collections/index.html">
+ * Java Collections Framework</a>.
+ *
+ * @since 1.5
+ * @author Doug Lea
+ * @param <E> the type of elements held in this collection
+ */
+public class ArrayBlockingQueue<E> extends AbstractQueue<E>
+        implements BlockingQueue<E>, java.io.Serializable {
+
+    /**
+     * Serialization ID. This class relies on default serialization
+     * even for the items array, which is default-serialized, even if
+     * it is empty. Otherwise it could not be declared final, which is
+     * necessary here.
+     */
+    private static final long serialVersionUID = -817911632652898426L;
+
+    /** The queued items  */
+    private final E[] items;
+    /** items index for next take, poll or remove */
+    private transient int takeIndex;
+    /** items index for next put, offer, or add. */
+    private transient int putIndex;
+    /** Number of items in the queue */
+    private int count;
+
+    /*
+     * Concurrency control uses the classic two-condition algorithm
+     * found in any textbook.
+     */
+
+    /** Main lock guarding all access */
+    private final ReentrantLock lock;
+    /** Condition for waiting takes */
+    private final Condition notEmpty;
+    /** Condition for waiting puts */
+    private final Condition notFull;
+
+    // Internal helper methods
+
+    /**
+     * Circularly increment i.
+     */
+    final int inc(int i) {
+        return (++i == items.length)? 0 : i;
+    }
+
+    /**
+     * Insert element at current put position, advance, and signal.
+     * Call only when holding lock.
+     */
+    private void insert(E x) {
+        items[putIndex] = x;
+        putIndex = inc(putIndex);
+        ++count;
+        notEmpty.signal();
+    }
+
+    /**
+     * Extract element at current take position, advance, and signal.
+     * Call only when holding lock.
+     */
+    private E extract() {
+        final E[] items = this.items;
+        E x = items[takeIndex];
+        items[takeIndex] = null;
+        takeIndex = inc(takeIndex);
+        --count;
+        notFull.signal();
+        return x;
+    }
+
+    /**
+     * Utility for remove and iterator.remove: Delete item at position i.
+     * Call only when holding lock.
+     */
+    void removeAt(int i) {
+        final E[] items = this.items;
+        // if removing front item, just advance
+        if (i == takeIndex) {
+            items[takeIndex] = null;
+            takeIndex = inc(takeIndex);
+        } else {
+            // slide over all others up through putIndex.
+            for (;;) {
+                int nexti = inc(i);
+                if (nexti != putIndex) {
+                    items[i] = items[nexti];
+                    i = nexti;
+                } else {
+                    items[i] = null;
+                    putIndex = i;
+                    break;
+                }
+            }
+        }
+        --count;
+        notFull.signal();
+    }
+
+    /**
+     * Creates an <tt>ArrayBlockingQueue</tt> with the given (fixed)
+     * capacity and default access policy.
+     * @param capacity the capacity of this queue
+     * @throws IllegalArgumentException if <tt>capacity</tt> is less than 1
+     */
+    public ArrayBlockingQueue(int capacity) {
+        this(capacity, false);
+    }
+
+    /**
+     * Creates an <tt>ArrayBlockingQueue</tt> with the given (fixed)
+     * capacity and the specified access policy.
+     * @param capacity the capacity of this queue
+     * @param fair if <tt>true</tt> then queue accesses for threads blocked
+     * on insertion or removal, are processed in FIFO order; if <tt>false</tt>
+     * the access order is unspecified.
+     * @throws IllegalArgumentException if <tt>capacity</tt> is less than 1
+     */
+    public ArrayBlockingQueue(int capacity, boolean fair) {
+        if (capacity <= 0)
+            throw new IllegalArgumentException();
+        this.items = (E[]) new Object[capacity];
+        lock = new ReentrantLock(fair);
+        notEmpty = lock.newCondition();
+        notFull =  lock.newCondition();
+    }
+
+    /**
+     * Creates an <tt>ArrayBlockingQueue</tt> with the given (fixed)
+     * capacity, the specified access policy and initially containing the
+     * elements of the given collection,
+     * added in traversal order of the collection's iterator.
+     * @param capacity the capacity of this queue
+     * @param fair if <tt>true</tt> then queue accesses for threads blocked
+     * on insertion or removal, are processed in FIFO order; if <tt>false</tt>
+     * the access order is unspecified.
+     * @param c the collection of elements to initially contain
+     * @throws IllegalArgumentException if <tt>capacity</tt> is less than
+     * <tt>c.size()</tt>, or less than 1.
+     * @throws NullPointerException if <tt>c</tt> or any element within it
+     * is <tt>null</tt>
+     */
+    public ArrayBlockingQueue(int capacity, boolean fair,
+                              Collection<? extends E> c) {
+        this(capacity, fair);
+        if (capacity < c.size())
+            throw new IllegalArgumentException();
+
+        for (Iterator<? extends E> it = c.iterator(); it.hasNext();)
+            add(it.next());
+    }
+
+    /**
+     * Inserts the specified element at the tail of this queue if possible,
+     * returning immediately if this queue is full.
+     *
+     * @param o the element to add.
+     * @return <tt>true</tt> if it was possible to add the element to
+     *         this queue, else <tt>false</tt>
+     * @throws NullPointerException if the specified element is <tt>null</tt>
+     */
+    public boolean offer(E o) {
+        if (o == null) throw new NullPointerException();
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            if (count == items.length)
+                return false;
+            else {
+                insert(o);
+                return true;
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * Inserts the specified element at the tail of this queue, waiting if
+     * necessary up to the specified wait time for space to become available.
+     * @param o the element to add
+     * @param timeout how long to wait before giving up, in units of
+     * <tt>unit</tt>
+     * @param unit a <tt>TimeUnit</tt> determining how to interpret the
+     * <tt>timeout</tt> parameter
+     * @return <tt>true</tt> if successful, or <tt>false</tt> if
+     * the specified waiting time elapses before space is available.
+     * @throws InterruptedException if interrupted while waiting.
+     * @throws NullPointerException if the specified element is <tt>null</tt>.
+     */
+    public boolean offer(E o, long timeout, TimeUnit unit)
+        throws InterruptedException {
+
+        if (o == null) throw new NullPointerException();
+        final ReentrantLock lock = this.lock;
+        lock.lockInterruptibly();
+        try {
+            long nanos = unit.toNanos(timeout);
+            for (;;) {
+                if (count != items.length) {
+                    insert(o);
+                    return true;
+                }
+                if (nanos <= 0)
+                    return false;
+                try {
+                    nanos = notFull.awaitNanos(nanos);
+                } catch (InterruptedException ie) {
+                    notFull.signal(); // propagate to non-interrupted thread
+                    throw ie;
+                }
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+
+
+    public E poll() {
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            if (count == 0)
+                return null;
+            E x = extract();
+            return x;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public E poll(long timeout, TimeUnit unit) throws InterruptedException {
+        final ReentrantLock lock = this.lock;
+        lock.lockInterruptibly();
+        try {
+            long nanos = unit.toNanos(timeout);
+            for (;;) {
+                if (count != 0) {
+                    E x = extract();
+                    return x;
+                }
+                if (nanos <= 0)
+                    return null;
+                try {
+                    nanos = notEmpty.awaitNanos(nanos);
+                } catch (InterruptedException ie) {
+                    notEmpty.signal(); // propagate to non-interrupted thread
+                    throw ie;
+                }
+
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+
+
+    public boolean remove(Object o) {
+        if (o == null) return false;
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            int i = takeIndex;
+            int k = 0;
+            for (;;) {
+                if (k++ >= count)
+                    return false;
+                if (o.equals(items[i])) {
+                    removeAt(i);
+                    return true;
+                }
+                i = inc(i);
+            }
+
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public E peek() {
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            return (count == 0) ? null : items[takeIndex];
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public E take() throws InterruptedException {
+        final ReentrantLock lock = this.lock;
+        lock.lockInterruptibly();
+        try {
+            try {
+                while (count == 0)
+                    notEmpty.await();
+            } catch (InterruptedException ie) {
+                notEmpty.signal(); // propagate to non-interrupted thread
+                throw ie;
+            }
+            E x = extract();
+            return x;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * Adds the specified element to the tail of this queue, waiting if
+     * necessary for space to become available.
+     * @param o the element to add
+     * @throws InterruptedException if interrupted while waiting.
+     * @throws NullPointerException if the specified element is <tt>null</tt>.
+     */
+    public void put(E o) throws InterruptedException {
+        if (o == null) throw new NullPointerException();
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lockInterruptibly();
+        try {
+            try {
+                while (count == items.length)
+                    notFull.await();
+            } catch (InterruptedException ie) {
+                notFull.signal(); // propagate to non-interrupted thread
+                throw ie;
+            }
+            insert(o);
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    // this doc comment is overridden to remove the reference to collections
+    // greater in size than Integer.MAX_VALUE
+    /**
+     * Returns the number of elements in this queue.
+     *
+     * @return  the number of elements in this queue.
+     */
+    public int size() {
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            return count;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    // this doc comment is a modified copy of the inherited doc comment,
+    // without the reference to unlimited queues.
+    /**
+     * Returns the number of elements that this queue can ideally (in
+     * the absence of memory or resource constraints) accept without
+     * blocking. This is always equal to the initial capacity of this queue
+     * less the current <tt>size</tt> of this queue.
+     * <p>Note that you <em>cannot</em> always tell if
+     * an attempt to <tt>add</tt> an element will succeed by
+     * inspecting <tt>remainingCapacity</tt> because it may be the
+     * case that a waiting consumer is ready to <tt>take</tt> an
+     * element out of an otherwise full queue.
+     */
+    public int remainingCapacity() {
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            return items.length - count;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+
+    public boolean contains(Object o) {
+        if (o == null) return false;
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            int i = takeIndex;
+            int k = 0;
+            while (k++ < count) {
+                if (o.equals(items[i]))
+                    return true;
+                i = inc(i);
+            }
+            return false;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public Object[] toArray() {
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            Object[] a = new Object[count];
+            int k = 0;
+            int i = takeIndex;
+            while (k < count) {
+                a[k++] = items[i];
+                i = inc(i);
+            }
+            return a;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public <T> T[] toArray(T[] a) {
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            if (a.length < count)
+                a = (T[])java.lang.reflect.Array.newInstance(
+                    a.getClass().getComponentType(),
+                    count
+                    );
+
+            int k = 0;
+            int i = takeIndex;
+            while (k < count) {
+                a[k++] = (T)items[i];
+                i = inc(i);
+            }
+            if (a.length > count)
+                a[count] = null;
+            return a;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public String toString() {
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            return super.toString();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+
+    public void clear() {
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            int i = takeIndex;
+            int k = count;
+            while (k-- > 0) {
+                items[i] = null;
+                i = inc(i);
+            }
+            count = 0;
+            putIndex = 0;
+            takeIndex = 0;
+            notFull.signalAll();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public int drainTo(Collection<? super E> c) {
+        if (c == null)
+            throw new NullPointerException();
+        if (c == this)
+            throw new IllegalArgumentException();
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            int i = takeIndex;
+            int n = 0;
+            int max = count;
+            while (n < max) {
+                c.add(items[i]);
+                items[i] = null;
+                i = inc(i);
+                ++n;
+            }
+            if (n > 0) {
+                count = 0;
+                putIndex = 0;
+                takeIndex = 0;
+                notFull.signalAll();
+            }
+            return n;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+
+    public int drainTo(Collection<? super E> c, int maxElements) {
+        if (c == null)
+            throw new NullPointerException();
+        if (c == this)
+            throw new IllegalArgumentException();
+        if (maxElements <= 0)
+            return 0;
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            int i = takeIndex;
+            int n = 0;
+            int sz = count;
+            int max = (maxElements < count)? maxElements : count;
+            while (n < max) {
+                c.add(items[i]);
+                items[i] = null;
+                i = inc(i);
+                ++n;
+            }
+            if (n > 0) {
+                count -= n;
+                takeIndex = i;
+                notFull.signalAll();
+            }
+            return n;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+
+    /**
+     * Returns an iterator over the elements in this queue in proper sequence.
+     * The returned <tt>Iterator</tt> is a "weakly consistent" iterator that
+     * will never throw {@link java.util.ConcurrentModificationException},
+     * and guarantees to traverse elements as they existed upon
+     * construction of the iterator, and may (but is not guaranteed to)
+     * reflect any modifications subsequent to construction.
+     *
+     * @return an iterator over the elements in this queue in proper sequence.
+     */
+    public Iterator<E> iterator() {
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            return new Itr();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * Iterator for ArrayBlockingQueue
+     */
+    private class Itr implements Iterator<E> {
+        /**
+         * Index of element to be returned by next,
+         * or a negative number if no such.
+         */
+        private int nextIndex;
+
+        /**
+         * nextItem holds on to item fields because once we claim
+         * that an element exists in hasNext(), we must return it in
+         * the following next() call even if it was in the process of
+         * being removed when hasNext() was called.
+         **/
+        private E nextItem;
+
+        /**
+         * Index of element returned by most recent call to next.
+         * Reset to -1 if this element is deleted by a call to remove.
+         */
+        private int lastRet;
+
+        Itr() {
+            lastRet = -1;
+            if (count == 0)
+                nextIndex = -1;
+            else {
+                nextIndex = takeIndex;
+                nextItem = items[takeIndex];
+            }
+        }
+
+        public boolean hasNext() {
+            /*
+             * No sync. We can return true by mistake here
+             * only if this iterator passed across threads,
+             * which we don't support anyway.
+             */
+            return nextIndex >= 0;
+        }
+
+        /**
+         * Check whether nextIndex is valid; if so setting nextItem.
+         * Stops iterator when either hits putIndex or sees null item.
+         */
+        private void checkNext() {
+            if (nextIndex == putIndex) {
+                nextIndex = -1;
+                nextItem = null;
+            } else {
+                nextItem = items[nextIndex];
+                if (nextItem == null)
+                    nextIndex = -1;
+            }
+        }
+
+        public E next() {
+            final ReentrantLock lock = ArrayBlockingQueue.this.lock;
+            lock.lock();
+            try {
+                if (nextIndex < 0)
+                    throw new NoSuchElementException();
+                lastRet = nextIndex;
+                E x = nextItem;
+                nextIndex = inc(nextIndex);
+                checkNext();
+                return x;
+            } finally {
+                lock.unlock();
+            }
+        }
+
+        public void remove() {
+            final ReentrantLock lock = ArrayBlockingQueue.this.lock;
+            lock.lock();
+            try {
+                int i = lastRet;
+                if (i == -1)
+                    throw new IllegalStateException();
+                lastRet = -1;
+
+                int ti = takeIndex;
+                removeAt(i);
+                // back up cursor (reset to front if was first element)
+                nextIndex = (i == ti) ? takeIndex : i;
+                checkNext();
+            } finally {
+                lock.unlock();
+            }
+        }
+    }
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,227 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/licenses/publicdomain
+ */
+
+package java.util.concurrent;
+
+import java.util.Collection;
+import java.util.Queue;
+
+/**
+ * A {@link java.util.Queue} that additionally supports operations
+ * that wait for the queue to become non-empty when retrieving an element,
+ * and wait for space to become available in the queue when storing an 
+ * element.
+ *
+ * <p>A <tt>BlockingQueue</tt> does not accept <tt>null</tt> elements.
+ * Implementations throw <tt>NullPointerException</tt> on attempts
+ * to <tt>add</tt>, <tt>put</tt> or <tt>offer</tt> a <tt>null</tt>.  A
+ * <tt>null</tt> is used as a sentinel value to indicate failure of
+ * <tt>poll</tt> operations.
+ *
+ * <p>A <tt>BlockingQueue</tt> may be capacity bounded. At any given
+ * time it may have a <tt>remainingCapacity</tt> beyond which no
+ * additional elements can be <tt>put</tt> without blocking.
+ * A <tt>BlockingQueue</tt> without any intrinsic capacity constraints always
+ * reports a remaining capacity of <tt>Integer.MAX_VALUE</tt>.
+ *
+ * <p> While <tt>BlockingQueue</tt> is designed to be used primarily
+ * for producer-consumer queues, it additionally supports the {@link
+ * java.util.Collection} interface.  So, for example, it is possible
+ * to remove an arbitrary element from a queue using
+ * <tt>remove(x)</tt>. However, such operations are in general
+ * <em>not</em> performed very efficiently, and are intended for only
+ * occasional use, such as when a queued message is cancelled.  Also,
+ * the bulk Collection operations, most notably <tt>addAll</tt>, are
+ * <em>not</em> necessarily performed atomically, so it is possible
+ * for <tt>addAll(c)</tt> to fail (throwing an exception) after adding
+ * only some of the elements in <tt>c</tt>.
+ *
+ * <p>A <tt>BlockingQueue</tt> does <em>not</em> intrinsically support
+ * any kind of &quot;close&quot; or &quot;shutdown&quot; operation to
+ * indicate that no more items will be added.  The needs and usage of
+ * such features tend to be implementation-dependent. For example, a
+ * common tactic is for producers to insert special
+ * <em>end-of-stream</em> or <em>poison</em> objects, that are
+ * interpreted accordingly when taken by consumers.
+ *
+ * <p>
+ * Usage example, based on a typical producer-consumer scenario.
+ * Note that a <tt>BlockingQueue</tt> can safely be used with multiple
+ * producers and multiple consumers.
+ * <pre>
+ * class Producer implements Runnable {
+ *   private final BlockingQueue queue;
+ *   Producer(BlockingQueue q) { queue = q; }
+ *   public void run() {
+ *     try {
+ *       while(true) { queue.put(produce()); }
+ *     } catch (InterruptedException ex) { ... handle ...}
+ *   }
+ *   Object produce() { ... }
+ * }
+ *
+ * class Consumer implements Runnable {
+ *   private final BlockingQueue queue;
+ *   Consumer(BlockingQueue q) { queue = q; }
+ *   public void run() {
+ *     try {
+ *       while(true) { consume(queue.take()); }
+ *     } catch (InterruptedException ex) { ... handle ...}
+ *   }
+ *   void consume(Object x) { ... }
+ * }
+ *
+ * class Setup {
+ *   void main() {
+ *     BlockingQueue q = new SomeQueueImplementation();
+ *     Producer p = new Producer(q);
+ *     Consumer c1 = new Consumer(q);
+ *     Consumer c2 = new Consumer(q);
+ *     new Thread(p).start();
+ *     new Thread(c1).start();
+ *     new Thread(c2).start();
+ *   }
+ * }
+ * </pre>
+ *
+ * <p>This interface is a member of the
+ * <a href="{@docRoot}/../guide/collections/index.html">
+ * Java Collections Framework</a>.
+ *  
+ * @since 1.5
+ * @author Doug Lea
+ * @param <E> the type of elements held in this collection
+ */
+public interface BlockingQueue<E> extends Queue<E> {
+
+    /**
+     * Inserts the specified element into this queue, if possible.  When
+     * using queues that may impose insertion restrictions (for
+     * example capacity bounds), method <tt>offer</tt> is generally
+     * preferable to method {@link Collection#add}, which can fail to
+     * insert an element only by throwing an exception.
+     *
+     * @param o the element to add.
+     * @return <tt>true</tt> if it was possible to add the element to
+     *         this queue, else <tt>false</tt>
+     * @throws NullPointerException if the specified element is <tt>null</tt>
+     */
+    boolean offer(E o);
+    
+    /**
+     * Inserts the specified element into this queue, waiting if necessary
+     * up to the specified wait time for space to become available.
+     * @param o the element to add
+     * @param timeout how long to wait before giving up, in units of
+     * <tt>unit</tt>
+     * @param unit a <tt>TimeUnit</tt> determining how to interpret the
+     * <tt>timeout</tt> parameter
+     * @return <tt>true</tt> if successful, or <tt>false</tt> if
+     * the specified waiting time elapses before space is available.
+     * @throws InterruptedException if interrupted while waiting.
+     * @throws NullPointerException if the specified element is <tt>null</tt>.
+     */
+    boolean offer(E o, long timeout, TimeUnit unit)
+        throws InterruptedException;
+
+    /**
+     * Retrieves and removes the head of this queue, waiting
+     * if necessary up to the specified wait time if no elements are
+     * present on this queue.
+     * @param timeout how long to wait before giving up, in units of
+     * <tt>unit</tt>
+     * @param unit a <tt>TimeUnit</tt> determining how to interpret the
+     * <tt>timeout</tt> parameter
+     * @return the head of this queue, or <tt>null</tt> if the
+     * specified waiting time elapses before an element is present.
+     * @throws InterruptedException if interrupted while waiting.
+     */
+    E poll(long timeout, TimeUnit unit)
+        throws InterruptedException;
+
+    /**
+     * Retrieves and removes the head of this queue, waiting
+     * if no elements are present on this queue.
+     * @return the head of this queue
+     * @throws InterruptedException if interrupted while waiting.
+     */
+    E take() throws InterruptedException;
+
+    /**
+     * Adds the specified element to this queue, waiting if necessary for
+     * space to become available.
+     * @param o the element to add
+     * @throws InterruptedException if interrupted while waiting.
+     * @throws NullPointerException if the specified element is <tt>null</tt>.
+     */
+    void put(E o) throws InterruptedException;
+
+    /**
+     * Returns the number of elements that this queue can ideally (in
+     * the absence of memory or resource constraints) accept without
+     * blocking, or <tt>Integer.MAX_VALUE</tt> if there is no
+     * intrinsic limit.
+     * <p>Note that you <em>cannot</em> always tell if
+     * an attempt to <tt>add</tt> an element will succeed by
+     * inspecting <tt>remainingCapacity</tt> because it may be the
+     * case that a waiting consumer is ready to <tt>take</tt> an
+     * element out of an otherwise full queue.
+     * @return the remaining capacity
+     */
+    int remainingCapacity();
+
+    /**
+     * Adds the specified element to this queue if it is possible to
+     * do so immediately, returning <tt>true</tt> upon success, else
+     * throwing an IllegalStateException.  
+     * @param o the element
+     * @return <tt>true</tt> (as per the general contract of
+     *         <tt>Collection.add</tt>).
+     *
+     * @throws NullPointerException if the specified element is <tt>null</tt>
+     * @throws IllegalStateException if element cannot be added
+     */
+    boolean add(E o);
+
+    /**
+     * Removes all available elements from this queue and adds them
+     * into the given collection.  This operation may be more
+     * efficient than repeatedly polling this queue.  A failure
+     * encountered while attempting to <tt>add</tt> elements to
+     * collection <tt>c</tt> may result in elements being in neither,
+     * either or both collections when the associated exception is
+     * thrown. Attempts to drain a queue to itself result in
+     * <tt>IllegalArgumentException</tt>. Further, the behavior of
+     * this operation is undefined if the specified collection is
+     * modified while the operation is in progress.
+     *
+     * @param c the collection to transfer elements into
+     * @return the number of elements transferred.
+     * @throws NullPointerException if c is null
+     * @throws IllegalArgumentException if c is this queue
+     * 
+     */
+    int drainTo(Collection<? super E> c);
+    
+    /**
+     * Removes at most the given number of available elements from
+     * this queue and adds them into the given collection.  A failure
+     * encountered while attempting to <tt>add</tt> elements to
+     * collection <tt>c</tt> may result in elements being in neither,
+     * either or both collections when the associated exception is
+     * thrown. Attempts to drain a queue to itself result in
+     * <tt>IllegalArgumentException</tt>. Further, the behavior of
+     * this operation is undefined if the specified collection is
+     * modified while the operation is in progress.
+     *
+     * @param c the collection to transfer elements into
+     * @param maxElements the maximum number of elements to transfer
+     * @return the number of elements transferred.
+     * @throws NullPointerException if c is null
+     * @throws IllegalArgumentException if c is this queue
+     */
+    int drainTo(Collection<? super E> c, int maxElements);
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,38 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/licenses/publicdomain
+ */
+
+package java.util.concurrent;
+
+/**
+ * Exception thrown when a thread tries to wait upon a barrier that is
+ * in a broken state, or which enters the broken state while the thread
+ * is waiting.
+ *
+ * @see CyclicBarrier
+ *
+ * @since 1.5
+ * @author Doug Lea
+ *
+ */
+public class BrokenBarrierException extends Exception {
+    private static final long serialVersionUID = 7117394618823254244L;
+
+    /**
+     * Constructs a <tt>BrokenBarrierException</tt> with no specified detail
+     * message.
+     */
+    public BrokenBarrierException() {}
+
+    /**
+     * Constructs a <tt>BrokenBarrierException</tt> with the specified
+     * detail message.
+     *
+     * @param message the detail message
+     */
+    public BrokenBarrierException(String message) {
+        super(message);
+    }
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,36 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/licenses/publicdomain
+ */
+
+package java.util.concurrent;
+
+/**
+ * A task that returns a result and may throw an exception.
+ * Implementors define a single method with no arguments called
+ * <tt>call</tt>.
+ *
+ * <p>The <tt>Callable</tt> interface is similar to {@link
+ * java.lang.Runnable}, in that both are designed for classes whose
+ * instances are potentially executed by another thread.  A
+ * <tt>Runnable</tt>, however, does not return a result and cannot
+ * throw a checked exception.
+ *
+ * <p> The {@link Executors} class contains utility methods to
+ * convert from other common forms to <tt>Callable</tt> classes.
+ *
+ * @see Executor
+ * @since 1.5
+ * @author Doug Lea
+ * @param <V> the result type of method <tt>call</tt>
+ */
+public interface Callable<V> {
+    /**
+     * Computes a result, or throws an exception if unable to do so.
+     *
+     * @return computed result
+     * @throws Exception if unable to compute a result
+     */
+    V call() throws Exception;
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,34 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/licenses/publicdomain
+ */
+
+package java.util.concurrent;
+
+/**
+ * Exception indicating that the result of a value-producing task,
+ * such as a {@link FutureTask}, cannot be retrieved because the task
+ * was cancelled.
+ *
+ * @since 1.5
+ * @author Doug Lea
+ */
+public class CancellationException extends IllegalStateException {
+    private static final long serialVersionUID = -9202173006928992231L;
+
+    /**
+     * Constructs a <tt>CancellationException</tt> with no detail message.
+     */
+    public CancellationException() {}
+
+    /**
+     * Constructs a <tt>CancellationException</tt> with the specified detail
+     * message.
+     *
+     * @param message the detail message
+     */
+    public CancellationException(String message) {
+        super(message);
+    }
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java Wed Aug 23 20:42:25 2006
@@ -0,0 +1,92 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/licenses/publicdomain
+ */
+
+package java.util.concurrent;
+
+/**
+ * A service that decouples the production of new asynchronous tasks
+ * from the consumption of the results of completed tasks.  Producers
+ * <tt>submit</tt> tasks for execution. Consumers <tt>take</tt>
+ * completed tasks and process their results in the order they
+ * complete.  A <tt>CompletionService</tt> can for example be used to
+ * manage asynchronous IO, in which tasks that perform reads are
+ * submitted in one part of a program or system, and then acted upon
+ * in a different part of the program when the reads complete,
+ * possibly in a different order than they were requested.
+
+ * <p>
+ *
+ * Typically, a <tt>CompletionService</tt> relies on a separate {@link
+ * Executor} to actually execute the tasks, in which case the
+ * <tt>CompletionService</tt> only manages an internal completion
+ * queue. The {@link ExecutorCompletionService} class provides an
+ * implementation of this approach.
+ *
+ */
+public interface CompletionService<V> {
+    /**
+     * Submits a value-returning task for execution and returns a Future
+     * representing the pending results of the task. Upon completion,
+     * this task may be taken or polled.
+     *
+     * @param task the task to submit
+     * @return a Future representing pending completion of the task
+     * @throws RejectedExecutionException if task cannot be scheduled
+     * for execution
+     * @throws NullPointerException if task null     
+     */
+    Future<V> submit(Callable<V> task);
+
+
+    /**
+     * Submits a Runnable task for execution and returns a Future 
+     * representing that task. Upon completion,
+     * this task may be taken or polled.
+     *
+     * @param task the task to submit
+     * @param result the result to return upon successful completion
+     * @return a Future representing pending completion of the task,
+     * and whose <tt>get()</tt> method will return the given result value 
+     * upon completion
+     * @throws RejectedExecutionException if task cannot be scheduled
+     * for execution
+     * @throws NullPointerException if task null     
+     */
+    Future<V> submit(Runnable task, V result);
+
+    /**
+     * Retrieves and removes the Future representing the next
+     * completed task, waiting if none are yet present.
+     * @return the Future representing the next completed task
+     * @throws InterruptedException if interrupted while waiting.
+     */
+    Future<V> take() throws InterruptedException;
+
+
+    /**
+     * Retrieves and removes the Future representing the next
+     * completed task or <tt>null</tt> if none are present.
+     *
+     * @return the Future representing the next completed task, or
+     * <tt>null</tt> if none are present.
+     */
+    Future<V> poll();
+
+    /**
+     * Retrieves and removes the Future representing the next
+     * completed task, waiting if necessary up to the specified wait
+     * time if none are yet present.
+     * @param timeout how long to wait before giving up, in units of
+     * <tt>unit</tt>
+     * @param unit a <tt>TimeUnit</tt> determining how to interpret the
+     * <tt>timeout</tt> parameter
+     * @return the Future representing the next completed task or
+     * <tt>null</tt> if the specified waiting time elapses before one
+     * is present.
+     * @throws InterruptedException if interrupted while waiting.
+     */
+    Future<V> poll(long timeout, TimeUnit unit) throws InterruptedException;
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message