mutex.h

Go to the documentation of this file.

 
#pragma once
#include "wait_handle.h"
#include "../date_time.h"
#include "../icomparable.h"
#include "../iequatable.h"
 
namespace xtd {
  namespace threading {
    class thread;
    
    class core_export_ mutex : public wait_handle, public icomparable<mutex>, public iequatable<mutex> {
      class mutex_base;
      class named_mutex;
      class unnamed_mutex;
    public:
      
      using native_handle_type = intptr;
      
      
      mutex();
      explicit mutex(bool initially_owned);
      explicit mutex(const string& name);
      mutex(const string& name, bool& created_new);
      mutex(bool initially_owned, const string& name);
      mutex(bool initially_owned, const string& name, bool& created_new);
 
      template <typename char_t>
      explicit mutex(const char_t* name) : mutex(string(name)) {}
      ~mutex();
 
      
      intptr handle() const noexcept override;
      void handle(intptr value) override;
 
      native_handle_type native_handle() const noexcept;
      
      
      void close() override;
      
      int32 compare_to(const mutex& value) const noexcept override;
      
      using object::equals;
      bool equals(const mutex& value) const noexcept override;
      
      void lock();
 
      void release_mutex();
      
      bool try_lock() noexcept;
      
      bool try_lock_for(const time_span& timeout) noexcept;
      
      bool try_lock_until(const date_time& timeout_time) noexcept;
 
      void unlock();
      
      
      static mutex open_existing(const string& name);
      
      static bool try_open_existing(const string& name, mutex& result) noexcept;
 
    protected:
      
      bool signal() override;
 
      bool wait(int32 milliseconds_timeout) override;
 
    private:
      friend class thread;
      void create(bool initially_owned, bool& created_new);
      xtd::sptr<mutex_base> mutex_;
      string name_;
    };
  }
}