🥮 mooncakes.io

    Nanaloveyuki/sync/atomic does not have a README file

    SyncError

    source

    AtomicBool

    source
    type AtomicBool

    AtomicBool::compare_exchange

    source
    fn AtomicBool::compare_exchange(self : AtomicBool, current : Bool, next : Bool, success? : MemoryOrdering, failure? : MemoryOrdering) -> CompareExchangeResult[Bool] raise 
    SyncError

    AtomicBool::load

    source

    AtomicBool::new

    source
    fn AtomicBool::new(value : Bool) -> AtomicBool

    Creates an atomic boolean. Defaults on operations are SeqCst.

    AtomicBool::share

    source
    fn AtomicBool::share(self : AtomicBool) -> AtomicBool

    Creates an independent wrapper for use by another OS thread.

    AtomicBool::store

    source
    fn AtomicBool::store(self : AtomicBool, value : Bool, order? : MemoryOrdering) -> Unit raise 
    SyncError

    AtomicBool::swap

    source
    fn AtomicBool::swap(self : AtomicBool, value : Bool, order? : MemoryOrdering) -> Bool

    AtomicInt

    source
    type AtomicInt

    AtomicInt::compare_exchange

    source
    fn AtomicInt::compare_exchange(self : AtomicInt, current : Int, next : Int, success? : MemoryOrdering, failure? : MemoryOrdering) -> CompareExchangeResult[Int] raise 
    SyncError

    AtomicInt::fetch_add

    source
    fn AtomicInt::fetch_add(self : AtomicInt, delta : Int, order? : MemoryOrdering) -> Int

    AtomicInt::load

    source

    AtomicInt::new

    source
    fn AtomicInt::new(value : Int) -> AtomicInt

    Creates a 32-bit signed atomic integer.

    AtomicInt::share

    source
    fn AtomicInt::share(self : AtomicInt) -> AtomicInt

    Creates an independent wrapper for use by another OS thread.

    AtomicInt::store

    source
    fn AtomicInt::store(self : AtomicInt, value : Int, order? : MemoryOrdering) -> Unit raise 
    SyncError

    AtomicInt::swap

    source
    fn AtomicInt::swap(self : AtomicInt, value : Int, order? : MemoryOrdering) -> Int

    AtomicUInt

    source
    type AtomicUInt

    AtomicUInt::compare_exchange

    source
    fn AtomicUInt::compare_exchange(self : AtomicUInt, current : UInt, next : UInt, success? : MemoryOrdering, failure? : MemoryOrdering) -> CompareExchangeResult[UInt] raise 
    SyncError

    AtomicUInt::fetch_add

    source
    fn AtomicUInt::fetch_add(self : AtomicUInt, delta : UInt, order? : MemoryOrdering) -> UInt

    AtomicUInt::load

    source

    AtomicUInt::new

    source
    fn AtomicUInt::new(value : UInt) -> AtomicUInt

    Creates a 32-bit unsigned atomic integer.

    AtomicUInt::share

    source
    fn AtomicUInt::share(self : AtomicUInt) -> AtomicUInt

    Creates an independent wrapper for use by another OS thread.

    AtomicUInt::store

    source
    fn AtomicUInt::store(self : AtomicUInt, value : UInt, order? : MemoryOrdering) -> Unit raise 
    SyncError

    AtomicUInt::swap

    source
    fn AtomicUInt::swap(self : AtomicUInt, value : UInt, order? : MemoryOrdering) -> UInt

    CompareExchangeResult

    source
    pub struct CompareExchangeResult[T] {
      observed : T
      exchanged : Bool
    } derive(Eq, 
    Debug    )

    MemoryOrdering

    source
    pub(all) enum MemoryOrdering {
      Relaxed
      Acquire
      Release
      AcqRel
      SeqCst
    } derive(Eq, 
    Debug    )

    Memory ordering for atomic operations.

    Windows uses Interlocked operations and may strengthen every ordering to SeqCst. Linux implements the requested ordering with compiler atomics.

    Source Files