98 lines
3.4 KiB
Go
98 lines
3.4 KiB
Go
package atomics
|
|
|
|
import (
|
|
"sync/atomic"
|
|
|
|
"codeberg.org/gruf/go-bitutil"
|
|
)
|
|
|
|
// Flags32 provides user-friendly means of performing atomic operations on bitutil.Flags32 types.
|
|
type Flags32 bitutil.Flags32
|
|
|
|
// NewFlags32 will return a new Flags32 instance initialized with zero value.
|
|
func NewFlags32() *Flags32 {
|
|
return new(Flags32)
|
|
}
|
|
|
|
// Get will atomically load a(n) bitutil.Flags32 value contained within f, and check if bit value is set.
|
|
func (f *Flags32) Get(bit uint8) bool {
|
|
return f.Load().Get(bit)
|
|
}
|
|
|
|
// Set performs a compare-and-swap for a(n) bitutil.Flags32 with bit value set, at address contained within f.
|
|
func (f *Flags32) Set(bit uint8) bool {
|
|
cur := f.Load()
|
|
return f.CAS(cur, cur.Set(bit))
|
|
}
|
|
|
|
// Unset performs a compare-and-swap for a(n) bitutil.Flags32 with bit value unset, at address contained within f.
|
|
func (f *Flags32) Unset(bit uint8) bool {
|
|
cur := f.Load()
|
|
return f.CAS(cur, cur.Unset(bit))
|
|
}
|
|
|
|
// Store will atomically store bitutil.Flags32 value in address contained within f.
|
|
func (f *Flags32) Store(val bitutil.Flags32) {
|
|
atomic.StoreUint32((*uint32)(f), uint32(val))
|
|
}
|
|
|
|
// Load will atomically load bitutil.Flags32 value at address contained within f.
|
|
func (f *Flags32) Load() bitutil.Flags32 {
|
|
return bitutil.Flags32(atomic.LoadUint32((*uint32)(f)))
|
|
}
|
|
|
|
// CAS performs a compare-and-swap for a(n) bitutil.Flags32 value at address contained within f.
|
|
func (f *Flags32) CAS(cmp, swp bitutil.Flags32) bool {
|
|
return atomic.CompareAndSwapUint32((*uint32)(f), uint32(cmp), uint32(swp))
|
|
}
|
|
|
|
// Swap atomically stores new bitutil.Flags32 value into address contained within f, and returns previous value.
|
|
func (f *Flags32) Swap(swp bitutil.Flags32) bitutil.Flags32 {
|
|
return bitutil.Flags32(atomic.SwapUint32((*uint32)(f), uint32(swp)))
|
|
}
|
|
|
|
// Flags64 provides user-friendly means of performing atomic operations on bitutil.Flags64 types.
|
|
type Flags64 bitutil.Flags64
|
|
|
|
// NewFlags64 will return a new Flags64 instance initialized with zero value.
|
|
func NewFlags64() *Flags64 {
|
|
return new(Flags64)
|
|
}
|
|
|
|
// Get will atomically load a(n) bitutil.Flags64 value contained within f, and check if bit value is set.
|
|
func (f *Flags64) Get(bit uint8) bool {
|
|
return f.Load().Get(bit)
|
|
}
|
|
|
|
// Set performs a compare-and-swap for a(n) bitutil.Flags64 with bit value set, at address contained within f.
|
|
func (f *Flags64) Set(bit uint8) bool {
|
|
cur := f.Load()
|
|
return f.CAS(cur, cur.Set(bit))
|
|
}
|
|
|
|
// Unset performs a compare-and-swap for a(n) bitutil.Flags64 with bit value unset, at address contained within f.
|
|
func (f *Flags64) Unset(bit uint8) bool {
|
|
cur := f.Load()
|
|
return f.CAS(cur, cur.Unset(bit))
|
|
}
|
|
|
|
// Store will atomically store bitutil.Flags64 value in address contained within f.
|
|
func (f *Flags64) Store(val bitutil.Flags64) {
|
|
atomic.StoreUint64((*uint64)(f), uint64(val))
|
|
}
|
|
|
|
// Load will atomically load bitutil.Flags64 value at address contained within f.
|
|
func (f *Flags64) Load() bitutil.Flags64 {
|
|
return bitutil.Flags64(atomic.LoadUint64((*uint64)(f)))
|
|
}
|
|
|
|
// CAS performs a compare-and-swap for a(n) bitutil.Flags64 value at address contained within f.
|
|
func (f *Flags64) CAS(cmp, swp bitutil.Flags64) bool {
|
|
return atomic.CompareAndSwapUint64((*uint64)(f), uint64(cmp), uint64(swp))
|
|
}
|
|
|
|
// Swap atomically stores new bitutil.Flags64 value into address contained within f, and returns previous value.
|
|
func (f *Flags64) Swap(swp bitutil.Flags64) bitutil.Flags64 {
|
|
return bitutil.Flags64(atomic.SwapUint64((*uint64)(f), uint64(swp)))
|
|
}
|