harmony-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Geir Magnusson Jr <g...@pobox.com>
Subject Re: svn commit: r421111 [1/11] - in /incubator/harmony/enhanced/classlib/trunk/sandbox: ./ juc-proposal/ juc-proposal/concurrent/ juc-proposal/concurrent/.settings/ juc-proposal/concurrent/META-INF/ juc-proposal/concurrent/src/ juc-proposal/concurrent/src/...
Date Wed, 12 Jul 2006 09:42:43 GMT
You can't veto something in the sandbox.

You can veto on technical grounds you don't want it in the mainline.

geir


Tim Ellison wrote:
> -1 for this commit.
> 
> I'll discuss over on the concurrent utils thread:
> http://mail-archives.apache.org/mod_mbox/incubator-harmony-dev/200607.mbox/%3c005401c6a56e$79234ce0$0c01a8c0@LITTLEGUY%3e
> 
> Regards,
> Tim
> 
> ndbeyer@apache.org wrote:
>> Author: ndbeyer
>> Date: Tue Jul 11 21:12:04 2006
>> New Revision: 421111
>>
>> URL: http://svn.apache.org/viewvc?rev=421111&view=rev
>> Log:
>> Check in java.util.concurrent module proposal.
>>
>> Added:
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/README.txt   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent.tar.gz   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.classpath   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.project   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.core.prefs
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.ui.prefs
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.pde.core.prefs
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/META-INF/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/META-INF/MANIFEST.MF
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/pom.xml   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Callable.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CancellationException.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CompletionService.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ConcurrentHashMap.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ConcurrentLinkedQueue.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ConcurrentMap.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CopyOnWriteArraySet.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CountDownLatch.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CyclicBarrier.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/DelayQueue.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Delayed.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Exchanger.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ExecutionException.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Executor.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ExecutorCompletionService.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ExecutorService.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Executors.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Future.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/FutureTask.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/LinkedBlockingQueue.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/PriorityBlockingQueue.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/RejectedExecutionException.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/RejectedExecutionHandler.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ScheduledExecutorService.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ScheduledFuture.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ScheduledThreadPoolExecutor.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Semaphore.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/SynchronousQueue.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ThreadFactory.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ThreadPoolExecutor.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/TimeUnit.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/TimeoutException.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicBoolean.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicInteger.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicIntegerArray.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLong.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLongArray.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLongFieldUpdater.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicMarkableReference.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReference.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReferenceArray.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicStampedReference.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/package.html   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/Condition.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/Lock.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/LockSupport.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/ReadWriteLock.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/ReentrantLock.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/ReentrantReadWriteLock.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/package.html   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/package.html   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/org/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/org/apache/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/org/apache/harmony/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/org/apache/harmony/concurrent/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/org/apache/harmony/concurrent/AtomicSupport.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/org/apache/harmony/concurrent/LocksSupport.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/org/apache/harmony/concurrent/ServiceLoader.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/resources/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/org/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/org/apache/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/org/apache/harmony/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/org/apache/harmony/concurrent/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/org/apache/harmony/concurrent/ServiceA.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/org/apache/harmony/concurrent/ServiceAImpl.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/org/apache/harmony/concurrent/ServiceLoaderTest.java   (with props)
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/resources/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/resources/META-INF/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/resources/META-INF/services/
>>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/resources/META-INF/services/org.apache.harmony.concurrent.ServiceA
>>
>> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/README.txt
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/README.txt?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/README.txt (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/README.txt Tue Jul 11 21:12:04 2006
>> @@ -0,0 +1,22 @@
>> +README
>> +======
>> +
>> +
>> +This directory contains the proposed contents and layout of the 'concurrent' module
>> +for the Apache Harmony Class Library. The majority of the source code is from Doug
>> +Lea's Concurrency JSR-166 Interest Site [1].
>> +
>> +
>> +Contents
>> +--------
>> +
>> +*  concurrent        - The 'concurrent' module that will eventually end up at 
>> +                       https://svn.apache.org/repos/asf/incubator/harmony/enhanced/classlib/trunk/modules/concurrent
>> +
>> +*  concurrent.tar.gz - The TAR ball of the original source, as pulled from Doub 
>> +                       Lea's ViewCVS. The source was pulled from the site at the
>> +                       tag JSR166_PFD [2].
>> +
>> +
>> +[1] http://gee.cs.oswego.edu/dl/concurrency-interest/
>> +[2] http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/main/java/util/concurrent/?only_with_tag=JSR166_PFD
>> \ No newline at end of file
>>
>> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/README.txt
>> ------------------------------------------------------------------------------
>>     svn:eol-style = native
>>
>> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/
>> ------------------------------------------------------------------------------
>> --- svn:ignore (added)
>> +++ svn:ignore Tue Jul 11 21:12:04 2006
>> @@ -0,0 +1 @@
>> +target
>>
>> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent.tar.gz
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent.tar.gz?rev=421111&view=auto
>> ==============================================================================
>> Binary file - no diff available.
>>
>> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent.tar.gz
>> ------------------------------------------------------------------------------
>>     svn:mime-type = application/octet-stream
>>
>> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.classpath
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.classpath?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.classpath (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.classpath Tue Jul 11 21:12:04 2006
>> @@ -0,0 +1,10 @@
>> +<?xml version="1.0" encoding="UTF-8"?>
>> +<classpath>
>> +	<classpathentry output="target/classes" kind="src" path="src/main/java"/>
>> +	<classpathentry output="target/classes" kind="src" path="src/main/resources"/>
>> +	<classpathentry output="target/test-classes" kind="src" path="src/test/java"/>
>> +	<classpathentry output="target/test-classes" 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="target/classes"/>
>> +</classpath>
>>
>> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.classpath
>> ------------------------------------------------------------------------------
>>     svn:eol-style = native
>>
>> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.project
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.project?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.project (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.project Tue Jul 11 21:12:04 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/sandbox/juc-proposal/concurrent/.project
>> ------------------------------------------------------------------------------
>>     svn:eol-style = native
>>
>> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.core.prefs
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.core.prefs?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.core.prefs (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.core.prefs Tue Jul 11 21:12:04 2006
>> @@ -0,0 +1,12 @@
>> +#Wed May 03 13:10:22 BST 2006
>> +eclipse.preferences.version=1
>> +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
>> +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.4
>> +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/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.ui.prefs
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.ui.prefs?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.ui.prefs (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.ui.prefs Tue Jul 11 21:12:04 2006
>> @@ -0,0 +1,3 @@
>> +#Wed May 03 13:10:00 BST 2006
>> +eclipse.preferences.version=1
>> +internal.default.compliance=user
>>
>> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.pde.core.prefs
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.pde.core.prefs?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.pde.core.prefs (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.pde.core.prefs Tue Jul 11 21:12:04 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/sandbox/juc-proposal/concurrent/META-INF/MANIFEST.MF
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/META-INF/MANIFEST.MF?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/META-INF/MANIFEST.MF (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/META-INF/MANIFEST.MF Tue Jul 11 21:12:04 2006
>> @@ -0,0 +1,18 @@
>> +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.net,
>> + java.security,
>> + java.util
>> +Export-Package: java.util.concurrent,
>> + java.util.concurrent.atomic,
>> + java.util.concurrent.locks,
>> + org.apache.harmony.concurrent
>>
>> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/pom.xml
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/pom.xml?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/pom.xml (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/pom.xml Tue Jul 11 21:12:04 2006
>> @@ -0,0 +1,57 @@
>> +<project xmlns="http://maven.apache.org/POM/4.0.0"
>> +	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
>> +	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
>> +	<modelVersion>4.0.0</modelVersion>
>> +	<groupId>org.apache.harmony</groupId>
>> +	<artifactId>concurrent</artifactId>
>> +	<packaging>jar</packaging>
>> +	<version>1.0-SNAPSHOT</version>
>> +	<name>Apache Harmony Class Library Concurrent Module</name>
>> +	<url>http://incubator.apache.org/harmony/</url>
>> +	<build>
>> +		<plugins>
>> +			<plugin>
>> +				<artifactId>maven-compiler-plugin</artifactId>
>> +				<configuration>
>> +					<source>1.5</source>
>> +					<target>1.5</target>
>> +				</configuration>
>> +			</plugin>
>> +			<plugin>
>> +				<artifactId>maven-jar-plugin</artifactId>
>> +				<configuration>
>> +					<archive>
>> +						<manifestFile>
>> +							META-INF/MANIFEST.MF
>> +						</manifestFile>
>> +					</archive>
>> +				</configuration>
>> +			</plugin>
>> +		</plugins>
>> +	</build>
>> +	<reporting>
>> +		<plugins>
>> +			<plugin>
>> +				<artifactId>maven-surefire-report-plugin</artifactId>
>> +			</plugin>
>> +			<plugin>
>> +				<artifactId>maven-javadoc-plugin</artifactId>
>> +				<configuration>
>> +					<source>1.5</source>
>> +					<show>private</show>
>> +				</configuration>
>> +			</plugin>
>> +			<plugin>
>> +				<artifactId>maven-jxr-plugin</artifactId>
>> +			</plugin>
>> +		</plugins>
>> +	</reporting>
>> +	<dependencies>
>> +		<dependency>
>> +			<groupId>junit</groupId>
>> +			<artifactId>junit</artifactId>
>> +			<version>[3,4)</version>
>> +			<scope>test</scope>
>> +		</dependency>
>> +	</dependencies>
>> +</project>
>>
>> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/pom.xml
>> ------------------------------------------------------------------------------
>>     svn:eol-style = native
>>
>> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java Tue Jul 11 21:12:04 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/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java
>> ------------------------------------------------------------------------------
>>     svn:eol-style = native
>>
>> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java Tue Jul 11 21:12:04 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/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java
>> ------------------------------------------------------------------------------
>>     svn:eol-style = native
>>
>> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java Tue Jul 11 21:12:04 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/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java
>> ------------------------------------------------------------------------------
>>     svn:eol-style = native
>>
>> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java Tue Jul 11 21:12:04 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/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java
>> ------------------------------------------------------------------------------
>>     svn:eol-style = native
>>
>> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Callable.java
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Callable.java?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Callable.java (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Callable.java Tue Jul 11 21:12:04 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/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Callable.java
>> ------------------------------------------------------------------------------
>>     svn:eol-style = native
>>
>> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CancellationException.java
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CancellationException.java?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CancellationException.java (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CancellationException.java Tue Jul 11 21:12:04 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/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CancellationException.java
>> ------------------------------------------------------------------------------
>>     svn:eol-style = native
>>
>> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CompletionService.java
>> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CompletionService.java?rev=421111&view=auto
>> ==============================================================================
>> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CompletionService.java (added)
>> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CompletionService.java Tue Jul 11 21:12:04 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/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CompletionService.java
>> ------------------------------------------------------------------------------
>>     svn:eol-style = native
>>
>>
>>
> 

---------------------------------------------------------------------
Terms of use : http://incubator.apache.org/harmony/mailing.html
To unsubscribe, e-mail: harmony-dev-unsubscribe@incubator.apache.org
For additional commands, e-mail: harmony-dev-help@incubator.apache.org


Mime
View raw message