public convenience init?( casting object: java_swift.JavaObject, _ file: StaticString = #file, _ line: Int = #line ) {

self.init( javaObject: nil )

object.withJavaObject {

self.javaObject = $0

}

}

private static var AbstractQueuedSynchronizerJNIClass: jclass?

/// private static final long java.util.concurrent.locks.AbstractQueuedSynchronizer.headOffset

/// private static final long java.util.concurrent.locks.AbstractQueuedSynchronizer.nextOffset

/// private static final long java.util.concurrent.locks.AbstractQueuedSynchronizer.serialVersionUID

/// static final long java.util.concurrent.locks.AbstractQueuedSynchronizer.spinForTimeoutThreshold

// Skipping field: true false false false false false

/// private static final long java.util.concurrent.locks.AbstractQueuedSynchronizer.stateOffset

/// private static final long java.util.concurrent.locks.AbstractQueuedSynchronizer.tailOffset

/// private static final sun.misc.Unsafe java.util.concurrent.locks.AbstractQueuedSynchronizer.unsafe

/// private static final long java.util.concurrent.locks.AbstractQueuedSynchronizer.waitStatusOffset

/// private transient volatile java.util.concurrent.locks.AbstractQueuedSynchronizer$Node java.util.concurrent.locks.AbstractQueuedSynchronizer.head

/// private volatile int java.util.concurrent.locks.AbstractQueuedSynchronizer.state

/// private transient volatile java.util.concurrent.locks.AbstractQueuedSynchronizer$Node java.util.concurrent.locks.AbstractQueuedSynchronizer.tail

/// private static final long java.util.concurrent.locks.AbstractOwnableSynchronizer.serialVersionUID

/// private transient java.lang.Thread java.util.concurrent.locks.AbstractOwnableSynchronizer.exclusiveOwnerThread

/// protected java.util.concurrent.locks.AbstractQueuedSynchronizer()

private static var new_MethodID_1: jmethodID?

public convenience init() {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

let __object = JNIMethod.NewObject( className: "java/util/concurrent/locks/AbstractQueuedSynchronizer", classCache: &AbstractQueuedSynchronizer.AbstractQueuedSynchronizerJNIClass, methodSig: "()V", methodCache: &AbstractQueuedSynchronizer.new_MethodID_1, args: &__args, locals: &__locals )

self.init( javaObject: __object )

JNI.DeleteLocalRef( __object )

}

/// private static final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.compareAndSetNext(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node,java.util.concurrent.locks.AbstractQueuedSynchronizer$Node,java.util.concurrent.locks.AbstractQueuedSynchronizer$Node)

/// private static final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.compareAndSetWaitStatus(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node,int,int)

/// static void java.util.concurrent.locks.AbstractQueuedSynchronizer.selfInterrupt()

// Skipping method: true false false false false

/// private static boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.shouldParkAfterFailedAcquire(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node,java.util.concurrent.locks.AbstractQueuedSynchronizer$Node)

/// public final void java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(int)

private static var acquire_MethodID_2: jmethodID?

open func acquire( arg: Int ) {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = jvalue( i: jint(arg) )

JNIMethod.CallVoidMethod( object: javaObject, methodName: "acquire", methodSig: "(I)V", methodCache: &AbstractQueuedSynchronizer.acquire_MethodID_2, args: &__args, locals: &__locals )

}

open func acquire( _ _arg: Int ) {

acquire( arg: _arg )

}

/// public final void java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(int) throws java.lang.InterruptedException

private static var acquireInterruptibly_MethodID_3: jmethodID?

open func acquireInterruptibly( arg: Int ) throws /* java.lang.InterruptedException */ {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = jvalue( i: jint(arg) )

JNIMethod.CallVoidMethod( object: javaObject, methodName: "acquireInterruptibly", methodSig: "(I)V", methodCache: &AbstractQueuedSynchronizer.acquireInterruptibly_MethodID_3, args: &__args, locals: &__locals )

if let throwable = JNI.ExceptionCheck() {

defer { JNI.DeleteLocalRef( throwable ) }

throw java_lang.InterruptedException( javaObject: throwable )

}

}

