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 int32 add(int32& location, int32 value) noexcept;
      static int64 add(int64& location, int64 value) noexcept;
      
      static double compare_exchange(double& location, double value, double comparand) noexcept;
      static int32 compare_exchange(int32& location, int32 value, int32 comparand) noexcept;
      static int64 compare_exchange(int64& location, int64 value, int64 comparand) noexcept;
      static slong compare_exchange(slong& location, slong value, slong comparand) noexcept;
      static void* compare_exchange(void*& location, void* value, void* comparand) noexcept;
      template<typename type_t>
      static type_t compare_exchange(object& location, const object& value, const object& comparand) noexcept {
        type_t retValue = location;
        lock_(location) {
          if (location.equals(comparand)) location = value;
        }
        return retValue;
      }
      template<typename type_t>
      static type_t compare_exchange(type_t& location, type_t value, type_t comparand) noexcept {
        type_t retValue = location;
        lock_(location) {
          if (location == comparand) location = value;
        }
        return retValue;
      }
      static float compare_exchange(float& location, float value, float comparand) noexcept;
      
      static int32 decrement(int32& location) noexcept;
      static int64 decrement(int64& location) noexcept;
      
      template<typename type_t>
      static type_t exchange(type_t& location, type_t value) {
        type_t original = location;
        lock_(location)
          location = value;
        return original;
      }
      static double exchange(double& location, double value) noexcept;
      static int32 exchange(int32& location, int32 value) noexcept;
      static int64 exchange(int64& location, int64 value) noexcept;
      static slong exchange(slong& location, slong value) noexcept;
      static void* exchange(void*& location, void* value) noexcept;
      template<typename type_t>
      static type_t exchange(object& location, const object& value) noexcept {
        type_t original = location;
        lock_(location)
          location = value;
        return original;
      }
      static float exchange(float& location, float value) noexcept;
      
      static int32 increment(int32& location) noexcept;
      static int64 increment(int64& location) noexcept;
      
      static void memory_barrier() noexcept;
      
      static int64 read(int64& location) noexcept;
    };
  }
}