//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Atomics open source project
//
// Copyright (c) 2020 - 2023 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

%{
  from gyb_utils import (
    autogenerated_warning, boolOperations, lowerFirst, argLabel)
}%
${autogenerated_warning()}

#if ATOMICS_NATIVE_BUILTINS
import Builtin

extension Bool {
  @_alwaysEmitIntoClient
  @_transparent
  internal init(_ builtin: Builtin.Int1) {
    self = unsafeBitCast(builtin, to: Bool.self)
  }
}
#else
import _AtomicsShims
#endif

extension Bool: AtomicValue {
  @frozen
  public struct AtomicRepresentation {
    public typealias Value = Bool

    @usableFromInline
    internal typealias _Storage = _AtomicInt8Storage

    @usableFromInline
    internal var _storage: _Storage

    @_transparent @_alwaysEmitIntoClient
    public init(_ value: Bool) {
#if ATOMICS_NATIVE_BUILTINS
      _storage = value._atomicRepresentation
#else
      _storage = _sa_prepare_Int8(value._atomicRepresentation)
#endif
    }

    @_transparent @_alwaysEmitIntoClient
    public func dispose() -> Value {
#if ATOMICS_NATIVE_BUILTINS
      return _storage._decodeBool
#else
      return _sa_dispose_Int8(_storage)._decodeBool
#endif
    }
  }
}

#if ATOMICS_NATIVE_BUILTINS
extension Bool {
  @_transparent @_alwaysEmitIntoClient
  internal var _atomicRepresentation: _AtomicInt8Storage {
    let v: Int8 = (self ? 1 : 0)
    return .init(v._value)
  }
}

extension _AtomicInt8Storage {
  @_transparent @_alwaysEmitIntoClient
  internal var _decodeBool: Bool {
    (Int8(self._value) & 1) != 0
  }
}
#else
extension Bool {
  @_transparent @_alwaysEmitIntoClient
  internal var _atomicRepresentation: Int8 {
    self ? 1 : 0
  }
}

extension Int8 {
  @_transparent @_alwaysEmitIntoClient
  internal var _decodeBool: Bool {
    (self & 1) != 0
  }
}
#endif

extension UnsafeMutablePointer
where Pointee == Bool.AtomicRepresentation {
  @_transparent @_alwaysEmitIntoClient
  @usableFromInline
  internal var _extract: UnsafeMutablePointer<Pointee._Storage> {
    // `Bool.AtomicRepresentation` is layout-compatible with
    // its only stored property.
    UnsafeMutableRawPointer(self).assumingMemoryBound(to: Pointee._Storage.self)
  }
}