open func acquireInterruptibly( _ _arg: Int ) throws /* java.lang.InterruptedException */ {

try acquireInterruptibly( arg: _arg )

}

/// final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node,int)

// Skipping method: true false false false false

/// public final void java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireShared(int)

private static var acquireShared_MethodID_4: jmethodID?

open func acquireShared( arg: Int ) {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = jvalue( i: jint(arg) )

JNIMethod.CallVoidMethod( object: javaObject, methodName: "acquireShared", methodSig: "(I)V", methodCache: &AbstractQueuedSynchronizer.acquireShared_MethodID_4, args: &__args, locals: &__locals )

}

open func acquireShared( _ _arg: Int ) {

acquireShared( arg: _arg )

}

/// public final void java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireSharedInterruptibly(int) throws java.lang.InterruptedException

private static var acquireSharedInterruptibly_MethodID_5: jmethodID?

open func acquireSharedInterruptibly( arg: Int ) throws /* java.lang.InterruptedException */ {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = jvalue( i: jint(arg) )

JNIMethod.CallVoidMethod( object: javaObject, methodName: "acquireSharedInterruptibly", methodSig: "(I)V", methodCache: &AbstractQueuedSynchronizer.acquireSharedInterruptibly_MethodID_5, args: &__args, locals: &__locals )

if let throwable = JNI.ExceptionCheck() {

defer { JNI.DeleteLocalRef( throwable ) }

throw java_lang.InterruptedException( javaObject: throwable )

}

}

open func acquireSharedInterruptibly( _ _arg: Int ) throws /* java.lang.InterruptedException */ {

try acquireSharedInterruptibly( arg: _arg )

}

/// private java.util.concurrent.locks.AbstractQueuedSynchronizer$Node java.util.concurrent.locks.AbstractQueuedSynchronizer.addWaiter(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node)

/// final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.apparentlyFirstQueuedIsExclusive()

// Skipping method: true false false false false

/// private void java.util.concurrent.locks.AbstractQueuedSynchronizer.cancelAcquire(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node)

/// private final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.compareAndSetHead(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node)

/// protected final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.compareAndSetState(int,int)

private static var compareAndSetState_MethodID_6: jmethodID?

open func compareAndSetState( expect: Int, update: Int ) -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 2 )

__args[0] = jvalue( i: jint(expect) )

__args[1] = jvalue( i: jint(update) )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "compareAndSetState", methodSig: "(II)Z", methodCache: &AbstractQueuedSynchronizer.compareAndSetState_MethodID_6, args: &__args, locals: &__locals )

return __return != jboolean(JNI_FALSE)

}

open func compareAndSetState( _ _expect: Int, _ _update: Int ) -> Bool {

return compareAndSetState( expect: _expect, update: _update )

}

/// private final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.compareAndSetTail(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node,java.util.concurrent.locks.AbstractQueuedSynchronizer$Node)

/// private void java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(int) throws java.lang.InterruptedException

/// private boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireNanos(int,long) throws java.lang.InterruptedException

/// private void java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireShared(int)

/// private void java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedInterruptibly(int) throws java.lang.InterruptedException

/// private boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireSharedNanos(int,long) throws java.lang.InterruptedException

/// private void java.util.concurrent.locks.AbstractQueuedSynchronizer.doReleaseShared()

/// private java.util.concurrent.locks.AbstractQueuedSynchronizer$Node java.util.concurrent.locks.AbstractQueuedSynchronizer.enq(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node)

/// private boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.findNodeFromTail(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node)

/// private java.lang.Thread java.util.concurrent.locks.AbstractQueuedSynchronizer.fullGetFirstQueuedThread()

/// final int java.util.concurrent.locks.AbstractQueuedSynchronizer.fullyRelease(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node)

// Skipping method: true false false false false

/// public final java.util.Collection java.util.concurrent.locks.AbstractQueuedSynchronizer.getExclusiveQueuedThreads()

