## EDU.oswego.cs.dl.util.concurrent
Class WaitableLong

    java.lang.Object
      EDU.oswego.cs.dl.util.concurrent.SynchronizedVariable
          EDU.oswego.cs.dl.util.concurrent.SynchronizedLong
              EDU.oswego.cs.dl.util.concurrent.WaitableLong

All Implemented Interfaces:
  Executor, java.lang.Cloneable, java.lang.Comparable

    public class WaitableLong

extends SynchronizedLong

A class useful for offloading waiting and signalling operations on single long variables.

[ Introduction to this package. ]

Field Summary

Fields inherited from class EDU.oswego.cs.dl.util.concurrent.SynchronizedLong
`value_`

Fields inherited from class EDU.oswego.cs.dl.util.concurrent.SynchronizedVariable
`lock_`

Constructor Summary
`WaitableLong(long initialValue)` Make a new WaitableLong with the given initial value, and using its own internal lock.
`WaitableLong(long initialValue, java.lang.Object lock)` Make a new WaitableLong with the given initial value, and using the supplied lock.

Method Summary
`long` `add(long amount)` Add amount to value (i.e., set value += amount)
`long` `and(long b)` Set value to value & b.
`boolean` `commit(long assumedValue, long newValue)` Set value to newValue only if it is currently assumedValue.
`long` `complement()` Set the value to its complement
`long` `decrement()` Decrement the value.
`long` `divide(long factor)` Divide value by factor (i.e., set value /= factor)
`long` `increment()` Increment the value.
`long` `multiply(long factor)` Multiply value by factor (i.e., set value *= factor)
`long` `or(long b)` Set value to value | b.
`long` `set(long newValue)` Set to newValue.
`long` `subtract(long amount)` Subtract amount from value (i.e., set value -= amount)
`void` `whenEqual(long c, java.lang.Runnable action)` Wait until value equals c, then run action if nonnull.
`void` `whenGreater(long c, java.lang.Runnable action)` wait until value greater than c, then run action if nonnull.
`void` `whenGreaterEqual(long c, java.lang.Runnable action)` wait until value greater than or equal to c, then run action if nonnull.
`void` `whenLess(long c, java.lang.Runnable action)` wait until value less than c, then run action if nonnull.
`void` `whenLessEqual(long c, java.lang.Runnable action)` wait until value less than or equal to c, then run action if nonnull.
`void` `whenNotEqual(long c, java.lang.Runnable action)` wait until value not equal to c, then run action if nonnull.
`long` `xor(long b)` Set value to value ^ b.

Methods inherited from class EDU.oswego.cs.dl.util.concurrent.SynchronizedLong
`compareTo, compareTo, compareTo, equals, get, hashCode, negate, swap, toString`

Methods inherited from class EDU.oswego.cs.dl.util.concurrent.SynchronizedVariable
`execute, getLock`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Constructor Detail

### WaitableLong

    public WaitableLong(long initialValue)

  Make a new WaitableLong with the given initial value, and using its own internal lock.

### WaitableLong

    public WaitableLong(long initialValue,
                        java.lang.Object lock)

  Make a new WaitableLong with the given initial value, and using the supplied lock.

Method Detail

### set

    public long set(long newValue)

  Description copied from class: `SynchronizedLong`
  Set to newValue.

  Overrides:
    `set` in class `SynchronizedLong`
  Returns:
    the old value

### commit

    public boolean commit(long assumedValue,
                          long newValue)

  Description copied from class: `SynchronizedLong`
  Set value to newValue only if it is currently assumedValue.

  Overrides:
    `commit` in class `SynchronizedLong`
  Returns:
    true if successful

### increment

    public long increment()

  Description copied from class: `SynchronizedLong`
  Increment the value.

  Overrides:
    `increment` in class `SynchronizedLong`
  Returns:
    the new value

### decrement

    public long decrement()

  Description copied from class: `SynchronizedLong`
  Decrement the value.

  Overrides:
    `decrement` in class `SynchronizedLong`
  Returns:
    the new value

### add

    public long add(long amount)

  Description copied from class: `SynchronizedLong`
  Add amount to value (i.e., set value += amount)

  Overrides:
    `add` in class `SynchronizedLong`
  Returns:
    the new value

### subtract

    public long subtract(long amount)

  Description copied from class: `SynchronizedLong`
  Subtract amount from value (i.e., set value -= amount)

  Overrides:
    `subtract` in class `SynchronizedLong`
  Returns:
    the new value

### multiply

    public long multiply(long factor)

  Description copied from class: `SynchronizedLong`
  Multiply value by factor (i.e., set value *= factor)

  Overrides:
    `multiply` in class `SynchronizedLong`
  Returns:
    the new value

### divide

    public long divide(long factor)

  Description copied from class: `SynchronizedLong`
  Divide value by factor (i.e., set value /= factor)

  Overrides:
    `divide` in class `SynchronizedLong`
  Returns:
    the new value

### complement

    public long complement()

  Set the value to its complement

  Overrides:
    `complement` in class `SynchronizedLong`
  Returns:
    the new value

### and

    public long and(long b)

  Set value to value & b.

  Overrides:
    `and` in class `SynchronizedLong`
  Returns:
    the new value

### or

    public long or(long b)

  Set value to value | b.

  Overrides:
    `or` in class `SynchronizedLong`
  Returns:
    the new value

### xor

    public long xor(long b)

  Set value to value ^ b.

  Overrides:
    `xor` in class `SynchronizedLong`
  Returns:
    the new value

### whenEqual

    public void whenEqual(long c,
                          java.lang.Runnable action)
                   throws java.lang.InterruptedException

  Wait until value equals c, then run action if nonnull. The action is run with the synchronization lock held.

  Throws:
    `java.lang.InterruptedException`

### whenNotEqual

    public void whenNotEqual(long c,
                             java.lang.Runnable action)
                      throws java.lang.InterruptedException

  wait until value not equal to c, then run action if nonnull. The action is run with the synchronization lock held.

  Throws:
    `java.lang.InterruptedException`

### whenLessEqual

    public void whenLessEqual(long c,
                              java.lang.Runnable action)
                       throws java.lang.InterruptedException

  wait until value less than or equal to c, then run action if nonnull. The action is run with the synchronization lock held.

  Throws:
    `java.lang.InterruptedException`

### whenLess

    public void whenLess(long c,
                         java.lang.Runnable action)
                  throws java.lang.InterruptedException

  wait until value less than c, then run action if nonnull. The action is run with the synchronization lock held.

  Throws:
    `java.lang.InterruptedException`

### whenGreaterEqual

    public void whenGreaterEqual(long c,
                                 java.lang.Runnable action)
                          throws java.lang.InterruptedException

  wait until value greater than or equal to c, then run action if nonnull. The action is run with the synchronization lock held.

  Throws:
    `java.lang.InterruptedException`

### whenGreater

    public void whenGreater(long c,
                            java.lang.Runnable action)
                     throws java.lang.InterruptedException

  wait until value greater than c, then run action if nonnull. The action is run with the synchronization lock held.

  Throws:
    `java.lang.InterruptedException`