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 ustring& name);
      mutex(const ustring& name, bool& created_new);
      mutex(bool initially_owned, const ustring& name);
      mutex(bool initially_owned, const ustring& name, bool& created_new);

      template <typename char_t>
      explicit mutex(const char_t* name) : mutex(ustring(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;
      
      bool equals(const mutex& value) const noexcept override;
      
      void lock();

      static mutex open_existing(const ustring& name);

      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;
      
      static bool try_open_existing(const ustring& name, mutex& result) noexcept;

      void unlock();
      
    protected:
      
      bool signal() override;

      bool wait(int32 milliseconds_timeout) override;

    private:
      friend class thread;
      void create(bool initially_owned, bool& created_new);
      std::shared_ptr<mutex_base> mutex_;
      ustring name_;
    };
  }
}