private static var getExclusiveQueuedThreads_MethodID_7: jmethodID?

open func getExclusiveQueuedThreads() -> Collection! {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

let __return = JNIMethod.CallObjectMethod( object: javaObject, methodName: "getExclusiveQueuedThreads", methodSig: "()Ljava/util/Collection;", methodCache: &AbstractQueuedSynchronizer.getExclusiveQueuedThreads_MethodID_7, args: &__args, locals: &__locals )

defer { JNI.DeleteLocalRef( __return ) }

return __return != nil ? CollectionForward( javaObject: __return ) : nil

}

/// public final java.lang.Thread java.util.concurrent.locks.AbstractQueuedSynchronizer.getFirstQueuedThread()

private static var getFirstQueuedThread_MethodID_8: jmethodID?

open func getFirstQueuedThread() -> java_swift.JavaThread! {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

let __return = JNIMethod.CallObjectMethod( object: javaObject, methodName: "getFirstQueuedThread", methodSig: "()Ljava/lang/Thread;", methodCache: &AbstractQueuedSynchronizer.getFirstQueuedThread_MethodID_8, args: &__args, locals: &__locals )

defer { JNI.DeleteLocalRef( __return ) }

return __return != nil ? java_swift.JavaThread( javaObject: __return ) : nil

}

/// public final int java.util.concurrent.locks.AbstractQueuedSynchronizer.getQueueLength()

private static var getQueueLength_MethodID_9: jmethodID?

open func getQueueLength() -> Int {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

let __return = JNIMethod.CallIntMethod( object: javaObject, methodName: "getQueueLength", methodSig: "()I", methodCache: &AbstractQueuedSynchronizer.getQueueLength_MethodID_9, args: &__args, locals: &__locals )

return Int(__return)

}

/// public final java.util.Collection java.util.concurrent.locks.AbstractQueuedSynchronizer.getQueuedThreads()

private static var getQueuedThreads_MethodID_10: jmethodID?

open func getQueuedThreads() -> Collection! {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

let __return = JNIMethod.CallObjectMethod( object: javaObject, methodName: "getQueuedThreads", methodSig: "()Ljava/util/Collection;", methodCache: &AbstractQueuedSynchronizer.getQueuedThreads_MethodID_10, args: &__args, locals: &__locals )

defer { JNI.DeleteLocalRef( __return ) }

return __return != nil ? CollectionForward( javaObject: __return ) : nil

}

/// public final java.util.Collection java.util.concurrent.locks.AbstractQueuedSynchronizer.getSharedQueuedThreads()

private static var getSharedQueuedThreads_MethodID_11: jmethodID?

open func getSharedQueuedThreads() -> Collection! {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

let __return = JNIMethod.CallObjectMethod( object: javaObject, methodName: "getSharedQueuedThreads", methodSig: "()Ljava/util/Collection;", methodCache: &AbstractQueuedSynchronizer.getSharedQueuedThreads_MethodID_11, args: &__args, locals: &__locals )

defer { JNI.DeleteLocalRef( __return ) }

return __return != nil ? CollectionForward( javaObject: __return ) : nil

}

/// protected final int java.util.concurrent.locks.AbstractQueuedSynchronizer.getState()

private static var getState_MethodID_12: jmethodID?

open func getState() -> Int {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

let __return = JNIMethod.CallIntMethod( object: javaObject, methodName: "getState", methodSig: "()I", methodCache: &AbstractQueuedSynchronizer.getState_MethodID_12, args: &__args, locals: &__locals )

return Int(__return)

}

/// public final int java.util.concurrent.locks.AbstractQueuedSynchronizer.getWaitQueueLength(java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)

private static var getWaitQueueLength_MethodID_13: jmethodID?