extension Bool.AtomicRepresentation: AtomicStorage {
  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicLoad(
    at pointer: UnsafeMutablePointer<Bool.AtomicRepresentation>,
    ordering: AtomicLoadOrdering
  ) -> Bool {
    pointer._extract._atomicLoad(ordering: ordering)._decodeBool
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicStore(
    _ desired: __owned Bool,
    at pointer: UnsafeMutablePointer<Bool.AtomicRepresentation>,
    ordering: AtomicStoreOrdering
  ) {
    pointer._extract._atomicStore(
      desired._atomicRepresentation, ordering: ordering)
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicExchange(
    _ desired: __owned Bool,
    at pointer: UnsafeMutablePointer<Bool.AtomicRepresentation>,
    ordering: AtomicUpdateOrdering
  ) -> Bool {
    pointer._extract._atomicExchange(
      desired._atomicRepresentation, ordering: ordering
    )._decodeBool
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicCompareExchange(
    expected: Bool,
    desired: __owned Bool,
    at pointer: UnsafeMutablePointer<Bool.AtomicRepresentation>,
    ordering: AtomicUpdateOrdering
  ) -> (exchanged: Bool, original: Bool) {
    let r = pointer._extract._atomicCompareExchange(
      expected: expected._atomicRepresentation,
      desired: desired._atomicRepresentation,
      ordering: ordering)
    return (r.exchanged, r.original._decodeBool)
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicCompareExchange(
    expected: Bool,
    desired: __owned Bool,
    at pointer: UnsafeMutablePointer<Bool.AtomicRepresentation>,
    successOrdering: AtomicUpdateOrdering,
    failureOrdering: AtomicLoadOrdering
  ) -> (exchanged: Bool, original: Bool) {
    let r = pointer._extract._atomicCompareExchange(
      expected: expected._atomicRepresentation,
      desired: desired._atomicRepresentation,
      successOrdering: successOrdering,
      failureOrdering: failureOrdering)
    return (r.exchanged, r.original._decodeBool)
  }

  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicWeakCompareExchange(
    expected: Bool,
    desired: __owned Bool,
    at pointer: UnsafeMutablePointer<Bool.AtomicRepresentation>,
    successOrdering: AtomicUpdateOrdering,
    failureOrdering: AtomicLoadOrdering
  ) -> (exchanged: Bool, original: Bool) {
    let r = pointer._extract._atomicWeakCompareExchange(
      expected: expected._atomicRepresentation,
      desired: desired._atomicRepresentation,
      successOrdering: successOrdering,
      failureOrdering: failureOrdering)
    return (r.exchanged, r.original._decodeBool)
  }
}


// MARK: - Additional operations

extension Bool.AtomicRepresentation {
% for (name, iname, op, label, doc) in boolOperations:
  /// Perform an atomic ${doc} operation on the value referenced by
  /// `pointer` and return the original value, applying the specified memory
  /// ordering.
  ///
  /// - Parameter operand: A boolean value.
  /// - Parameter pointer: A memory location previously initialized with a value
  ///   returned by `prepareAtomicRepresentation(for:)`.
  /// - Parameter ordering: The memory ordering to apply on this operation.
  /// - Returns: The original value before the operation.
  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public static func atomicLoadThen${name}(
    ${label} operand: Value,
    at pointer: UnsafeMutablePointer<Self>,
    ordering: AtomicUpdateOrdering
  ) -> Value {
    pointer._extract._atomicLoadThen${iname}(
      ${argLabel(label)}operand._atomicRepresentation, ordering: ordering
    )._decodeBool
  }
% end
}

% for construct in ["UnsafeAtomic", "ManagedAtomic"]:
extension ${construct} where Value == Bool {
% for (name, iname, op, label, doc) in boolOperations:
  /// Perform an atomic ${doc} operation and return the original value, applying
  /// the specified memory ordering.
  ///
  /// - Parameter operand: A boolean value.
  /// - Parameter ordering: The memory ordering to apply on this operation.
  /// - Returns: The original value before the operation.
  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public func loadThen${name}(
    ${label} operand: Value,
    ordering: AtomicUpdateOrdering
  ) -> Value {
    Value.AtomicRepresentation.atomicLoadThen${name}(
      ${argLabel(label)}operand,
      at: _ptr,
      ordering: ordering)
  }
% end
}

extension ${construct} where Value == Bool {
% for (name, iname, op, label, doc) in boolOperations:
  /// Perform an atomic ${doc} operation and return the original value, applying
  /// the specified memory ordering.
  ///
  /// - Parameter operand: A boolean value.
  /// - Parameter ordering: The memory ordering to apply on this operation.
  /// - Returns: The original value before the operation.
  @_semantics("atomics.requires_constant_orderings")
  @_transparent @_alwaysEmitIntoClient
  public func ${lowerFirst(name)}ThenLoad(
    ${label} operand: Value,
    ordering: AtomicUpdateOrdering
  ) -> Value {
    let original = Value.AtomicRepresentation.atomicLoadThen${name}(
      ${argLabel(label)}operand,
      at: _ptr,
      ordering: ordering)
    return original ${op} operand
  }

% end
}
% end