monitor.hpp

Go to the documentation of this file.

#pragma once
#include "timeout.hpp"
#include "../diagnostics/stack_frame.hpp"
#include "../core_export.hpp"
#include "../invalid_operation_exception.hpp"
#include "../static.hpp"
#include "../time_span.hpp"
#include "../types.hpp"
#include "../as.hpp"
#include "../is.hpp"
#include <unordered_map>
#include <utility>

namespace xtd {
  namespace threading {
    class lock;
    
    class core_export_ monitor static_ {
      class condition_variable;
      class critical_section;
      struct item;
      using item_collection = std::unordered_map<intptr, item>;
      using object_ptr = std::pair<intptr, bool>;
      struct static_data;
      
    public:
      
      template<class object_t>
      static auto enter(const object_t& obj) -> void {
        auto lock_taken = false;
        enter_ptr(get_ptr(obj), lock_taken);
      }
      
      template<class type_t>
      static auto enter(const type_t* str) -> void {enter(string(str));}
      
      template<class object_t>
      static auto enter(const object_t& obj, bool& lock_taken) -> void {enter_ptr(get_ptr(obj), lock_taken);}
      
      template<class type_t>
      static auto enter(const type_t* str, bool& lock_taken) -> void {enter(string(str), lock_taken);}
      
      template<class object_t>
      static auto exit(const object_t& obj) -> void {exit_ptr(get_ptr(obj));}
      
      template<class type_t>
      static auto exit(const type_t* str) -> void {exit(string(str));}
      
      template<class object_t>
      static auto is_entered(const object_t& obj) -> bool {return is_entered_ptr(get_ptr(obj));}
      
      template<class type_t>
      static auto is_entered(const type_t* str) -> bool {return is_entered(string(str));}
      
      template<class object_t>
      static auto pulse(const object_t& obj) -> void {pulse_ptr(get_ptr(obj));}
      
      template<class type_t>
      static auto pulse(const type_t* str) -> void {pulse(string(str));}
      
      template<class object_t>
      static auto pulse_all(const object_t& obj) -> void {pulse_all_ptr(get_ptr(obj));}
      
      template<class type_t>
      static auto pulse_all(const type_t* str) -> void {pulse_all(string(str));}
      
      template<class object_t>
      static auto try_enter(const object_t& obj) noexcept -> bool {
        auto lock_taken = false;
        return try_enter_ptr(get_ptr(obj), timeout::infinite, lock_taken);
      }
      
      template<class type_t>
      static auto try_enter(const type_t* str) -> bool {return try_enter(string(str));}
      
      template<class object_t>
      [[nodiscard]] static auto try_enter(const object_t& obj, bool& lock_taken) noexcept -> bool {return try_enter_ptr(get_ptr(obj), timeout::infinite, lock_taken);}
      
      template<class type_t>
      [[nodiscard]] static auto try_enter(const type_t* str, bool& lock_taken) -> bool {return try_enter(string(str), lock_taken);}
      
      template<class object_t>
      [[nodiscard]] static auto try_enter(const object_t& obj, int32 milliseconds_timeout) noexcept -> bool {
        auto lock_taken = false;
        return try_enter_ptr(get_ptr(obj), milliseconds_timeout, lock_taken);
      }
      
      template<class type_t>
      [[nodiscard]] static auto try_enter(const type_t* str, int32 milliseconds_timeout) -> bool {return try_enter(string(str), milliseconds_timeout);}
      
      template<class object_t>
      [[nodiscard]] static auto try_enter(const object_t& obj, int32 milliseconds_timeout, bool& lock_taken) noexcept -> bool {return try_enter_ptr(get_ptr(obj), milliseconds_timeout, lock_taken);}
      
      template<class type_t>
      [[nodiscard]] static auto try_enter(const type_t* str, int32 milliseconds_timeout, bool& lock_taken) -> bool {return try_enter(string(str), milliseconds_timeout, lock_taken);}
      