open func getWaitQueueLength( condition: /* class java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject */ UnavailableObject? ) -> Int {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = JNIType.toJava( value: condition, locals: &__locals )

let __return = JNIMethod.CallIntMethod( object: javaObject, methodName: "getWaitQueueLength", methodSig: "(Ljava/util/concurrent/locks/AbstractQueuedSynchronizer$ConditionObject;)I", methodCache: &AbstractQueuedSynchronizer.getWaitQueueLength_MethodID_13, args: &__args, locals: &__locals )

return Int(__return)

}

open func getWaitQueueLength( _ _condition: /* class java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject */ UnavailableObject? ) -> Int {

return getWaitQueueLength( condition: _condition )

}

/// public final java.util.Collection java.util.concurrent.locks.AbstractQueuedSynchronizer.getWaitingThreads(java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)

private static var getWaitingThreads_MethodID_14: jmethodID?

open func getWaitingThreads( condition: /* class java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject */ UnavailableObject? ) -> Collection! {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = JNIType.toJava( value: condition, locals: &__locals )

let __return = JNIMethod.CallObjectMethod( object: javaObject, methodName: "getWaitingThreads", methodSig: "(Ljava/util/concurrent/locks/AbstractQueuedSynchronizer$ConditionObject;)Ljava/util/Collection;", methodCache: &AbstractQueuedSynchronizer.getWaitingThreads_MethodID_14, args: &__args, locals: &__locals )

defer { JNI.DeleteLocalRef( __return ) }

return __return != nil ? CollectionForward( javaObject: __return ) : nil

}

open func getWaitingThreads( _ _condition: /* class java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject */ UnavailableObject? ) -> Collection! {

return getWaitingThreads( condition: _condition )

}

/// public final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.hasContended()

private static var hasContended_MethodID_15: jmethodID?

open func hasContended() -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "hasContended", methodSig: "()Z", methodCache: &AbstractQueuedSynchronizer.hasContended_MethodID_15, args: &__args, locals: &__locals )

return __return != jboolean(JNI_FALSE)

}

/// public final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.hasQueuedPredecessors()

private static var hasQueuedPredecessors_MethodID_16: jmethodID?

open func hasQueuedPredecessors() -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "hasQueuedPredecessors", methodSig: "()Z", methodCache: &AbstractQueuedSynchronizer.hasQueuedPredecessors_MethodID_16, args: &__args, locals: &__locals )

return __return != jboolean(JNI_FALSE)

}

/// public final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.hasQueuedThreads()

private static var hasQueuedThreads_MethodID_17: jmethodID?

open func hasQueuedThreads() -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "hasQueuedThreads", methodSig: "()Z", methodCache: &AbstractQueuedSynchronizer.hasQueuedThreads_MethodID_17, args: &__args, locals: &__locals )

return __return != jboolean(JNI_FALSE)

}

/// public final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.hasWaiters(java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)

private static var hasWaiters_MethodID_18: jmethodID?

open func hasWaiters( condition: /* class java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject */ UnavailableObject? ) -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = JNIType.toJava( value: condition, locals: &__locals )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "hasWaiters", methodSig: "(Ljava/util/concurrent/locks/AbstractQueuedSynchronizer$ConditionObject;)Z", methodCache: &AbstractQueuedSynchronizer.hasWaiters_MethodID_18, args: &__args, locals: &__locals )

return __return != jboolean(JNI_FALSE)

}

open func hasWaiters( _ _condition: /* class java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject */ UnavailableObject? ) -> Bool {

return hasWaiters( condition: _condition )

}

/// protected boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.isHeldExclusively()

private static var isHeldExclusively_MethodID_19: jmethodID?

open func isHeldExclusively() -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "isHeldExclusively", methodSig: "()Z", methodCache: &AbstractQueuedSynchronizer.isHeldExclusively_MethodID_19, args: &__args, locals: &__locals )

return __return != jboolean(JNI_FALSE)

}

/// final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.isOnSyncQueue(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node)

// Skipping method: true false false false false

/// public final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.isQueued(java.lang.Thread)

private static var isQueued_MethodID_20: jmethodID?

