harmony-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Tim Ellison <t.p.elli...@gmail.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 14:07:56 GMT
My objection to committing the concurrency code to our SVN is not on a
technical basis.  My objection is based on the Harmony contributor process.

The commit was not made by an original author in the day to day
development of the code, it is bringing in code from elsewhere and
making it part of the Harmony project.  As such we need to have suitable
Authorized Contributor Questionnaires from the authors and/or the Bulk
Contribution Questionnaire from the owners.

I understand that the code has been released into the public domain by
the authors, and I have no reason to doubt that the authors' employers
(who may have a claim on that work) knew what they were doing and were
happy for that work to be out in public domain.  So can we go and get
ACQs from the authors to show that is the case, and file them alongside
the other ACQs that we have for the Harmony code?

Similarly, if we then intend to take regular updates from the JSR166
repository we should have some indication that the authors' ongoing
contributions to that work are understood to be public domain.

Given the very public history of the concurrency project I'm quite happy
that this openness is understood and intentional by contributors to that
JSR and their employers, so I'm assuming that it won't be difficult to
get such assurances.

Regards,
Tim

Geir Magnusson Jr wrote:
> To be clearer, I needed an "if" between "technical grounds" and "you
> don't..."
> 
> Also, we can keep things out of sandbox if the code violates someones
> copyright, or is under an inappropriate license for us to have in SVN,
> or some other legal problem for the project or ASF (like code that
> implements a patent) but I don't think that's the case here.
> 
> geir
> 
> 
> Geir Magnusson Jr wrote:
>> 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
>>
>>
>>
> 
> ---------------------------------------------------------------------
> 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
> 
> 

-- 

Tim Ellison (t.p.ellison@gmail.com)
IBM Java technology centre, UK.

---------------------------------------------------------------------
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