From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- .../concurrent/locks/AbstractOwnableSynchronizer.h | 25 +++++ ...bstractQueuedLongSynchronizer$ConditionObject.h | 52 ++++++++++ .../locks/AbstractQueuedLongSynchronizer$Node.h | 34 ++++++ .../locks/AbstractQueuedLongSynchronizer.h | 115 +++++++++++++++++++++ .../AbstractQueuedSynchronizer$ConditionObject.h | 52 ++++++++++ .../locks/AbstractQueuedSynchronizer$Node.h | 34 ++++++ .../concurrent/locks/AbstractQueuedSynchronizer.h | 115 +++++++++++++++++++++ libjava/java/util/concurrent/locks/Condition.h | 25 +++++ libjava/java/util/concurrent/locks/Lock.h | 24 +++++ libjava/java/util/concurrent/locks/LockSupport.h | 42 ++++++++ libjava/java/util/concurrent/locks/ReadWriteLock.h | 20 ++++ .../util/concurrent/locks/ReentrantLock$FairSync.h | 25 +++++ .../concurrent/locks/ReentrantLock$NonfairSync.h | 25 +++++ .../util/concurrent/locks/ReentrantLock$Sync.h | 33 ++++++ libjava/java/util/concurrent/locks/ReentrantLock.h | 49 +++++++++ .../locks/ReentrantReadWriteLock$FairSync.h | 24 +++++ .../locks/ReentrantReadWriteLock$NonfairSync.h | 24 +++++ .../locks/ReentrantReadWriteLock$ReadLock.h | 31 ++++++ .../ReentrantReadWriteLock$Sync$HoldCounter.h | 23 +++++ ...rantReadWriteLock$Sync$ThreadLocalHoldCounter.h | 22 ++++ .../concurrent/locks/ReentrantReadWriteLock$Sync.h | 55 ++++++++++ .../locks/ReentrantReadWriteLock$WriteLock.h | 33 ++++++ .../util/concurrent/locks/ReentrantReadWriteLock.h | 57 ++++++++++ 23 files changed, 939 insertions(+) create mode 100644 libjava/java/util/concurrent/locks/AbstractOwnableSynchronizer.h create mode 100644 libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer$ConditionObject.h create mode 100644 libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer$Node.h create mode 100644 libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.h create mode 100644 libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer$ConditionObject.h create mode 100644 libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer$Node.h create mode 100644 libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer.h create mode 100644 libjava/java/util/concurrent/locks/Condition.h create mode 100644 libjava/java/util/concurrent/locks/Lock.h create mode 100644 libjava/java/util/concurrent/locks/LockSupport.h create mode 100644 libjava/java/util/concurrent/locks/ReadWriteLock.h create mode 100644 libjava/java/util/concurrent/locks/ReentrantLock$FairSync.h create mode 100644 libjava/java/util/concurrent/locks/ReentrantLock$NonfairSync.h create mode 100644 libjava/java/util/concurrent/locks/ReentrantLock$Sync.h create mode 100644 libjava/java/util/concurrent/locks/ReentrantLock.h create mode 100644 libjava/java/util/concurrent/locks/ReentrantReadWriteLock$FairSync.h create mode 100644 libjava/java/util/concurrent/locks/ReentrantReadWriteLock$NonfairSync.h create mode 100644 libjava/java/util/concurrent/locks/ReentrantReadWriteLock$ReadLock.h create mode 100644 libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync$HoldCounter.h create mode 100644 libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter.h create mode 100644 libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync.h create mode 100644 libjava/java/util/concurrent/locks/ReentrantReadWriteLock$WriteLock.h create mode 100644 libjava/java/util/concurrent/locks/ReentrantReadWriteLock.h (limited to 'libjava/java/util/concurrent/locks') diff --git a/libjava/java/util/concurrent/locks/AbstractOwnableSynchronizer.h b/libjava/java/util/concurrent/locks/AbstractOwnableSynchronizer.h new file mode 100644 index 000000000..8a14257c9 --- /dev/null +++ b/libjava/java/util/concurrent/locks/AbstractOwnableSynchronizer.h @@ -0,0 +1,25 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_AbstractOwnableSynchronizer__ +#define __java_util_concurrent_locks_AbstractOwnableSynchronizer__ + +#pragma interface + +#include + +class java::util::concurrent::locks::AbstractOwnableSynchronizer : public ::java::lang::Object +{ + +public: // actually protected + AbstractOwnableSynchronizer(); + virtual void setExclusiveOwnerThread(::java::lang::Thread *); + virtual ::java::lang::Thread * getExclusiveOwnerThread(); +private: + static const jlong serialVersionUID = 3737899427754241961LL; + ::java::lang::Thread * __attribute__((aligned(__alignof__( ::java::lang::Object)))) exclusiveOwnerThread; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_AbstractOwnableSynchronizer__ diff --git a/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer$ConditionObject.h b/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer$ConditionObject.h new file mode 100644 index 000000000..123ab81b5 --- /dev/null +++ b/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer$ConditionObject.h @@ -0,0 +1,52 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_AbstractQueuedLongSynchronizer$ConditionObject__ +#define __java_util_concurrent_locks_AbstractQueuedLongSynchronizer$ConditionObject__ + +#pragma interface + +#include + +class java::util::concurrent::locks::AbstractQueuedLongSynchronizer$ConditionObject : public ::java::lang::Object +{ + +public: + AbstractQueuedLongSynchronizer$ConditionObject(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer *); +private: + ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * addConditionWaiter(); + void doSignal(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + void doSignalAll(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + jboolean isOnConditionQueue(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + void unlinkCancelledWaiter(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); +public: + virtual void signal(); + virtual void signalAll(); + virtual void awaitUninterruptibly(); +private: + jint checkInterruptWhileWaiting(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + void reportInterruptAfterWait(jint); +public: + virtual void await(); + virtual jlong awaitNanos(jlong); + virtual jboolean awaitUntil(::java::util::Date *); + virtual jboolean await(jlong, ::java::util::concurrent::TimeUnit *); +public: // actually package-private + virtual jboolean isOwnedBy(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer *); +public: // actually protected + virtual jboolean hasWaiters(); + virtual jint getWaitQueueLength(); + virtual ::java::util::Collection * getWaitingThreads(); +private: + static const jlong serialVersionUID = 1173984872572414699LL; + ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * __attribute__((aligned(__alignof__( ::java::lang::Object)))) firstWaiter; + ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * lastWaiter; + static const jint REINTERRUPT = 1; + static const jint THROW_IE = -1; +public: // actually package-private + ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer * this$0; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_AbstractQueuedLongSynchronizer$ConditionObject__ diff --git a/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer$Node.h b/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer$Node.h new file mode 100644 index 000000000..097692062 --- /dev/null +++ b/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer$Node.h @@ -0,0 +1,34 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_AbstractQueuedLongSynchronizer$Node__ +#define __java_util_concurrent_locks_AbstractQueuedLongSynchronizer$Node__ + +#pragma interface + +#include + +class java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node : public ::java::lang::Object +{ + +public: // actually package-private + jboolean isShared(); + ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * predecessor(); + AbstractQueuedLongSynchronizer$Node(); + AbstractQueuedLongSynchronizer$Node(::java::lang::Thread *, ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + AbstractQueuedLongSynchronizer$Node(::java::lang::Thread *, jint); + static const jint CANCELLED = 1; + static const jint SIGNAL = -1; + static const jint CONDITION = -2; + static ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * SHARED; + static ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * EXCLUSIVE; + jint volatile __attribute__((aligned(__alignof__( ::java::lang::Object)))) waitStatus; + ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * volatile prev; + ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * volatile next; + ::java::lang::Thread * volatile thread; + ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * nextWaiter; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_AbstractQueuedLongSynchronizer$Node__ diff --git a/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.h b/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.h new file mode 100644 index 000000000..41f1f7cba --- /dev/null +++ b/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.h @@ -0,0 +1,115 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_AbstractQueuedLongSynchronizer__ +#define __java_util_concurrent_locks_AbstractQueuedLongSynchronizer__ + +#pragma interface + +#include +extern "Java" +{ + namespace sun + { + namespace misc + { + class Unsafe; + } + } +} + +class java::util::concurrent::locks::AbstractQueuedLongSynchronizer : public ::java::util::concurrent::locks::AbstractOwnableSynchronizer +{ + +public: // actually protected + AbstractQueuedLongSynchronizer(); + virtual jlong getState(); + virtual void setState(jlong); + virtual jboolean compareAndSetState(jlong, jlong); +private: + ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * enq(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * addWaiter(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + void setHead(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + void unparkSuccessor(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + void setHeadAndPropagate(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *, jlong); + void cancelAcquire(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + static jboolean shouldParkAfterFailedAcquire(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *, ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + static void selfInterrupt(); + jboolean parkAndCheckInterrupt(); +public: // actually package-private + virtual jboolean acquireQueued(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *, jlong); +private: + void doAcquireInterruptibly(jlong); + jboolean doAcquireNanos(jlong, jlong); + void doAcquireShared(jlong); + void doAcquireSharedInterruptibly(jlong); + jboolean doAcquireSharedNanos(jlong, jlong); +public: // actually protected + virtual jboolean tryAcquire(jlong); + virtual jboolean tryRelease(jlong); + virtual jlong tryAcquireShared(jlong); + virtual jboolean tryReleaseShared(jlong); + virtual jboolean isHeldExclusively(); +public: + virtual void acquire(jlong); + virtual void acquireInterruptibly(jlong); + virtual jboolean tryAcquireNanos(jlong, jlong); + virtual jboolean release(jlong); + virtual void acquireShared(jlong); + virtual void acquireSharedInterruptibly(jlong); + virtual jboolean tryAcquireSharedNanos(jlong, jlong); + virtual jboolean releaseShared(jlong); + virtual jboolean hasQueuedThreads(); + virtual jboolean hasContended(); + virtual ::java::lang::Thread * getFirstQueuedThread(); +private: + ::java::lang::Thread * fullGetFirstQueuedThread(); +public: + virtual jboolean isQueued(::java::lang::Thread *); +public: // actually package-private + virtual jboolean apparentlyFirstQueuedIsExclusive(); + virtual jboolean isFirst(::java::lang::Thread *); + virtual jboolean fullIsFirst(::java::lang::Thread *); +public: + virtual jint getQueueLength(); + virtual ::java::util::Collection * getQueuedThreads(); + virtual ::java::util::Collection * getExclusiveQueuedThreads(); + virtual ::java::util::Collection * getSharedQueuedThreads(); + virtual ::java::lang::String * toString(); +public: // actually package-private + virtual jboolean isOnSyncQueue(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); +private: + jboolean findNodeFromTail(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); +public: // actually package-private + virtual jboolean transferForSignal(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + virtual jboolean transferAfterCancelledWait(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + virtual jlong fullyRelease(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); +public: + virtual jboolean owns(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$ConditionObject *); + virtual jboolean hasWaiters(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$ConditionObject *); + virtual jint getWaitQueueLength(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$ConditionObject *); + virtual ::java::util::Collection * getWaitingThreads(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$ConditionObject *); +private: + jboolean compareAndSetHead(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + jboolean compareAndSetTail(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *, ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *); + static jboolean compareAndSetWaitStatus(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *, jint, jint); +public: // actually package-private + static void access$0(); +private: + static const jlong serialVersionUID = 7373984972572414692LL; + ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * volatile __attribute__((aligned(__alignof__( ::java::util::concurrent::locks::AbstractOwnableSynchronizer)))) head; + ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * volatile tail; + jlong volatile state; +public: // actually package-private + static const jlong spinForTimeoutThreshold = 1000LL; +private: + static ::sun::misc::Unsafe * unsafe; + static jlong stateOffset; + static jlong headOffset; + static jlong tailOffset; + static jlong waitStatusOffset; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_AbstractQueuedLongSynchronizer__ diff --git a/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer$ConditionObject.h b/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer$ConditionObject.h new file mode 100644 index 000000000..67ca64f6e --- /dev/null +++ b/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer$ConditionObject.h @@ -0,0 +1,52 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_AbstractQueuedSynchronizer$ConditionObject__ +#define __java_util_concurrent_locks_AbstractQueuedSynchronizer$ConditionObject__ + +#pragma interface + +#include + +class java::util::concurrent::locks::AbstractQueuedSynchronizer$ConditionObject : public ::java::lang::Object +{ + +public: + AbstractQueuedSynchronizer$ConditionObject(::java::util::concurrent::locks::AbstractQueuedSynchronizer *); +private: + ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * addConditionWaiter(); + void doSignal(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + void doSignalAll(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + jboolean isOnConditionQueue(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + void unlinkCancelledWaiter(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); +public: + virtual void signal(); + virtual void signalAll(); + virtual void awaitUninterruptibly(); +private: + jint checkInterruptWhileWaiting(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + void reportInterruptAfterWait(jint); +public: + virtual void await(); + virtual jlong awaitNanos(jlong); + virtual jboolean awaitUntil(::java::util::Date *); + virtual jboolean await(jlong, ::java::util::concurrent::TimeUnit *); +public: // actually package-private + virtual jboolean isOwnedBy(::java::util::concurrent::locks::AbstractQueuedSynchronizer *); +public: // actually protected + virtual jboolean hasWaiters(); + virtual jint getWaitQueueLength(); + virtual ::java::util::Collection * getWaitingThreads(); +private: + static const jlong serialVersionUID = 1173984872572414699LL; + ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * __attribute__((aligned(__alignof__( ::java::lang::Object)))) firstWaiter; + ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * lastWaiter; + static const jint REINTERRUPT = 1; + static const jint THROW_IE = -1; +public: // actually package-private + ::java::util::concurrent::locks::AbstractQueuedSynchronizer * this$0; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_AbstractQueuedSynchronizer$ConditionObject__ diff --git a/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer$Node.h b/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer$Node.h new file mode 100644 index 000000000..cc4955057 --- /dev/null +++ b/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer$Node.h @@ -0,0 +1,34 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_AbstractQueuedSynchronizer$Node__ +#define __java_util_concurrent_locks_AbstractQueuedSynchronizer$Node__ + +#pragma interface + +#include + +class java::util::concurrent::locks::AbstractQueuedSynchronizer$Node : public ::java::lang::Object +{ + +public: // actually package-private + jboolean isShared(); + ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * predecessor(); + AbstractQueuedSynchronizer$Node(); + AbstractQueuedSynchronizer$Node(::java::lang::Thread *, ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + AbstractQueuedSynchronizer$Node(::java::lang::Thread *, jint); + static const jint CANCELLED = 1; + static const jint SIGNAL = -1; + static const jint CONDITION = -2; + static ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * SHARED; + static ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * EXCLUSIVE; + jint volatile __attribute__((aligned(__alignof__( ::java::lang::Object)))) waitStatus; + ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * volatile prev; + ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * volatile next; + ::java::lang::Thread * volatile thread; + ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * nextWaiter; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_AbstractQueuedSynchronizer$Node__ diff --git a/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer.h b/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer.h new file mode 100644 index 000000000..e50fcef61 --- /dev/null +++ b/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer.h @@ -0,0 +1,115 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_AbstractQueuedSynchronizer__ +#define __java_util_concurrent_locks_AbstractQueuedSynchronizer__ + +#pragma interface + +#include +extern "Java" +{ + namespace sun + { + namespace misc + { + class Unsafe; + } + } +} + +class java::util::concurrent::locks::AbstractQueuedSynchronizer : public ::java::util::concurrent::locks::AbstractOwnableSynchronizer +{ + +public: // actually protected + AbstractQueuedSynchronizer(); + virtual jint getState(); + virtual void setState(jint); + virtual jboolean compareAndSetState(jint, jint); +private: + ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * enq(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * addWaiter(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + void setHead(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + void unparkSuccessor(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + void setHeadAndPropagate(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *, jint); + void cancelAcquire(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + static jboolean shouldParkAfterFailedAcquire(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *, ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + static void selfInterrupt(); + jboolean parkAndCheckInterrupt(); +public: // actually package-private + virtual jboolean acquireQueued(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *, jint); +private: + void doAcquireInterruptibly(jint); + jboolean doAcquireNanos(jint, jlong); + void doAcquireShared(jint); + void doAcquireSharedInterruptibly(jint); + jboolean doAcquireSharedNanos(jint, jlong); +public: // actually protected + virtual jboolean tryAcquire(jint); + virtual jboolean tryRelease(jint); + virtual jint tryAcquireShared(jint); + virtual jboolean tryReleaseShared(jint); + virtual jboolean isHeldExclusively(); +public: + virtual void acquire(jint); + virtual void acquireInterruptibly(jint); + virtual jboolean tryAcquireNanos(jint, jlong); + virtual jboolean release(jint); + virtual void acquireShared(jint); + virtual void acquireSharedInterruptibly(jint); + virtual jboolean tryAcquireSharedNanos(jint, jlong); + virtual jboolean releaseShared(jint); + virtual jboolean hasQueuedThreads(); + virtual jboolean hasContended(); + virtual ::java::lang::Thread * getFirstQueuedThread(); +private: + ::java::lang::Thread * fullGetFirstQueuedThread(); +public: + virtual jboolean isQueued(::java::lang::Thread *); +public: // actually package-private + virtual jboolean apparentlyFirstQueuedIsExclusive(); + virtual jboolean isFirst(::java::lang::Thread *); + virtual jboolean fullIsFirst(::java::lang::Thread *); +public: + virtual jint getQueueLength(); + virtual ::java::util::Collection * getQueuedThreads(); + virtual ::java::util::Collection * getExclusiveQueuedThreads(); + virtual ::java::util::Collection * getSharedQueuedThreads(); + virtual ::java::lang::String * toString(); +public: // actually package-private + virtual jboolean isOnSyncQueue(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); +private: + jboolean findNodeFromTail(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); +public: // actually package-private + virtual jboolean transferForSignal(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + virtual jboolean transferAfterCancelledWait(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + virtual jint fullyRelease(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); +public: + virtual jboolean owns(::java::util::concurrent::locks::AbstractQueuedSynchronizer$ConditionObject *); + virtual jboolean hasWaiters(::java::util::concurrent::locks::AbstractQueuedSynchronizer$ConditionObject *); + virtual jint getWaitQueueLength(::java::util::concurrent::locks::AbstractQueuedSynchronizer$ConditionObject *); + virtual ::java::util::Collection * getWaitingThreads(::java::util::concurrent::locks::AbstractQueuedSynchronizer$ConditionObject *); +private: + jboolean compareAndSetHead(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + jboolean compareAndSetTail(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *, ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *); + static jboolean compareAndSetWaitStatus(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *, jint, jint); +public: // actually package-private + static void access$0(); +private: + static const jlong serialVersionUID = 7373984972572414691LL; + ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * volatile __attribute__((aligned(__alignof__( ::java::util::concurrent::locks::AbstractOwnableSynchronizer)))) head; + ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * volatile tail; + jint volatile state; +public: // actually package-private + static const jlong spinForTimeoutThreshold = 1000LL; +private: + static ::sun::misc::Unsafe * unsafe; + static jlong stateOffset; + static jlong headOffset; + static jlong tailOffset; + static jlong waitStatusOffset; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_AbstractQueuedSynchronizer__ diff --git a/libjava/java/util/concurrent/locks/Condition.h b/libjava/java/util/concurrent/locks/Condition.h new file mode 100644 index 000000000..141a4e919 --- /dev/null +++ b/libjava/java/util/concurrent/locks/Condition.h @@ -0,0 +1,25 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_Condition__ +#define __java_util_concurrent_locks_Condition__ + +#pragma interface + +#include + +class java::util::concurrent::locks::Condition : public ::java::lang::Object +{ + +public: + virtual void await() = 0; + virtual void awaitUninterruptibly() = 0; + virtual jlong awaitNanos(jlong) = 0; + virtual jboolean await(jlong, ::java::util::concurrent::TimeUnit *) = 0; + virtual jboolean awaitUntil(::java::util::Date *) = 0; + virtual void signal() = 0; + virtual void signalAll() = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __java_util_concurrent_locks_Condition__ diff --git a/libjava/java/util/concurrent/locks/Lock.h b/libjava/java/util/concurrent/locks/Lock.h new file mode 100644 index 000000000..b00f601e7 --- /dev/null +++ b/libjava/java/util/concurrent/locks/Lock.h @@ -0,0 +1,24 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_Lock__ +#define __java_util_concurrent_locks_Lock__ + +#pragma interface + +#include + +class java::util::concurrent::locks::Lock : public ::java::lang::Object +{ + +public: + virtual void lock() = 0; + virtual void lockInterruptibly() = 0; + virtual jboolean tryLock() = 0; + virtual jboolean tryLock(jlong, ::java::util::concurrent::TimeUnit *) = 0; + virtual void unlock() = 0; + virtual ::java::util::concurrent::locks::Condition * newCondition() = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __java_util_concurrent_locks_Lock__ diff --git a/libjava/java/util/concurrent/locks/LockSupport.h b/libjava/java/util/concurrent/locks/LockSupport.h new file mode 100644 index 000000000..15ef7306f --- /dev/null +++ b/libjava/java/util/concurrent/locks/LockSupport.h @@ -0,0 +1,42 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_LockSupport__ +#define __java_util_concurrent_locks_LockSupport__ + +#pragma interface + +#include +extern "Java" +{ + namespace sun + { + namespace misc + { + class Unsafe; + } + } +} + +class java::util::concurrent::locks::LockSupport : public ::java::lang::Object +{ + + LockSupport(); + static void setBlocker(::java::lang::Thread *, ::java::lang::Object *); +public: + static void unpark(::java::lang::Thread *); + static void park(::java::lang::Object *); + static void parkNanos(::java::lang::Object *, jlong); + static void parkUntil(::java::lang::Object *, jlong); + static ::java::lang::Object * getBlocker(::java::lang::Thread *); + static void park(); + static void parkNanos(jlong); + static void parkUntil(jlong); +private: + static ::sun::misc::Unsafe * unsafe; + static jlong parkBlockerOffset; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_LockSupport__ diff --git a/libjava/java/util/concurrent/locks/ReadWriteLock.h b/libjava/java/util/concurrent/locks/ReadWriteLock.h new file mode 100644 index 000000000..1f4ae2e72 --- /dev/null +++ b/libjava/java/util/concurrent/locks/ReadWriteLock.h @@ -0,0 +1,20 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_ReadWriteLock__ +#define __java_util_concurrent_locks_ReadWriteLock__ + +#pragma interface + +#include + +class java::util::concurrent::locks::ReadWriteLock : public ::java::lang::Object +{ + +public: + virtual ::java::util::concurrent::locks::Lock * readLock() = 0; + virtual ::java::util::concurrent::locks::Lock * writeLock() = 0; + static ::java::lang::Class class$; +} __attribute__ ((java_interface)); + +#endif // __java_util_concurrent_locks_ReadWriteLock__ diff --git a/libjava/java/util/concurrent/locks/ReentrantLock$FairSync.h b/libjava/java/util/concurrent/locks/ReentrantLock$FairSync.h new file mode 100644 index 000000000..d4268afcd --- /dev/null +++ b/libjava/java/util/concurrent/locks/ReentrantLock$FairSync.h @@ -0,0 +1,25 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_ReentrantLock$FairSync__ +#define __java_util_concurrent_locks_ReentrantLock$FairSync__ + +#pragma interface + +#include + +class java::util::concurrent::locks::ReentrantLock$FairSync : public ::java::util::concurrent::locks::ReentrantLock$Sync +{ + +public: // actually package-private + ReentrantLock$FairSync(); + void lock(); +public: // actually protected + jboolean tryAcquire(jint); +private: + static const jlong serialVersionUID = -3000897897090466540LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_ReentrantLock$FairSync__ diff --git a/libjava/java/util/concurrent/locks/ReentrantLock$NonfairSync.h b/libjava/java/util/concurrent/locks/ReentrantLock$NonfairSync.h new file mode 100644 index 000000000..743a0bd75 --- /dev/null +++ b/libjava/java/util/concurrent/locks/ReentrantLock$NonfairSync.h @@ -0,0 +1,25 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_ReentrantLock$NonfairSync__ +#define __java_util_concurrent_locks_ReentrantLock$NonfairSync__ + +#pragma interface + +#include + +class java::util::concurrent::locks::ReentrantLock$NonfairSync : public ::java::util::concurrent::locks::ReentrantLock$Sync +{ + +public: // actually package-private + ReentrantLock$NonfairSync(); + void lock(); +public: // actually protected + jboolean tryAcquire(jint); +private: + static const jlong serialVersionUID = 7316153563782823691LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_ReentrantLock$NonfairSync__ diff --git a/libjava/java/util/concurrent/locks/ReentrantLock$Sync.h b/libjava/java/util/concurrent/locks/ReentrantLock$Sync.h new file mode 100644 index 000000000..b3656d0df --- /dev/null +++ b/libjava/java/util/concurrent/locks/ReentrantLock$Sync.h @@ -0,0 +1,33 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_ReentrantLock$Sync__ +#define __java_util_concurrent_locks_ReentrantLock$Sync__ + +#pragma interface + +#include + +class java::util::concurrent::locks::ReentrantLock$Sync : public ::java::util::concurrent::locks::AbstractQueuedSynchronizer +{ + +public: // actually package-private + ReentrantLock$Sync(); + virtual void lock() = 0; + virtual jboolean nonfairTryAcquire(jint); +public: // actually protected + virtual jboolean tryRelease(jint); + virtual jboolean isHeldExclusively(); +public: // actually package-private + virtual ::java::util::concurrent::locks::AbstractQueuedSynchronizer$ConditionObject * newCondition(); + virtual ::java::lang::Thread * getOwner(); + virtual jint getHoldCount(); + virtual jboolean isLocked(); +private: + void readObject(::java::io::ObjectInputStream *); + static const jlong serialVersionUID = -5179523762034025860LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_ReentrantLock$Sync__ diff --git a/libjava/java/util/concurrent/locks/ReentrantLock.h b/libjava/java/util/concurrent/locks/ReentrantLock.h new file mode 100644 index 000000000..5cac4b27f --- /dev/null +++ b/libjava/java/util/concurrent/locks/ReentrantLock.h @@ -0,0 +1,49 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_ReentrantLock__ +#define __java_util_concurrent_locks_ReentrantLock__ + +#pragma interface + +#include + +class java::util::concurrent::locks::ReentrantLock : public ::java::lang::Object +{ + +public: + ReentrantLock(); + ReentrantLock(jboolean); + virtual void lock(); + virtual void lockInterruptibly(); + virtual jboolean tryLock(); + virtual jboolean tryLock(jlong, ::java::util::concurrent::TimeUnit *); + virtual void unlock(); + virtual ::java::util::concurrent::locks::Condition * newCondition(); + virtual jint getHoldCount(); + virtual jboolean isHeldByCurrentThread(); + virtual jboolean isLocked(); + virtual jboolean isFair(); +public: // actually protected + virtual ::java::lang::Thread * getOwner(); +public: + virtual jboolean hasQueuedThreads(); + virtual jboolean hasQueuedThread(::java::lang::Thread *); + virtual jint getQueueLength(); +public: // actually protected + virtual ::java::util::Collection * getQueuedThreads(); +public: + virtual jboolean hasWaiters(::java::util::concurrent::locks::Condition *); + virtual jint getWaitQueueLength(::java::util::concurrent::locks::Condition *); +public: // actually protected + virtual ::java::util::Collection * getWaitingThreads(::java::util::concurrent::locks::Condition *); +public: + virtual ::java::lang::String * toString(); +private: + static const jlong serialVersionUID = 7373984872572414699LL; + ::java::util::concurrent::locks::ReentrantLock$Sync * __attribute__((aligned(__alignof__( ::java::lang::Object)))) sync; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_ReentrantLock__ diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$FairSync.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$FairSync.h new file mode 100644 index 000000000..05090b5b1 --- /dev/null +++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$FairSync.h @@ -0,0 +1,24 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock$FairSync__ +#define __java_util_concurrent_locks_ReentrantReadWriteLock$FairSync__ + +#pragma interface + +#include + +class java::util::concurrent::locks::ReentrantReadWriteLock$FairSync : public ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync +{ + +public: // actually package-private + ReentrantReadWriteLock$FairSync(); + jboolean writerShouldBlock(::java::lang::Thread *); + jboolean readerShouldBlock(::java::lang::Thread *); +private: + static const jlong serialVersionUID = -2274990926593161451LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_ReentrantReadWriteLock$FairSync__ diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$NonfairSync.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$NonfairSync.h new file mode 100644 index 000000000..29a565ae4 --- /dev/null +++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$NonfairSync.h @@ -0,0 +1,24 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock$NonfairSync__ +#define __java_util_concurrent_locks_ReentrantReadWriteLock$NonfairSync__ + +#pragma interface + +#include + +class java::util::concurrent::locks::ReentrantReadWriteLock$NonfairSync : public ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync +{ + +public: // actually package-private + ReentrantReadWriteLock$NonfairSync(); + jboolean writerShouldBlock(::java::lang::Thread *); + jboolean readerShouldBlock(::java::lang::Thread *); +private: + static const jlong serialVersionUID = -8159625535654395037LL; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_ReentrantReadWriteLock$NonfairSync__ diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$ReadLock.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$ReadLock.h new file mode 100644 index 000000000..0f48a6cb8 --- /dev/null +++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$ReadLock.h @@ -0,0 +1,31 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock$ReadLock__ +#define __java_util_concurrent_locks_ReentrantReadWriteLock$ReadLock__ + +#pragma interface + +#include + +class java::util::concurrent::locks::ReentrantReadWriteLock$ReadLock : public ::java::lang::Object +{ + +public: // actually protected + ReentrantReadWriteLock$ReadLock(::java::util::concurrent::locks::ReentrantReadWriteLock *); +public: + virtual void lock(); + virtual void lockInterruptibly(); + virtual jboolean tryLock(); + virtual jboolean tryLock(jlong, ::java::util::concurrent::TimeUnit *); + virtual void unlock(); + virtual ::java::util::concurrent::locks::Condition * newCondition(); + virtual ::java::lang::String * toString(); +private: + static const jlong serialVersionUID = -5992448646407690164LL; + ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync * __attribute__((aligned(__alignof__( ::java::lang::Object)))) sync; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_ReentrantReadWriteLock$ReadLock__ diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync$HoldCounter.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync$HoldCounter.h new file mode 100644 index 000000000..4813f0d8f --- /dev/null +++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync$HoldCounter.h @@ -0,0 +1,23 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock$Sync$HoldCounter__ +#define __java_util_concurrent_locks_ReentrantReadWriteLock$Sync$HoldCounter__ + +#pragma interface + +#include + +class java::util::concurrent::locks::ReentrantReadWriteLock$Sync$HoldCounter : public ::java::lang::Object +{ + +public: // actually package-private + ReentrantReadWriteLock$Sync$HoldCounter(); + jint tryDecrement(); + jint __attribute__((aligned(__alignof__( ::java::lang::Object)))) count; + jlong tid; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_ReentrantReadWriteLock$Sync$HoldCounter__ diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter.h new file mode 100644 index 000000000..10f87c922 --- /dev/null +++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter.h @@ -0,0 +1,22 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter__ +#define __java_util_concurrent_locks_ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter__ + +#pragma interface + +#include + +class java::util::concurrent::locks::ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter : public ::java::lang::ThreadLocal +{ + +public: // actually package-private + ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter(); +public: + ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync$HoldCounter * ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter$initialValue(); + ::java::lang::Object * initialValue(); + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter__ diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync.h new file mode 100644 index 000000000..d1d43078f --- /dev/null +++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync.h @@ -0,0 +1,55 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock$Sync__ +#define __java_util_concurrent_locks_ReentrantReadWriteLock$Sync__ + +#pragma interface + +#include + +class java::util::concurrent::locks::ReentrantReadWriteLock$Sync : public ::java::util::concurrent::locks::AbstractQueuedSynchronizer +{ + +public: // actually package-private + static jint sharedCount(jint); + static jint exclusiveCount(jint); + ReentrantReadWriteLock$Sync(); + virtual jboolean readerShouldBlock(::java::lang::Thread *) = 0; + virtual jboolean writerShouldBlock(::java::lang::Thread *) = 0; +public: // actually protected + virtual jboolean tryRelease(jint); + virtual jboolean tryAcquire(jint); + virtual jboolean tryReleaseShared(jint); + virtual jint tryAcquireShared(jint); +public: // actually package-private + virtual jint fullTryAcquireShared(::java::lang::Thread *); + virtual jboolean tryWriteLock(); + virtual jboolean tryReadLock(); +public: // actually protected + virtual jboolean isHeldExclusively(); +public: // actually package-private + virtual ::java::util::concurrent::locks::AbstractQueuedSynchronizer$ConditionObject * newCondition(); + virtual ::java::lang::Thread * getOwner(); + virtual jint getReadLockCount(); + virtual jboolean isWriteLocked(); + virtual jint getWriteHoldCount(); + virtual jint getReadHoldCount(); +private: + void readObject(::java::io::ObjectInputStream *); +public: // actually package-private + virtual jint getCount(); +private: + static const jlong serialVersionUID = 6317671515068378041LL; +public: // actually package-private + static const jint SHARED_SHIFT = 16; + static const jint SHARED_UNIT = 65536; + static const jint MAX_COUNT = 65535; + static const jint EXCLUSIVE_MASK = 65535; + ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter * __attribute__((aligned(__alignof__( ::java::util::concurrent::locks::AbstractQueuedSynchronizer)))) readHolds; + ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync$HoldCounter * cachedHoldCounter; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_ReentrantReadWriteLock$Sync__ diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$WriteLock.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$WriteLock.h new file mode 100644 index 000000000..4e57d53c6 --- /dev/null +++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$WriteLock.h @@ -0,0 +1,33 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock$WriteLock__ +#define __java_util_concurrent_locks_ReentrantReadWriteLock$WriteLock__ + +#pragma interface + +#include + +class java::util::concurrent::locks::ReentrantReadWriteLock$WriteLock : public ::java::lang::Object +{ + +public: // actually protected + ReentrantReadWriteLock$WriteLock(::java::util::concurrent::locks::ReentrantReadWriteLock *); +public: + virtual void lock(); + virtual void lockInterruptibly(); + virtual jboolean tryLock(); + virtual jboolean tryLock(jlong, ::java::util::concurrent::TimeUnit *); + virtual void unlock(); + virtual ::java::util::concurrent::locks::Condition * newCondition(); + virtual ::java::lang::String * toString(); + virtual jboolean isHeldByCurrentThread(); + virtual jint getHoldCount(); +private: + static const jlong serialVersionUID = -4992448646407690164LL; + ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync * __attribute__((aligned(__alignof__( ::java::lang::Object)))) sync; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_ReentrantReadWriteLock$WriteLock__ diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock.h new file mode 100644 index 000000000..e7da50a75 --- /dev/null +++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock.h @@ -0,0 +1,57 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock__ +#define __java_util_concurrent_locks_ReentrantReadWriteLock__ + +#pragma interface + +#include + +class java::util::concurrent::locks::ReentrantReadWriteLock : public ::java::lang::Object +{ + +public: + ReentrantReadWriteLock(); + ReentrantReadWriteLock(jboolean); + virtual ::java::util::concurrent::locks::ReentrantReadWriteLock$WriteLock * ReentrantReadWriteLock$writeLock(); + virtual ::java::util::concurrent::locks::ReentrantReadWriteLock$ReadLock * ReentrantReadWriteLock$readLock(); + virtual jboolean isFair(); +public: // actually protected + virtual ::java::lang::Thread * getOwner(); +public: + virtual jint getReadLockCount(); + virtual jboolean isWriteLocked(); + virtual jboolean isWriteLockedByCurrentThread(); + virtual jint getWriteHoldCount(); + virtual jint getReadHoldCount(); +public: // actually protected + virtual ::java::util::Collection * getQueuedWriterThreads(); + virtual ::java::util::Collection * getQueuedReaderThreads(); +public: + virtual jboolean hasQueuedThreads(); + virtual jboolean hasQueuedThread(::java::lang::Thread *); + virtual jint getQueueLength(); +public: // actually protected + virtual ::java::util::Collection * getQueuedThreads(); +public: + virtual jboolean hasWaiters(::java::util::concurrent::locks::Condition *); + virtual jint getWaitQueueLength(::java::util::concurrent::locks::Condition *); +public: // actually protected + virtual ::java::util::Collection * getWaitingThreads(::java::util::concurrent::locks::Condition *); +public: + virtual ::java::lang::String * toString(); + virtual ::java::util::concurrent::locks::Lock * readLock(); + virtual ::java::util::concurrent::locks::Lock * writeLock(); +public: // actually package-private + static ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync * access$2(::java::util::concurrent::locks::ReentrantReadWriteLock *); +private: + static const jlong serialVersionUID = -6992448646407690164LL; + ::java::util::concurrent::locks::ReentrantReadWriteLock$ReadLock * __attribute__((aligned(__alignof__( ::java::lang::Object)))) readerLock; + ::java::util::concurrent::locks::ReentrantReadWriteLock$WriteLock * writerLock; + ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync * sync; +public: + static ::java::lang::Class class$; +}; + +#endif // __java_util_concurrent_locks_ReentrantReadWriteLock__ -- cgit v1.2.3