/**@class java.util.concurrent.atomic.AtomicInteger
 implements java.io.Serializable

@extends java.lang.Number

 An {@code int} value that may be updated atomically.  See the
 {@link java.util.concurrent.atomic} package specification for
 description of the properties of atomic variables. An
 {@code AtomicInteger} is used in applications such as atomically
 incremented counters, and cannot be used as a replacement for an
 {@link java.lang.Integer}. However, this class does extend
 {@code Number} to allow uniform access by tools and utilities that
 deal with numerically-based classes.

 @since 1.5
 @author Doug Lea
*/
var AtomicInteger = {

/**Gets the current value.
@return {Number} the current value
*/
get : function(  ) {},

/**Sets to the given value.
@param {Number} newValue the new value
*/
set : function(  ) {},

/**Eventually sets to the given value.
@param {Number} newValue the new value
@since 1.6
*/
lazySet : function(  ) {},

/**Atomically sets to the given value and returns the old value.
@param {Number} newValue the new value
@return {Number} the previous value
*/
getAndSet : function(  ) {},

/**Atomically sets the value to the given updated value
 if the current value {@code ==} the expected value.
@param {Number} expect the expected value
@param {Number} update the new value
@return {Boolean} {@code true} if successful. False return indicates that
 the actual value was not equal to the expected value.
*/
compareAndSet : function(  ) {},

/**Atomically sets the value to the given updated value
 if the current value {@code ==} the expected value.

 <p><a href="package-summary.html#weakCompareAndSet">May fail
 spuriously and does not provide ordering guarantees</a>, so is
 only rarely an appropriate alternative to {@code compareAndSet}.
@param {Number} expect the expected value
@param {Number} update the new value
@return {Boolean} {@code true} if successful
*/
weakCompareAndSet : function(  ) {},

/**Atomically increments by one the current value.
@return {Number} the previous value
*/
getAndIncrement : function(  ) {},

/**Atomically decrements by one the current value.
@return {Number} the previous value
*/
getAndDecrement : function(  ) {},

/**Atomically adds the given value to the current value.
@param {Number} delta the value to add
@return {Number} the previous value
*/
getAndAdd : function(  ) {},

/**Atomically increments by one the current value.
@return {Number} the updated value
*/
incrementAndGet : function(  ) {},

/**Atomically decrements by one the current value.
@return {Number} the updated value
*/
decrementAndGet : function(  ) {},

/**Atomically adds the given value to the current value.
@param {Number} delta the value to add
@return {Number} the updated value
*/
addAndGet : function(  ) {},

/**Atomically updates the current value with the results of
 applying the given function, returning the previous value. The
 function should be side-effect-free, since it may be re-applied
 when attempted updates fail due to contention among threads.
@param {Object {IntUnaryOperator}} updateFunction a side-effect-free function
@return {Number} the previous value
@since 1.8
*/
getAndUpdate : function(  ) {},

/**Atomically updates the current value with the results of
 applying the given function, returning the updated value. The
 function should be side-effect-free, since it may be re-applied
 when attempted updates fail due to contention among threads.
@param {Object {IntUnaryOperator}} updateFunction a side-effect-free function
@return {Number} the updated value
@since 1.8
*/
updateAndGet : function(  ) {},

/**Atomically updates the current value with the results of
 applying the given function to the current and given values,
 returning the previous value. The function should be
 side-effect-free, since it may be re-applied when attempted
 updates fail due to contention among threads.  The function
 is applied with the current value as its first argument,
 and the given update as the second argument.
@param {Number} x the update value
@param {Object {IntBinaryOperator}} accumulatorFunction a side-effect-free function of two arguments
@return {Number} the previous value
@since 1.8
*/
getAndAccumulate : function(  ) {},

/**Atomically updates the current value with the results of
 applying the given function to the current and given values,
 returning the updated value. The function should be
 side-effect-free, since it may be re-applied when attempted
 updates fail due to contention among threads.  The function
 is applied with the current value as its first argument,
 and the given update as the second argument.
@param {Number} x the update value
@param {Object {IntBinaryOperator}} accumulatorFunction a side-effect-free function of two arguments
@return {Number} the updated value
@since 1.8
*/
accumulateAndGet : function(  ) {},

/**Returns the String representation of the current value.
@return {String} the String representation of the current value
*/
toString : function(  ) {},

/**Returns the value of this {@code AtomicInteger} as an {@code int}.
 Equivalent to {@link #get}().
*/
intValue : function(  ) {},

/**Returns the value of this {@code AtomicInteger} as a {@code long}
 after a widening primitive conversion.
@jls 5.1.2 Widening Primitive Conversions
*/
longValue : function(  ) {},

/**Returns the value of this {@code AtomicInteger} as a {@code float}
 after a widening primitive conversion.
@jls 5.1.2 Widening Primitive Conversions
*/
floatValue : function(  ) {},

/**Returns the value of this {@code AtomicInteger} as a {@code double}
 after a widening primitive conversion.
@jls 5.1.2 Widening Primitive Conversions
*/
doubleValue : function(  ) {},


};