semaphore.hpp

Go to the documentation of this file.

 
#pragma once
#include "semaphore_full_exception.hpp"
#include "wait_handle.hpp"
#include "../icomparable.hpp"
#include "../iequatable.hpp"
#include "../int32_object.hpp"
 
namespace xtd {
  namespace threading {
    class core_export_ semaphore : public wait_handle, public icomparable<semaphore>, public iequatable<semaphore> {
      class semaphore_base;
      class named_semaphore;
      class unnamed_semaphore;
      struct data;
    public:
      
      semaphore();
      explicit semaphore(const string& name);
      explicit semaphore(const string& name, bool& created_new);
      explicit semaphore(int32 initial_count);
      semaphore(int32 initial_count, const string& name);
      semaphore(int32 initial_count, const string& name, bool& created_new);
      semaphore(int32 initial_count, int32 maximum_count);
      semaphore(int32 initial_count, int32 maximum_count, const string& name);
      semaphore(int32 initial_count, int32 maximum_count, const string& name, bool& created_new);
 
      template <typename char_t>
      explicit semaphore(const char_t* name) : semaphore(string(name)) {}
      ~semaphore();
 
      
      intptr handle() const noexcept override;
      void handle(intptr value) override;
      
      
      void close() override;
      
      int32 compare_to(const semaphore& value) const noexcept override;
      
      using object::equals;
      bool equals(const semaphore& value) const noexcept override;
 
      int32 release();
      int32 release(int32 release_count);
 
      
      static semaphore open_existing(const string& name);
 
      static bool try_open_existing(const string& name, semaphore& result) noexcept;
 
    protected:
      
      bool signal() override;
 
      bool wait(int32 milliseconds_timeout) override;
 
    private:
      void create(int32 initial_count, int32 maximum_count, bool& created_new);
      xtd::sptr<semaphore_base> semaphore_;
      xtd::sptr<data> data_;
    };
  }
}