| // Copyright (c) 2016 Uber Technologies, Inc. |
| // |
| // Permission is hereby granted, free of charge, to any person obtaining a copy |
| // of this software and associated documentation files (the "Software"), to deal |
| // in the Software without restriction, including without limitation the rights |
| // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| // copies of the Software, and to permit persons to whom the Software is |
| // furnished to do so, subject to the following conditions: |
| // |
| // The above copyright notice and this permission notice shall be included in |
| // all copies or substantial portions of the Software. |
| // |
| // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| // THE SOFTWARE. |
| |
| // Package atomic provides simple wrappers around numerics to enforce atomic |
| // access. |
| package atomic |
| |
| import "sync/atomic" |
| |
| // Int32 is an atomic wrapper around an int32. |
| type Int32 struct{ int32 } |
| |
| // NewInt32 creates an Int32. |
| func NewInt32(i int32) *Int32 { |
| return &Int32{i} |
| } |
| |
| // Load atomically loads the wrapped value. |
| func (i *Int32) Load() int32 { |
| return atomic.LoadInt32(&i.int32) |
| } |
| |
| // Add atomically adds to the wrapped int32 and returns the new value. |
| func (i *Int32) Add(n int32) int32 { |
| return atomic.AddInt32(&i.int32, n) |
| } |
| |
| // Inc atomically increments the wrapped int32 and returns the new value. |
| func (i *Int32) Inc() int32 { |
| return i.Add(1) |
| } |
| |
| // Dec atomically decrements the wrapped int32 and returns the new value. |
| func (i *Int32) Dec() int32 { |
| return i.Add(-1) |
| } |
| |
| // CAS is an atomic compare-and-swap. |
| func (i *Int32) CAS(old, new int32) bool { |
| return atomic.CompareAndSwapInt32(&i.int32, old, new) |
| } |
| |
| // Store atomically stores the passed value. |
| func (i *Int32) Store(n int32) { |
| atomic.StoreInt32(&i.int32, n) |
| } |
| |
| // Swap atomically swaps the wrapped int32 and returns the old value. |
| func (i *Int32) Swap(n int32) int32 { |
| return atomic.SwapInt32(&i.int32, n) |
| } |
| |
| // Int64 is an atomic wrapper around an int64. |
| type Int64 struct{ int64 } |
| |
| // NewInt64 creates an Int64. |
| func NewInt64(i int64) *Int64 { |
| return &Int64{i} |
| } |
| |
| // Load atomically loads the wrapped value. |
| func (i *Int64) Load() int64 { |
| return atomic.LoadInt64(&i.int64) |
| } |
| |
| // Add atomically adds to the wrapped int64 and returns the new value. |
| func (i *Int64) Add(n int64) int64 { |
| return atomic.AddInt64(&i.int64, n) |
| } |
| |
| // Inc atomically increments the wrapped int64 and returns the new value. |
| func (i *Int64) Inc() int64 { |
| return i.Add(1) |
| } |
| |
| // Dec atomically decrements the wrapped int64 and returns the new value. |
| func (i *Int64) Dec() int64 { |
| return i.Add(-1) |
| } |
| |
| // CAS is an atomic compare-and-swap. |
| func (i *Int64) CAS(old, new int64) bool { |
| return atomic.CompareAndSwapInt64(&i.int64, old, new) |
| } |
| |
| // Store atomically stores the passed value. |
| func (i *Int64) Store(n int64) { |
| atomic.StoreInt64(&i.int64, n) |
| } |
| |
| // Swap atomically swaps the wrapped int64 and returns the old value. |
| func (i *Int64) Swap(n int64) int64 { |
| return atomic.SwapInt64(&i.int64, n) |
| } |
| |
| // Uint32 is an atomic wrapper around an uint32. |
| type Uint32 struct{ uint32 } |
| |
| // NewUint32 creates a Uint32. |
| func NewUint32(i uint32) *Uint32 { |
| return &Uint32{i} |
| } |
| |
| // Load atomically loads the wrapped value. |
| func (i *Uint32) Load() uint32 { |
| return atomic.LoadUint32(&i.uint32) |
| } |
| |
| // Add atomically adds to the wrapped uint32 and returns the new value. |
| func (i *Uint32) Add(n uint32) uint32 { |
| return atomic.AddUint32(&i.uint32, n) |
| } |
| |
| // Inc atomically increments the wrapped uint32 and returns the new value. |
| func (i *Uint32) Inc() uint32 { |
| return i.Add(1) |
| } |
| |
| // Dec atomically decrements the wrapped int32 and returns the new value. |
| func (i *Uint32) Dec() uint32 { |
| return i.Add(^uint32(0)) |
| } |
| |
| // CAS is an atomic compare-and-swap. |
| func (i *Uint32) CAS(old, new uint32) bool { |
| return atomic.CompareAndSwapUint32(&i.uint32, old, new) |
| } |
| |
| // Store atomically stores the passed value. |
| func (i *Uint32) Store(n uint32) { |
| atomic.StoreUint32(&i.uint32, n) |
| } |
| |
| // Swap atomically swaps the wrapped uint32 and returns the old value. |
| func (i *Uint32) Swap(n uint32) uint32 { |
| return atomic.SwapUint32(&i.uint32, n) |
| } |
| |
| // Uint64 is an atomic wrapper around a uint64. |
| type Uint64 struct{ uint64 } |
| |
| // NewUint64 creates a Uint64. |
| func NewUint64(i uint64) *Uint64 { |
| return &Uint64{i} |
| } |
| |
| // Load atomically loads the wrapped value. |
| func (i *Uint64) Load() uint64 { |
| return atomic.LoadUint64(&i.uint64) |
| } |
| |
| // Add atomically adds to the wrapped uint64 and returns the new value. |
| func (i *Uint64) Add(n uint64) uint64 { |
| return atomic.AddUint64(&i.uint64, n) |
| } |
| |
| // Inc atomically increments the wrapped uint64 and returns the new value. |
| func (i *Uint64) Inc() uint64 { |
| return i.Add(1) |
| } |
| |
| // Dec atomically decrements the wrapped uint64 and returns the new value. |
| func (i *Uint64) Dec() uint64 { |
| return i.Add(^uint64(0)) |
| } |
| |
| // CAS is an atomic compare-and-swap. |
| func (i *Uint64) CAS(old, new uint64) bool { |
| return atomic.CompareAndSwapUint64(&i.uint64, old, new) |
| } |
| |
| // Store atomically stores the passed value. |
| func (i *Uint64) Store(n uint64) { |
| atomic.StoreUint64(&i.uint64, n) |
| } |
| |
| // Swap atomically swaps the wrapped uint64 and returns the old value. |
| func (i *Uint64) Swap(n uint64) uint64 { |
| return atomic.SwapUint64(&i.uint64, n) |
| } |