barrier.hpp

Go to the documentation of this file.

 
#pragma once
#include "barrier_post_phase_exception.hpp"
#include "cancellation_token.hpp"
#include "../action.hpp"
#include "../object.hpp"
#include "../time_span.hpp"
 
namespace xtd {
  namespace threading {
    class core_export_ barrier : public object {
      struct data;
    public:
      
      using post_phase_action = action<barrier&>;
      
      
      explicit barrier(int32 participant_count);
      barrier(int32 participant_count, barrier::post_phase_action post_phase_action);
 
      template <typename post_phase_action_t>
      barrier(int32 participant_count, post_phase_action_t post_phase_action) : barrier(participant_count, barrier::post_phase_action {post_phase_action}) {}
      barrier();
      barrier(barrier&&) = default;
      barrier(const barrier&) = default;
      barrier& operator =(const barrier& other);
      ~barrier();
 
      
      int32 current_phase_number() const;
 
      int32 participant_count() const;
 
      int32 participants_remaining() const;
 
      
      int32 add_participant();
 
      int32 add_participants(int32 participant_count);
      
      void close();
 
      int32 remove_participant();
      
      int32 remove_participants(int32 participant_count);
 
      void signal_and_wait();
      bool signal_and_wait(int32 milliseconds_timeout);
      bool signal_and_wait(const cancellation_token& cancellation_token);
      bool signal_and_wait(const time_span& timeout);
      bool signal_and_wait(int32 milliseconds_timeout, const cancellation_token& cancellation_token);
      bool signal_and_wait(const time_span& timeout, const cancellation_token& cancellation_token);
 
    private:
      bool wait_wtih_cancellation_token();
      bool wait_wtih_cancellation_token(int32 milliseconds_timeout);
 
      xtd::sptr<data> data_;
    };
  }
}