wait_handle.h

Go to the documentation of this file.

 
#pragma once
 
#include "timeout.h"
#include "../abstract.h"
#include "../as.h"
#include "../size_object.h"
#include "../time_span.h"
#include "../types.h"
#include <limits>
#include <vector>
 
namespace xtd {
  namespace threading {
    class registered_wait_handle;
    class thread;
    
    class core_export_ wait_handle abstract_ {
      friend class registered_wait_handle;
      friend class thread;
    public:
      
      static const intptr invalid_handle;
      
      static constexpr size_t wait_timeout = size_object::max_value;
      
      
      wait_handle() = default;
      
      ~wait_handle();
 
      
      virtual intptr handle() const noexcept = 0;
      virtual void handle(intptr value) = 0;
      
      
      virtual void close();
      
      virtual bool wait_one();
      
      virtual bool wait_one(int32 milliseconds_timeout);
      
      virtual bool wait_one(const time_span& timeout);
      
      
      static bool signal_and_wait(wait_handle& to_signal, wait_handle& to_wait);
      
      static bool signal_and_wait(wait_handle& to_signal, wait_handle& to_wait, int32 milliseconds_timeout);
      
      static bool signal_and_wait(wait_handle& to_signal, wait_handle& to_wait, const time_span& timeout);
      
      template<typename collection_t>
      static bool wait_all(const collection_t& wait_handles) {return wait_all(wait_handles, timeout::infinite);}
      
      template<typename collection_t>
      static bool wait_all(const collection_t& wait_handles, int32 milliseconds_timeout) {
        std::vector<wait_handle*> wait_handle_pointers;
        for (auto& item : wait_handles)
          wait_handle_pointers.push_back(const_cast<wait_handle*>(as<wait_handle>(&item)));
        return wait_all(wait_handle_pointers, milliseconds_timeout);
      }
      
      template<typename collection_t>
      static bool wait_all(const collection_t& wait_handles, const time_span& timeout) {return wait_all(wait_handles, as<int32>(timeout.total_milliseconds_duration().count()));}
      
      template<typename collection_t>
      static size_t wait_any(const collection_t& wait_handles) {return wait_any(wait_handles, timeout::infinite);}
      
      template<typename collection_t>
      static size_t wait_any(const collection_t& wait_handles, int32 milliseconds_timeout) {
        std::vector<wait_handle*> wait_handle_pointers;
        for (auto& item : wait_handles)
          wait_handle_pointers.push_back(const_cast<wait_handle*>(as<wait_handle>(&item)));
        return wait_any(wait_handle_pointers, milliseconds_timeout);
      }
      
      template<typename collection_t>
      static size_t wait_any(const collection_t& wait_handles, const time_span& timeout) {return wait_any(wait_handles, as<int32>(timeout.total_milliseconds_duration().count()));}
 
      template <typename... items_t>
      static size_t wait_all(items_t... items) {return wait_all(timeout::infinite, items...);}
      template <typename... items_t>
      static size_t wait_all(const time_span& timeout, items_t... items) {return wait_all(as<int32>(timeout.total_milliseconds()), items...);}
      template <typename... items_t>
      static size_t wait_all(int32 milliseconds_timeout, items_t... items) {
        std::vector<wait_handle*> wait_handle_pointers;
        fill_wait_handle_pointers(wait_handle_pointers, items...);
        return wait_all(wait_handle_pointers, milliseconds_timeout);
      }
      template<typename item_t>
      static bool wait_all(const std::initializer_list<item_t>& wait_handles) {return wait_all(wait_handles, timeout::infinite);}
      template<typename item_t>
      static bool wait_all(const std::initializer_list<item_t>& wait_handles, int32 milliseconds_timeout) {
        std::vector<wait_handle*> wait_handle_pointers;
        for (auto& item : wait_handles)
          wait_handle_pointers.push_back(const_cast<wait_handle*>(as<wait_handle>(&item)));
        return wait_all(wait_handle_pointers, milliseconds_timeout);
      }
      template<typename item_t>
      static bool wait_all(const std::initializer_list<item_t>& wait_handles, const time_span& timeout) {return wait_all(wait_handles, as<int32>(timeout.total_milliseconds_duration().count()));}
      static bool wait_all(const std::initializer_list<std::shared_ptr<wait_handle>>& wait_handles);
      static bool wait_all(const std::initializer_list<std::shared_ptr<wait_handle>>& wait_handles, int32 milliseconds_timeout);
      static bool wait_all(const std::initializer_list<std::shared_ptr<wait_handle>>& wait_handles, const time_span& timeout);
      static bool wait_all(const std::initializer_list<std::unique_ptr<wait_handle>>& wait_handles);
      static bool wait_all(const std::initializer_list<std::unique_ptr<wait_handle>>& wait_handles, int32 milliseconds_timeout);
      static bool wait_all(const std::initializer_list<std::unique_ptr<wait_handle>>& wait_handles, const time_span& timeout);
      static bool wait_all(const std::vector<std::shared_ptr<wait_handle>>& wait_handles);
      static bool wait_all(const std::vector<std::shared_ptr<wait_handle>>& wait_handles, int32 milliseconds_timeout);
      static bool wait_all(const std::vector<std::shared_ptr<wait_handle>>& wait_handles, const time_span& timeout);
      static bool wait_all(const std::vector<std::unique_ptr<wait_handle>>& wait_handles);
      static bool wait_all(const std::vector<std::unique_ptr<wait_handle>>& wait_handles, int32 milliseconds_timeout);
      static bool wait_all(const std::vector<std::unique_ptr<wait_handle>>& wait_handles, const time_span& timeout);
      static bool wait_all(const std::vector<wait_handle*>& wait_handles, int32 milliseconds_timeout);
 
