monitor.hpp

Go to the documentation of this file.

 
#pragma once
#include "timeout.hpp"
#include "../collections/generic/key_value_pair.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_guard;
    
    class core_export_ monitor static_ {
      class condition_variable;
      class critical_section;
      struct item;
      using item_collection = std::unordered_map<intptr, item>;
      using object_ptr = xtd::collections::generic::key_value_pair<intptr, bool>;
      struct static_data;
      
    public:
      
      template<typename object_t>
      static void enter(const object_t& obj) {
        auto lock_taken = false;
        enter_ptr(get_ptr(obj), lock_taken);
      }
      
      template<typename type_t>
      static void enter(const type_t* str) {enter(string(str));}
 
      template<typename object_t>
      static void enter(const object_t& obj, bool& lock_taken) {
        enter_ptr(get_ptr(obj), lock_taken);
      }
      
      template<typename type_t>
      static void enter(const type_t* str, bool& lock_taken) {enter(string(str), lock_taken);}
 
      template<typename object_t>
      static void exit(const object_t& obj) {
        exit_ptr(get_ptr(obj));
      }
      
      template<typename type_t>
      static void exit(const type_t* str) {exit(string(str));}
 
      template<typename object_t>
      static bool is_entered(const object_t& obj) {
        return is_entered_ptr(get_ptr(obj));
      }
 
      template<typename type_t>
      static bool is_entered(const type_t* str) {return is_entered(string(str));}
 
      template<typename object_t>
      static void pulse(const object_t& obj) {
        pulse_ptr(get_ptr(obj));
      }
      
      template<typename type_t>
      static void pulse(const type_t* str) {pulse(string(str));}
 
      template<typename object_t>
      static void pulse_all(const object_t& obj) {
        pulse_all_ptr(get_ptr(obj));
      }
      
      template<typename type_t>
      static void pulse_all(const type_t* str) {pulse_all(string(str));}
 
      template<typename object_t>
      static bool try_enter(const object_t& obj) noexcept {
        auto lock_taken = false;
        return try_enter_ptr(get_ptr(obj), timeout::infinite, lock_taken);
      }
      
      template<typename type_t>
      static bool try_enter(const type_t* str) {return try_enter(string(str));}
 
      template<typename object_t>
      static bool try_enter(const object_t& obj, bool& lock_taken) noexcept {
        return try_enter_ptr(get_ptr(obj), timeout::infinite, lock_taken);
      }
      
      template<typename type_t>
      static bool try_enter(const type_t* str, bool& lock_taken) {return try_enter(string(str), lock_taken);}
 
      template<typename object_t>
      static bool try_enter(const object_t& obj, int32 milliseconds_timeout) noexcept {
        auto lock_taken = false;
        return try_enter_ptr(get_ptr(obj), milliseconds_timeout, lock_taken);
      }
      
      template<typename type_t>
      static bool try_enter(const type_t* str, int32 milliseconds_timeout) {return try_enter(string(str), milliseconds_timeout);}
 
      template<typename object_t>
      static bool try_enter(const object_t& obj, int32 milliseconds_timeout, bool& lock_taken) noexcept {
        return try_enter_ptr(get_ptr(obj), milliseconds_timeout, lock_taken);
      }
      
      template<typename type_t>
      static bool try_enter(const type_t* str, int32 milliseconds_timeout, bool& lock_taken) {return try_enter(string(str), milliseconds_timeout, lock_taken);}
 
      template<typename object_t>
      static bool try_enter(const object_t& obj, int64 milliseconds_timeout) noexcept {
        auto lock_taken = false;
        return try_enter_ptr(get_ptr(obj), static_cast<int32>(milliseconds_timeout), lock_taken);
      }
      
      template<typename type_t>
      static bool try_enter(const type_t* str, int64 milliseconds_timeout) {return try_enter(string(str), milliseconds_timeout);}
 
      template<typename object_t>
      static bool try_enter(const object_t& obj, int64 milliseconds_timeout, bool& lock_taken) noexcept {
        return try_enter_ptr(get_ptr(obj), static_cast<int32>(milliseconds_timeout), lock_taken);
      }
      
      template<typename type_t>
      static bool try_enter(const type_t* str, int64 milliseconds_timeout, bool& lock_taken) {return try_enter(string(str), milliseconds_timeout, lock_taken);}
 
      template<typename object_t>
      static bool try_enter(const object_t& obj, const time_span& timeout) noexcept {
        auto lock_taken = false;
        return try_enter_ptr(get_ptr(obj), timeout.total_milliseconds_duration().count(), lock_taken);
      }
      
      template<typename type_t>
      static bool try_enter(const type_t* str, const time_span& timeout) {return try_enter(string(str), timeout);}
 
      template<typename object_t>
      static bool try_enter(const object_t& obj, const time_span& timeout, bool& lock_taken) noexcept {
        return try_enter_ptr(get_ptr(obj), timeout.total_milliseconds_duration().count(), lock_taken);
      }
 
      template<typename object_t>
      static bool wait(const object_t& obj, int32 milliseconds_timeout) {
        return wait_ptr(get_ptr(obj), milliseconds_timeout);
      }
      
      template<typename object_t>
      static bool wait(const object_t& obj, const time_span& timeout) {
        return wait_ptr(get_ptr(obj), as<int32>(timeout.total_milliseconds()));
      }
 
      template<typename object_t>
      static bool wait(const object_t& obj) {
        return wait_ptr(get_ptr(obj), timeout::infinite);
      }
 
      template<typename type_t>
      static bool try_enter(const type_t* str, const time_span& timeout, bool& lock_taken) {return try_enter(string(str), timeout, lock_taken);}
      
    private:
      friend class xtd::threading::lock_guard;
 
      static static_data& get_static_data();
 
      template<typename object_t>
      static object_ptr get_ptr(const object_t& obj) noexcept {
        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_ustring_ptr(*(new string(as<string>(obj)))) : reinterpret_cast<intptr>(&obj), is_string);
      }
      
      template<typename type_t>
      static object_ptr get_ptr(const type_t* str) {return get_ptr(string(str));}
 
      static void enter_ptr(object_ptr obj);
      static void enter_ptr(object_ptr obj, bool& lock_taken);
      static void exit_ptr(object_ptr obj);
      static intptr get_ustring_ptr(const string& str);
      static bool is_entered_ptr(object_ptr obj) noexcept;
      static void pulse_ptr(object_ptr obj);
      static void pulse_all_ptr(object_ptr obj);
      static bool try_enter_ptr(object_ptr obj, int32 milliseconds_timeout, bool& lock_taken) noexcept;
      static bool wait_ptr(object_ptr obj, int32 milliseconds_timeout);
    };
  }
}