interlocked.hpp

Go to the documentation of this file.

#pragma once
#include "../core_export.hpp"
#include "../lock.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(slong& location, slong value, slong comparand) noexcept -> slong;
      static auto compare_exchange(void*& location, void* value, void* comparand) noexcept -> void*;
      template<class type_t>
      static auto compare_exchange(object& location, const object& value, const object& comparand) noexcept -> type_t {
        type_t retValue = location;
        lock_(location) {
          if (location.equals(comparand)) location = value;
        }
        return retValue;
      }

      template<class type_t>
      static auto compare_exchange(type_t& location, type_t value, type_t comparand) noexcept -> type_t {
        type_t retValue = location;
        lock_(location) {
          if (location == comparand) location = value;
        }
        return retValue;
      }

      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<class type_t>
      static auto exchange(type_t& location, type_t value) -> type_t {
        type_t original = location;
        lock_(location)
        location = value;
        return original;
      }

      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(slong& location, slong value) noexcept -> slong;
      static auto exchange(void*& location, void* value) noexcept -> void*;
      template<class type_t>
      static auto exchange(object& location, const object& value) noexcept -> type_t {
        type_t original = location;
        lock_(location)
        location = value;
        return original;
      }

      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;
    };
  }
}