      template <typename... items_t>
      static size_t wait_any(items_t... items) {return wait_any(timeout::infinite, items...);}
      template <typename... items_t>
      static size_t wait_any(const time_span& timeout, items_t... items) {return wait_any(as<int32>(timeout.total_milliseconds()), items...);}
      template <typename... items_t>
      static size_t wait_any(int32 milliseconds_timeout, items_t... items) {
        std::vector<wait_handle*> wait_handle_pointers;
        fill_wait_handle_pointers(wait_handle_pointers, items...);
        return wait_any(wait_handle_pointers, milliseconds_timeout);
      }
      template<typename item_t>
      static size_t wait_any(const std::initializer_list<item_t>& wait_handles) {return wait_any(wait_handles, timeout::infinite);}
      template<typename item_t>
      static size_t wait_any(const std::initializer_list<item_t>& wait_handles, int32 milliseconds_timeout) {
        std::vector<wait_handle*> wait_handle_pointers;
        for (auto& item : wait_handles)
          wait_handle_pointers.push_back(const_cast<wait_handle*>(as<wait_handle>(&item)));
        return wait_any(wait_handle_pointers, milliseconds_timeout);
      }
      template<typename item_t>
      static size_t wait_any(const std::initializer_list<item_t>& wait_handles, const time_span& timeout) {return wait_any(wait_handles, as<int32>(timeout.total_milliseconds_duration().count()));}
      static size_t wait_any(const std::initializer_list<std::shared_ptr<wait_handle>>& wait_handles);
      static size_t wait_any(const std::initializer_list<std::shared_ptr<wait_handle>>& wait_handles, int32 milliseconds_timeout);
      static size_t wait_any(const std::initializer_list<std::shared_ptr<wait_handle>>& wait_handles, const time_span& timeout);
      static size_t wait_any(const std::initializer_list<std::unique_ptr<wait_handle>>& wait_handles);
      static size_t wait_any(const std::initializer_list<std::unique_ptr<wait_handle>>& wait_handles, int32 milliseconds_timeout);
      static size_t wait_any(const std::initializer_list<std::unique_ptr<wait_handle>>& wait_handles, const time_span& timeout);
      static size_t wait_any(const std::vector<std::shared_ptr<wait_handle>>& wait_handles);
      static size_t wait_any(const std::vector<std::shared_ptr<wait_handle>>& wait_handles, int32 milliseconds_timeout);
      static size_t wait_any(const std::vector<std::shared_ptr<wait_handle>>& wait_handles, const time_span& timeout);
      static size_t wait_any(const std::vector<std::unique_ptr<wait_handle>>& wait_handles);
      static size_t wait_any(const std::vector<std::unique_ptr<wait_handle>>& wait_handles, int32 milliseconds_timeout);
      static size_t wait_any(const std::vector<std::unique_ptr<wait_handle>>& wait_handles, const time_span& timeout);
      static size_t wait_any(const std::vector<wait_handle*>& wait_handles, int32 milliseconds_timeout);
 
    protected:
      
      virtual bool signal() = 0;
      
      virtual bool wait(int32 milliseconds_timeout) = 0;
 
    private:
      template <typename item_t, typename... items_t>
      static void fill_wait_handle_pointers(std::vector<wait_handle*>& wait_handle_pointers, item_t& first, items_t&... rest) {
        wait_handle_pointers.push_back(const_cast<wait_handle*>(as<wait_handle>(&first)));
        fill_wait_handle_pointers(wait_handle_pointers, rest...);
      }
      template <typename item_t>
      static void fill_wait_handle_pointers(std::vector<wait_handle*>& wait_handle_pointers, item_t& item) {
        wait_handle_pointers.push_back(const_cast<wait_handle*>(as<wait_handle>(&item)));
      }
    };
  }
}