interlocked.hpp

Go to the documentation of this file.

#pragma once
#include "../core_export.hpp"
#include "../lock_guard.hpp"
#include "../object.hpp"
#include "../static.hpp"
#include "../types.hpp"

namespace xtd {
  namespace threading {
    class core_export_ interlocked static_ {
    public:
      
      static auto add(int32& location, int32 value) noexcept -> int32;
      static auto add(int64& location, int64 value) noexcept -> int64;
      
      static auto compare_exchange(double& location, double value, double comparand) noexcept -> double;
      static auto compare_exchange(int32& location, int32 value, int32 comparand) noexcept -> int32;
      static auto compare_exchange(int64& location, int64 value, int64 comparand) noexcept -> int64;
      static auto compare_exchange(bool& location, bool value, bool comparand) noexcept -> bool;
      static auto compare_exchange(slong& location, slong value, slong comparand) noexcept -> slong;
      static auto compare_exchange(void*& location, void* value, void* comparand) noexcept -> void*;
      template<typename type_t>
      requires std::is_enum_v<type_t>
      static auto compare_exchange(type_t& location, type_t value, type_t comparand) noexcept -> type_t {
        auto* location_ptr = reinterpret_cast<std::underlying_type<type_t>::type*>(&location);
        return static_cast<type_t>(compare_exchange(*location_ptr, static_cast<std::underlying_type<type_t>::type>(value), static_cast<std::underlying_type<type_t>::type>(comparand)));
      }

      static auto compare_exchange(float& location, float value, float comparand) noexcept -> float;
      
      static auto decrement(int32& location) noexcept -> int32;
      static auto decrement(int64& location) noexcept -> int64;
      
      template<typename type_t>
      requires std::is_enum_v<type_t>
      static auto exchange(type_t& location, const type_t& value) noexcept -> type_t {
        auto* location_ptr = reinterpret_cast<std::underlying_type<type_t>::type*>(&location);
        return static_cast<type_t>(exchange(*location_ptr, static_cast<std::underlying_type<type_t>::type>(value)));
      }

      static auto exchange(double& location, double value) noexcept -> double;
      static auto exchange(int32& location, int32 value) noexcept -> int32;
      static auto exchange(int64& location, int64 value) noexcept -> int64;
      static auto exchange(bool& location, bool value) noexcept -> bool;
      static auto exchange(slong& location, slong value) noexcept -> slong;
      static auto exchange(void*& location, void* value) noexcept -> void*;
      static auto exchange(float& location, float value) noexcept -> float;
      
      static auto increment(int32& location) noexcept -> int32;
      static auto increment(int64& location) noexcept -> int64;
      
      static auto memory_barrier() noexcept -> void;
      
      static auto read(int64& location) noexcept -> int64;
    };
  }
}