      template<class object_t>
      [[nodiscard]] static auto try_enter(const object_t& obj, int64 milliseconds_timeout) noexcept -> bool {
        auto lock_taken = false;
        return try_enter_ptr(get_ptr(obj), static_cast<int32>(milliseconds_timeout), lock_taken);
      }
      
      template<class type_t>
      [[nodiscard]] static auto try_enter(const type_t* str, int64 milliseconds_timeout) -> bool {return try_enter(string(str), milliseconds_timeout);}
      
      template<class object_t>
      [[nodiscard]] static auto try_enter(const object_t& obj, int64 milliseconds_timeout, bool& lock_taken) noexcept -> bool {return try_enter_ptr(get_ptr(obj), static_cast<int32>(milliseconds_timeout), lock_taken);}
      
      template<class type_t>
      [[nodiscard]] static bool try_enter(const type_t* str, int64 milliseconds_timeout, bool& lock_taken) {return try_enter(string(str), milliseconds_timeout, lock_taken);}
      
      template<class object_t>
      [[nodiscard]] static auto try_enter(const object_t& obj, const time_span& timeout) noexcept -> bool {
        auto lock_taken = false;
        return try_enter_ptr(get_ptr(obj), timeout.total_milliseconds_duration().count(), lock_taken);
      }
      
      template<class type_t>
      [[nodiscard]] static auto try_enter(const type_t* str, const time_span& timeout) -> bool {return try_enter(string(str), timeout);}
      
      template<class object_t>
      [[nodiscard]] static auto try_enter(const object_t& obj, const time_span& timeout, bool& lock_taken) noexcept -> bool {return try_enter_ptr(get_ptr(obj), timeout.total_milliseconds_duration().count(), lock_taken);}
      
      template<class object_t>
      static auto wait(const object_t& obj, int32 milliseconds_timeout) -> bool {return wait_ptr(get_ptr(obj), milliseconds_timeout);}
      
      template<class object_t>
      static auto wait(const object_t& obj, const time_span& timeout) -> bool {return wait_ptr(get_ptr(obj), as<int32>(timeout.total_milliseconds()));}
      
      template<class object_t>
      static auto wait(const object_t& obj) -> bool {return wait_ptr(get_ptr(obj), timeout::infinite);}
      
      template<class type_t>
      [[nodiscard]] static auto try_enter(const type_t* str, const time_span& timeout, bool& lock_taken) -> bool {return try_enter(string(str), timeout, lock_taken);}
      
    private:
      friend class xtd::threading::lock;
      
      static auto get_static_data() -> static_data&;
      
      template<class object_t>
      [[nodiscard]] static auto get_ptr(const object_t& obj) noexcept -> object_ptr {
        bool is_string = is<string>(obj);
        // The newly created string will be deleted when the exit method is called, or if the lock has already been entered.
        return std::make_pair(is_string ? get_string_ptr(*(new string(as<string>(obj)))) : reinterpret_cast<intptr>(&obj), is_string);
      }
      
      template<class type_t>
      [[nodiscard]] static auto get_ptr(const type_t* str) -> object_ptr {return get_ptr(string(str));}
      
      static auto enter_ptr(object_ptr obj) -> void;
      static auto enter_ptr(object_ptr obj, bool& lock_taken) -> void;
      static auto exit_ptr(object_ptr obj) -> void;
      [[nodiscard]] static auto get_string_ptr(const string& str) -> intptr;
      static auto is_entered_ptr(object_ptr obj) noexcept -> bool;
      static auto pulse_ptr(object_ptr obj) -> void;
      static auto pulse_all_ptr(object_ptr obj) -> void;
      static auto try_enter_ptr(object_ptr obj, int32 milliseconds_timeout, bool& lock_taken) noexcept -> bool;
      static auto wait_ptr(object_ptr obj, int32 milliseconds_timeout) -> bool;
    };
  }
}