open func isQueued( thread: java_swift.JavaThread? ) -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = JNIType.toJava( value: thread, locals: &__locals )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "isQueued", methodSig: "(Ljava/lang/Thread;)Z", methodCache: &AbstractQueuedSynchronizer.isQueued_MethodID_20, args: &__args, locals: &__locals )

return __return != jboolean(JNI_FALSE)

}

open func isQueued( _ _thread: java_swift.JavaThread? ) -> Bool {

return isQueued( thread: _thread )

}

/// public final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.owns(java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)

private static var owns_MethodID_21: jmethodID?

open func owns( condition: /* class java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject */ UnavailableObject? ) -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = JNIType.toJava( value: condition, locals: &__locals )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "owns", methodSig: "(Ljava/util/concurrent/locks/AbstractQueuedSynchronizer$ConditionObject;)Z", methodCache: &AbstractQueuedSynchronizer.owns_MethodID_21, args: &__args, locals: &__locals )

return __return != jboolean(JNI_FALSE)

}

open func owns( _ _condition: /* class java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject */ UnavailableObject? ) -> Bool {

return owns( condition: _condition )

}

/// private final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt()

/// public final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.release(int)

private static var release_MethodID_22: jmethodID?

open func release( arg: Int ) -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = jvalue( i: jint(arg) )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "release", methodSig: "(I)Z", methodCache: &AbstractQueuedSynchronizer.release_MethodID_22, args: &__args, locals: &__locals )

return __return != jboolean(JNI_FALSE)

}

open func release( _ _arg: Int ) -> Bool {

return release( arg: _arg )

}

/// public final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.releaseShared(int)

private static var releaseShared_MethodID_23: jmethodID?

open func releaseShared( arg: Int ) -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = jvalue( i: jint(arg) )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "releaseShared", methodSig: "(I)Z", methodCache: &AbstractQueuedSynchronizer.releaseShared_MethodID_23, args: &__args, locals: &__locals )

return __return != jboolean(JNI_FALSE)

}

open func releaseShared( _ _arg: Int ) -> Bool {

return releaseShared( arg: _arg )

}

/// private void java.util.concurrent.locks.AbstractQueuedSynchronizer.setHead(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node)

/// private void java.util.concurrent.locks.AbstractQueuedSynchronizer.setHeadAndPropagate(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node,int)

/// protected final void java.util.concurrent.locks.AbstractQueuedSynchronizer.setState(int)

private static var setState_MethodID_24: jmethodID?

open func setState( newState: Int ) {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = jvalue( i: jint(newState) )

JNIMethod.CallVoidMethod( object: javaObject, methodName: "setState", methodSig: "(I)V", methodCache: &AbstractQueuedSynchronizer.setState_MethodID_24, args: &__args, locals: &__locals )

}

open func setState( _ _newState: Int ) {

setState( newState: _newState )

}

/// public java.lang.String java.util.concurrent.locks.AbstractQueuedSynchronizer.toString()

// Skipping method: false true false false false

/// final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.transferAfterCancelledWait(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node)

// Skipping method: true false false false false

/// final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.transferForSignal(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node)

// Skipping method: true false false false false

/// protected boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.tryAcquire(int)

private static var tryAcquire_MethodID_25: jmethodID?

open func tryAcquire( arg: Int ) -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = jvalue( i: jint(arg) )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "tryAcquire", methodSig: "(I)Z", methodCache: &AbstractQueuedSynchronizer.tryAcquire_MethodID_25, args: &__args, locals: &__locals )

return __return != jboolean(JNI_FALSE)

}

open func tryAcquire( _ _arg: Int ) -> Bool {

return tryAcquire( arg: _arg )

}

/// public final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.tryAcquireNanos(int,long) throws java.lang.InterruptedException

private static var tryAcquireNanos_MethodID_26: jmethodID?

open func tryAcquireNanos( arg: Int, nanosTimeout: Int64 ) throws /* java.lang.InterruptedException */ -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 2 )

__args[0] = jvalue( i: jint(arg) )

__args[1] = jvalue( j: nanosTimeout )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "tryAcquireNanos", methodSig: "(IJ)Z", methodCache: &AbstractQueuedSynchronizer.tryAcquireNanos_MethodID_26, args: &__args, locals: &__locals )

if let throwable = JNI.ExceptionCheck() {

defer { JNI.DeleteLocalRef( throwable ) }

throw java_lang.InterruptedException( javaObject: throwable )

}

return __return != jboolean(JNI_FALSE)

}

open func tryAcquireNanos( _ _arg: Int, _ _nanosTimeout: Int64 ) throws /* java.lang.InterruptedException */ -> Bool {

return try tryAcquireNanos( arg: _arg, nanosTimeout: _nanosTimeout )

}

/// protected int java.util.concurrent.locks.AbstractQueuedSynchronizer.tryAcquireShared(int)

private static var tryAcquireShared_MethodID_27: jmethodID?

open func tryAcquireShared( arg: Int ) -> Int {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = jvalue( i: jint(arg) )

let __return = JNIMethod.CallIntMethod( object: javaObject, methodName: "tryAcquireShared", methodSig: "(I)I", methodCache: &AbstractQueuedSynchronizer.tryAcquireShared_MethodID_27, args: &__args, locals: &__locals )

return Int(__return)

}

open func tryAcquireShared( _ _arg: Int ) -> Int {

return tryAcquireShared( arg: _arg )

}

/// public final boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.tryAcquireSharedNanos(int,long) throws java.lang.InterruptedException

private static var tryAcquireSharedNanos_MethodID_28: jmethodID?

open func tryAcquireSharedNanos( arg: Int, nanosTimeout: Int64 ) throws /* java.lang.InterruptedException */ -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 2 )

__args[0] = jvalue( i: jint(arg) )

__args[1] = jvalue( j: nanosTimeout )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "tryAcquireSharedNanos", methodSig: "(IJ)Z", methodCache: &AbstractQueuedSynchronizer.tryAcquireSharedNanos_MethodID_28, args: &__args, locals: &__locals )

if let throwable = JNI.ExceptionCheck() {

defer { JNI.DeleteLocalRef( throwable ) }

throw java_lang.InterruptedException( javaObject: throwable )

}

return __return != jboolean(JNI_FALSE)

}

open func tryAcquireSharedNanos( _ _arg: Int, _ _nanosTimeout: Int64 ) throws /* java.lang.InterruptedException */ -> Bool {

return try tryAcquireSharedNanos( arg: _arg, nanosTimeout: _nanosTimeout )

}

/// protected boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.tryRelease(int)

private static var tryRelease_MethodID_29: jmethodID?

open func tryRelease( arg: Int ) -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = jvalue( i: jint(arg) )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "tryRelease", methodSig: "(I)Z", methodCache: &AbstractQueuedSynchronizer.tryRelease_MethodID_29, args: &__args, locals: &__locals )

return __return != jboolean(JNI_FALSE)

}

open func tryRelease( _ _arg: Int ) -> Bool {

return tryRelease( arg: _arg )

}

/// protected boolean java.util.concurrent.locks.AbstractQueuedSynchronizer.tryReleaseShared(int)

private static var tryReleaseShared_MethodID_30: jmethodID?

open func tryReleaseShared( arg: Int ) -> Bool {

var __locals = [jobject]()

var __args = [jvalue]( repeating: jvalue(), count: 1 )

__args[0] = jvalue( i: jint(arg) )

let __return = JNIMethod.CallBooleanMethod( object: javaObject, methodName: "tryReleaseShared", methodSig: "(I)Z", methodCache: &AbstractQueuedSynchronizer.tryReleaseShared_MethodID_30, args: &__args, locals: &__locals )

return __return != jboolean(JNI_FALSE)

}

open func tryReleaseShared( _ _arg: Int ) -> Bool {

return tryReleaseShared( arg: _arg )

}

/// private void java.util.concurrent.locks.AbstractQueuedSynchronizer.unparkSuccessor(java.util.concurrent.locks.AbstractQueuedSynchronizer$Node)