delegate.hpp

Go to the documentation of this file.

#pragma once
#include "any.hpp"
#include "expressions/expression_operand.hpp"
#include "async_result.hpp"
#include "iequatable.hpp"
#include "object.hpp"
#include "object_ref.hpp"
#include "usize.hpp"
#include <functional>
#include <vector>

namespace xtd {
  template<typename result_t>
  class delegate;
  
  template<typename result_t, typename ...arguments_t>
  class delegate<result_t(arguments_t...)>;
  
  using async_callback = xtd::delegate<void(async_result ar)>;
  
  template<typename result_t>
  class delegate<result_t()> : public xtd::object, public xtd::iequatable<delegate<result_t()>> {
    struct data {
      std::vector<std::function<result_t()>> functions;
    };
    
    class async_result_invoke : public xtd::iasync_result {
      struct data;
    public:
      async_result_invoke(xtd::async_callback async_callback, const xtd::any_object& async_state);
      [[nodiscard]] auto async_state() const noexcept -> xtd::any_object override;
      [[nodiscard]] auto async_wait_handle() noexcept -> xtd::threading::wait_handle& override;
      [[nodiscard]] auto completed_synchronously() const noexcept -> bool override;
      [[nodiscard]] auto is_completed() const noexcept -> bool override;
      
      xtd::sptr<data> data_;
    };
    
  public:
    
    using function_t = std::function<result_t()>;
    using function_collection = std::vector<function_t>;
    
    
    delegate() = default;
    delegate(delegate&&) = default;
    delegate(const delegate& other) {*data_ = *other.data_;}
    delegate& operator =(const delegate& other) {*data_ = *other.data_; return *this;}
 
    template <typename fct_t>
    requires (!xtd::expressions::expression_operand<fct_t>) &&
    (!std::same_as<std::decay_t<fct_t>, delegate>) &&
    (!std::same_as<std::decay_t<fct_t>, function_t>) &&
    std::invocable<fct_t&> &&
    std::convertible_to<std::invoke_result_t<fct_t&>, result_t>
    delegate(fct_t&& f) {data_->functions.push_back(function_t(std::forward<fct_t>(f)));}
    
    delegate(const function_t& function) noexcept {data_->functions.push_back(function);} // Can't be explicit by design.
    
    template<class object1_t, typename object2_t>
    delegate(const object1_t& object, result_t(object2_t::*method)() const) noexcept {data_->functions.push_back(function_t(std::bind(method, const_cast<object1_t*>(&object))));}
    template<class object1_t, typename object2_t>
    delegate(const object1_t& object, result_t(object2_t::*method)()) noexcept {data_->functions.push_back(function_t(std::bind(method, const_cast<object1_t*>(&object))));}
    
    
    [[nodiscard]] auto count() const noexcept -> xtd::usize {return data_->functions.size();}
    
    [[nodiscard]] auto functions() const -> const function_collection& {return data_->functions;}
    
    [[nodiscard]] auto is_empty() const noexcept -> bool {return count() == 0;}
    
    [[nodiscard]] auto size() const noexcept -> xtd::usize {return count();}
    
    
    auto clear() -> void {data_->functions.clear();}
    
    [[nodiscard]] auto begin_invoke() -> async_result;
    [[nodiscard]] auto begin_invoke(xtd::async_callback async_callback) -> async_result;
    [[nodiscard]] auto begin_invoke(xtd::async_callback async_callback, const xtd::any_object& async_state) -> async_result;
    
    auto end_invoke(async_result async) -> result_t;
    
    auto invoke() const -> result_t {return operator()();}
    
    [[nodiscard]] auto equals(const object& obj) const noexcept -> bool override {return is<delegate>(obj) && equals(static_cast<const delegate&>(obj));}
    [[nodiscard]] auto equals(const delegate& other) const noexcept -> bool override {
      if (data_->functions.size() != other.data_->functions.size()) return false;
      for (auto i = xtd::usize {0}; i < data_->functions.size(); i++)
        if (!are_equals(data_->functions[i], other.data_->functions[i])) return false;
      return true;
    }

    
    
    [[nodiscard]] static auto combine(const xtd::array<delegate>& delegates) noexcept -> delegate {
      auto result = delegate {};
      for (auto delegate : delegates)
        for (auto function : delegate.data_->functions)
          result.data_->functions.push_back(function);
      return result;
    }
    
    [[nodiscard]] static auto combine(const delegate& a, const delegate& b) noexcept -> delegate {return combine({a, b});}
    
    [[nodiscard]] static auto remove(const delegate& source, const delegate& value) noexcept -> delegate {
      auto result = source;
      std::for_each(value.data_->functions.begin(), value.data_->functions.end(), [&](const auto& function) {
        auto iterator = std::find_if(result.data_->functions.rbegin(), result.data_->functions.rend(), [&](const auto& item) {return are_equals(item, function);});
        if (iterator != result.data_->functions.rend()) result.data_->functions.erase((iterator + 1).base());
      });
      return result;
    }
    
    [[nodiscard]] static auto remove_all(const delegate& source, const delegate& value) noexcept -> delegate {
      delegate result = source;
      for (const function_t& function : value.data_->functions) {
        if (find(result.data_->functions.begin(), result.data_->functions.end(), function) != result.data_->functions.end()) {
          for (typename function_collection::reverse_iterator iterator = result.data_->functions.rbegin(); iterator != result.data_->functions.rend(); ++iterator) {
            if (are_equals(*iterator, function))
              result.data_->functions.erase((iterator + 1).base());
          }
        }
      }
      return result;
    }

    
    
    auto operator()() const -> result_t {
      if (data_->functions.size() == 0) {
        if constexpr(std::is_void_v<result_t>) return;
        else if constexpr(std::is_reference_v<result_t>) {
          using underlying_t = std::remove_reference_t<result_t>;
          if constexpr(std::is_const_v<underlying_t>) {
            static const underlying_t empty_value{};
            return empty_value;
          } else {
            static underlying_t empty_value{};
            return empty_value;
          }
        } else return result_t{};
      }
      
      for (auto i = xtd::usize {0}; i < data_->functions.size() - 1; i++) {
        if (data_->functions[i] == nullptr) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_null);
        data_->functions[i]();
      }
      if (data_->functions.back() == nullptr) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_null);
      return data_->functions.back()();
    }
    
    auto operator =(const function_t& function) noexcept -> delegate& {
      data_->functions.clear();
      data_->functions.push_back(function);
      return *this;
    }
    
    [[nodiscard]] auto operator +(const delegate& other) const noexcept -> delegate {
      delegate result = *this;
      result += other;
      return result;
    }
    
    [[nodiscard]] auto operator +(const function_t& function) const noexcept -> delegate {
      delegate result = *this;
      result += function;
      return result;
    }
    
    template<class fn_t>
    [[nodiscard]] auto operator +(fn_t function) const noexcept -> delegate {
      delegate result = *this;
      result += function;
      return result;
    }
    
    auto operator +=(const delegate& other) noexcept -> delegate& {
      for (const auto& function : other.data_->functions)
        data_->functions.push_back(function);
      return *this;
    }
    
    auto operator +=(delegate&& other) noexcept -> delegate& {
      for (auto&& function : other.data_->functions)
        data_->functions.push_back(std::move(function));
      return *this;
    }
    
    auto operator +=(const function_t& function) noexcept -> delegate& {
      data_->functions.push_back(delagate(function));
      return *this;
    }
    
    template<class fn_t>
    auto operator +=(fn_t function) noexcept -> delegate& {
      data_->functions.push_back(delegate(function));
      return *this;
    }
    
    [[nodiscard]] auto operator -(const delegate& other) const noexcept -> delegate {
      delegate result = *this;
      result -= other;
      return result;
    }
    
    [[nodiscard]] auto operator -(const function_t& function) const noexcept -> delegate {
      delegate result = *this;
      result -= function;
      return result;
    }
    
    template<class fn_t>
    [[nodiscard]] auto operator -(fn_t function) const noexcept -> delegate {
      delegate result = *this;
      result -= function;
      return result;
    }
    
    auto operator -=(const delegate& other) noexcept -> delegate& {
      std::for_each(other.data_->functions.begin(), other.data_->functions.end(), [&](const auto& function) {
        auto iterator = std::find_if(data_->functions.rbegin(), data_->functions.rend(), [&](const auto& item) {return are_equals(item, function);});
        if (iterator != data_->functions.rend()) data_->functions.erase((iterator + 1).base());
      });
      return *this;
    }
    
    auto operator -=(const function_t& function) noexcept -> delegate& {
      auto iterator = std::find_if(data_->functions.rbegin(), data_->functions.rend(), [&](const auto& item) {return are_equals(item, function);});
      if (iterator != data_->functions.rend()) data_->functions.erase((iterator + 1).base());
      return *this;
    }
    
    template<class fn_t>
    auto operator -=(fn_t function) noexcept -> delegate& {
      auto iterator = std::find_if(data_->functions.rbegin(), data_->functions.rend(), [&](const auto& item) {return are_equals(item, function);});
      if (iterator != data_->functions.rend()) data_->functions.erase((iterator + 1).base());
      return *this;
    }
    
  private:
    [[nodiscard]] static auto are_equals(const std::function<result_t()>& fct1, const std::function<result_t()>& fct2) noexcept -> bool {return fct1.target_type() == fct2.target_type() && (fct1.template target<result_t(*)()>() == fct2.template target<result_t(*)()>() || *fct1.template target<result_t(*)()>() == *fct2.template target<result_t(*)()>());}
    [[nodiscard]] static auto find(typename function_collection::const_iterator begin, typename function_collection::const_iterator end, const function_t& function) noexcept -> typename function_collection::const_iterator {
      auto iterator = std::find_if(begin, end, [&](const auto& item) {return are_equals(item, function);});
      if (iterator != end) return iterator;
      return end;
    }
    
    xtd::sptr<data> data_ = xtd::new_sptr<data>();
  };
  
  template<class result_t, typename ...arguments_t>
  class delegate<result_t(arguments_t...)> : public object, public xtd::iequatable<delegate<result_t(arguments_t...)>> {
    struct data {
      std::vector<std::function<result_t()>> no_arguments_functions;
      std::vector<std::function<result_t(arguments_t...)>> functions;
    };
    
    class async_result_invoke : public xtd::iasync_result {
      struct data;
    public:
      async_result_invoke(xtd::async_callback async_callback, const xtd::any_object& async_state);
      [[nodiscard]] auto async_state() const noexcept -> xtd::any_object override;
      [[nodiscard]] auto async_wait_handle() noexcept -> xtd::threading::wait_handle& override;
      [[nodiscard]] auto completed_synchronously() const noexcept -> bool override;
      [[nodiscard]] auto is_completed() const noexcept -> bool override;
      
      xtd::sptr<data> data_;
    };
    
  public:
    
    using no_arguments_function_t = std::function<result_t()>;
    using function_t = std::function<result_t(arguments_t...)>;
    using no_arguments_function_collection = std::vector<no_arguments_function_t>;
    using function_collection = std::vector<function_t>;
    
    
    delegate() = default;
    delegate(delegate&&) = default;
    delegate(const delegate& other) {*data_ = *other.data_;}
    delegate& operator =(const delegate& other) {*data_ = *other.data_; return *this;}
    
    delegate(const function_t& function) noexcept {data_->functions.push_back(function);} // Can't be explicit by design.
    
    template<class object1_t, typename object2_t>
    delegate(const object1_t& object, result_t(object2_t::*method)() const) noexcept {data_->functions.push_back(function_t(std::bind(method, const_cast<object1_t*>(&object))));}
    
    template<class object1_t, typename object2_t>
    delegate(const object1_t& object, result_t(object2_t::*method)()) noexcept {data_->functions.push_back(function_t(std::bind(method, const_cast<object1_t*>(&object))));}
    
    template<class object1_t, typename object2_t, typename... args_t>
    delegate(const object1_t& object, result_t(object2_t::*method)(args_t...) const) noexcept {data_->functions.push_back(function_t(std::bind_front(method, const_cast<object1_t*>(&object))));}
 
    template<class object1_t, typename object2_t, typename... args_t>
    delegate(const object1_t& object, result_t(object2_t::*method)(args_t...)) noexcept {data_->functions.push_back(function_t(std::bind_front(method, const_cast<object1_t*>(&object))));}
 
    template <typename fct_t>
    requires (!xtd::expressions::expression_operand<fct_t>) &&
    (!std::same_as<std::decay_t<fct_t>, delegate>) &&
    (!std::same_as<std::decay_t<fct_t>, function_t>) &&
    std::invocable<fct_t&, arguments_t...>
    delegate(fct_t&& f) {data_->functions.push_back(function_t(std::forward<fct_t>(f)));}
 
    template <typename fct_t>
    requires (!xtd::expressions::expression_operand<fct_t>) &&
    (!std::same_as<std::decay_t<fct_t>, delegate>) &&
    (!std::same_as<std::decay_t<fct_t>, function_t>) &&
    std::invocable<fct_t&>
    delegate(fct_t&& f) {data_->no_arguments_functions.push_back(no_arguments_function_t(std::forward<fct_t>(f)));}
 
    template <typename expression_t>
    requires xtd::expressions::expression_operand<expression_t> &&
    requires (expression_t e, arguments_t... args) { { e(args...) } -> std::convertible_to<result_t>;}
    delegate(expression_t&& expression) {data_->functions.push_back(function_t(std::forward<expression_t>(expression)));}
    
    
    [[nodiscard]] auto count() const noexcept -> xtd::usize {return data_->functions.size() + data_->no_arguments_functions.size();}
    
    [[nodiscard]] auto no_arguments_functions() const -> const no_arguments_function_collection& {return data_->no_arguments_functions;}
    
    [[nodiscard]] auto functions() const -> const function_collection& {return data_->functions;}
    
    [[nodiscard]] auto is_empty() const noexcept -> bool {return count() == 0;}
    
    [[nodiscard]] auto size() const noexcept -> xtd::usize {return count();}
    
    
    [[nodiscard]] auto begin_invoke(arguments_t&&... arguments) -> async_result;
    [[nodiscard]] auto begin_invoke(xtd::async_callback async_callback, arguments_t&&... arguments) -> async_result;
    [[nodiscard]] auto begin_invoke(xtd::async_callback async_callback, const xtd::any_object& async_state, arguments_t&&... arguments) -> async_result;
    
    auto end_invoke(async_result async) -> result_t;
    
    auto invoke(arguments_t&&... arguments) const -> result_t {return operator()(arguments...);}
    
    [[nodiscard]] auto equals(const object& obj) const noexcept -> bool override {return is<delegate>(obj) && equals(static_cast<const delegate&>(obj));}
    [[nodiscard]] auto equals(const delegate& other) const noexcept -> bool override {
      if (data_->functions.size() != other.data_->functions.size() || data_->no_arguments_functions.size() != other.data_->no_arguments_functions.size()) return false;
      for (auto i = xtd::usize {0}; i < data_->no_arguments_functions.size(); i++)
        if (!are_equals(data_->no_arguments_functions[i], other.data_->no_arguments_functions[i])) return false;
      for (auto i = xtd::usize {0}; i < data_->functions.size(); i++)
        if (!are_equals(data_->functions[i], other.data_->functions[i])) return false;
      return true;
    }

    
    
    [[nodiscard]] static auto combine(const xtd::array<delegate>& delegates) noexcept -> delegate {
      auto result = delegate {};
      for (const auto& delegate : delegates) {
        for (const auto& function : delegate.data_->no_arguments_functions)
          result.data_->no_arguments_functions.push_back(function);
        for (const auto& function : delegate.data_->functions)
          result.data_->functions.push_back(function);
      }
      return result;
    }
    
    [[nodiscard]] static auto combine(const delegate& a, const delegate& b) noexcept -> delegate {
      auto result = a;
      for (const auto& function : b.data_->no_arguments_functions)
        result.data_->no_arguments_functions.push_back(function);
      for (const auto& function : b.data_->functions)
        result.data_->functions.push_back(function);
      return result;
    }
    
    [[nodiscard]] static auto combine(delegate&& a, delegate&& b) noexcept -> delegate {
      auto result = std::move(a);
      for (auto&& function : b.data_->no_arguments_functions)
        result.data_->no_arguments_functions.push_back(std::move(function));
      for (auto&& function : b.data_->functions)
        result.data_->functions.push_back(std::move(function));
      return result;
    }
    
    [[nodiscard]] static auto combine(const delegate& a, delegate&& b) noexcept -> delegate {
      auto result = a;
      for (auto&& function : b.data_->no_arguments_functions)
        result.data_->no_arguments_functions.push_back(std::move(function));
      for (auto&& function : b.data_->functions)
        result.data_->functions.push_back(std::move(function));
      return result;
    }

    [[nodiscard]] static auto remove(const delegate& source, const delegate& value) noexcept -> delegate {
      auto result = source;
      std::for_each(value.data_->no_arguments_functions.begin(), value.data_->no_arguments_functions.end(), [&](const auto& no_arguments_function) {
        auto iterator = std::find_if(result.data_->no_arguments_functions.rbegin(), result.data_->no_arguments_functions.rend(), [&](const auto& item) {return are_equals(item, no_arguments_function);});
        if (iterator != result.data_->no_arguments_functions.rend()) result.data_->no_arguments_functions.erase((iterator + 1).base());
      });
      
      std::for_each(value.data_->functions.begin(), value.data_->functions.end(), [&](const auto& function) {
        auto iterator = std::find_if(result.data_->functions.rbegin(), result.data_->functions.rend(), [&](const auto& item) {return are_equals(item, function);});
        if (iterator != result.data_->functions.rend()) result.data_->functions.erase((iterator + 1).base());
      });
      return result;
    }
    
    [[nodiscard]] static auto remove_all(const delegate& source, const delegate& value) noexcept -> delegate {
      auto result = source;
      for (auto function : value.data_->no_arguments_functions) {
        if (find(result.data_->no_arguments_functions.begin(), result.data_->no_arguments_functions.end(), function) != result.data_->no_arguments_functions.end()) {
          for (typename function_collection::reverse_iterator iterator = result.data_->no_arguments_functions.rbegin(); iterator != result.data_->no_arguments_functions.rend(); ++iterator) {
            if (are_equals(*iterator, function))
              result.data_->no_arguments_functions.erase((iterator + 1).base());
          }
        }
      }
      
      for (auto function : value.data_->functions) {
        if (find(result.data_->functions.begin(), result.data_->functions.end(), function) != result.data_->functions.end()) {
          for (auto iterator = result.data_->functions.rbegin(); iterator != result.data_->functions.rend(); ++iterator) {
            if (are_equals(*iterator, function))
              result.data_->functions.erase((iterator + 1).base());
          }
        }
      }
      return result;
    }

    
    
    auto operator()(arguments_t... arguments) const -> result_t {
      if (data_->no_arguments_functions.size() == 0 && data_->functions.size() == 0) {
        if constexpr(std::is_void_v<result_t>) return;
        else if constexpr(std::is_reference_v<result_t>) {
          using underlying_t = std::remove_reference_t<result_t>;
          if constexpr(std::is_const_v<underlying_t>) {
            static const underlying_t empty_value{};
            return empty_value;
          } else {
            static underlying_t empty_value{};
            return empty_value;
          }
        } else return result_t{};
      }
      
      if (data_->no_arguments_functions.size()) {
        for (auto i = xtd::usize {0}; i < data_->no_arguments_functions.size() - (data_->functions.size() == 0 ? 1 : 0); i++) {
          if (data_->no_arguments_functions[i] == nullptr) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_null);
          data_->no_arguments_functions[i]();
        }
        
        if (data_->functions.size() == 0) {
          if (data_->no_arguments_functions.back() == nullptr) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_null);
          return data_->no_arguments_functions.back()();
        }
      }
      
      for (auto i = xtd::usize {0}; i < data_->functions.size() - 1; i++) {
        if (data_->functions[i] == nullptr) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_null);
        data_->functions[i](arguments...);
      }
      if (data_->functions.back() == nullptr) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_null);
      return data_->functions.back()(arguments...);
    }

    
    template <typename fct_t>
    requires (!xtd::expressions::expression_operand<fct_t>) &&
    (!std::same_as<std::decay_t<fct_t>, delegate>) &&
    (!std::same_as<std::decay_t<fct_t>, function_t>) &&
    std::invocable<fct_t&, arguments_t...>
    auto operator =(fct_t&& function) noexcept -> delegate& {
      data_->no_arguments_functions.clear();
      data_->functions.clear();
      data_->functions.push_back(function_t(function));
      return *this;
    }
    
    template <typename fct_t>
    requires (!xtd::expressions::expression_operand<fct_t>) &&
    (!std::same_as<std::decay_t<fct_t>, delegate>) &&
    (!std::same_as<std::decay_t<fct_t>, function_t>) &&
    std::invocable<fct_t&>
    auto operator =(fct_t&& function) noexcept -> delegate& {
      data_->no_arguments_functions.clear();
      data_->functions.clear();
      data_->no_arguments_functions.push_back(no_arguments_function_t(function));
      return *this;
    }
    
    template <typename expression_t>
    requires xtd::expressions::expression_operand<expression_t> &&
    requires (expression_t e, arguments_t... args) { { e(args...) } -> std::convertible_to<result_t>;}
    auto operator =(expression_t&& expression) noexcept -> delegate& {
      data_->no_arguments_functions.clear();
      data_->functions.clear();
      data_->functions.push_back(function_t(expression));
      return *this;
    }
    
    auto operator =(const function_t& function) noexcept -> delegate& {
      data_->no_arguments_functions.clear();
      data_->functions.clear();
      data_->functions.push_back(function);
      return *this;
    }
    
    [[nodiscard]] auto operator +(const delegate& other) const noexcept -> delegate {
      delegate result = *this;
      result += other;
      return result;
    }
    
    [[nodiscard]] auto operator +(const function_t& function) const noexcept -> delegate {
      delegate result = *this;
      result += function;
      return result;
    }
    
    template <typename fct_t>
    requires (!xtd::expressions::expression_operand<fct_t>) &&
    (!std::same_as<std::decay_t<fct_t>, delegate>) &&
    (!std::same_as<std::decay_t<fct_t>, function_t>) &&
    std::invocable<fct_t&, arguments_t...>
    [[nodiscard]] auto operator +(fct_t&& function) noexcept -> delegate {
      delegate result = *this;
      result += function;
      return result;
    }
    
    template <typename fct_t>
    requires (!xtd::expressions::expression_operand<fct_t>) &&
    (!std::same_as<std::decay_t<fct_t>, delegate>) &&
    (!std::same_as<std::decay_t<fct_t>, function_t>) &&
    std::invocable<fct_t&>
    [[nodiscard]] auto operator +(fct_t&& function) noexcept -> delegate {
      delegate result = *this;
      result += function;
      return result;
    }
    
    template <typename expression_t>
    requires xtd::expressions::expression_operand<expression_t> &&
    requires (expression_t e, arguments_t... args) { { e(args...) } -> std::convertible_to<result_t>;}
    [[nodiscard]] auto operator +(expression_t&& expression) noexcept -> delegate {
      delegate result = *this;
      result += expression;
      return result;
    }
    
    auto operator +=(const delegate& other) noexcept -> delegate& {
      for (const auto& function : other.data_->no_arguments_functions)
        data_->no_arguments_functions.push_back(function);
      for (const auto& function : other.data_->functions)
        data_->functions.push_back(function);
      return *this;
    }
    
    auto operator +=(delegate&& other) noexcept -> delegate& {
      for (auto&& function : other.data_->no_arguments_functions)
        data_->no_arguments_functions.push_back(std::move(function));
      for (auto&& function : other.data_->functions)
        data_->functions.push_back(std::move(function));
      return *this;
    }
 
    auto operator +=(const function_t& function) noexcept -> delegate& {
      data_->functions.push_back(function);
      return *this;
    }
    
    template <typename fct_t>
    requires (!xtd::expressions::expression_operand<fct_t>) &&
    (!std::same_as<std::decay_t<fct_t>, delegate>) &&
    (!std::same_as<std::decay_t<fct_t>, function_t>) &&
    std::invocable<fct_t&, arguments_t...>
    auto operator +=(fct_t&& function) noexcept -> delegate& {
      *this += delegate(function);
      return *this;
    }
    
    template <typename fct_t>
    requires (!xtd::expressions::expression_operand<fct_t>) &&
    (!std::same_as<std::decay_t<fct_t>, delegate>) &&
    (!std::same_as<std::decay_t<fct_t>, function_t>) &&
    std::invocable<fct_t&>
    auto operator +=(fct_t&& function) noexcept -> delegate& {
      *this += delegate(function);
      return *this;
    }
    
    template <typename expression_t>
    requires xtd::expressions::expression_operand<expression_t> &&
    requires (expression_t e, arguments_t... args) { { e(args...) } -> std::convertible_to<result_t>;}
    auto operator +=(expression_t&& expression) noexcept -> delegate& {
      *this += delegate(expression);
      return *this;
    }
    
    [[nodiscard]] auto operator -(const delegate& other) const noexcept -> delegate {
      delegate result = *this;
      result -= other;
      return result;
    }
    
    [[nodiscard]] auto operator -(const function_t& function) const noexcept -> delegate {
      delegate result = *this;
      result -= function;
      return result;
    }
    
    template <typename fct_t>
    requires (!xtd::expressions::expression_operand<fct_t>) &&
    (!std::same_as<std::decay_t<fct_t>, delegate>) &&
    (!std::same_as<std::decay_t<fct_t>, function_t>) &&
    std::invocable<fct_t&, arguments_t...>
    [[nodiscard]] auto operator -(fct_t&& function) noexcept -> delegate {
      delegate result = *this;
      result -= function;
      return result;
    }
    
    template <typename fct_t>
    requires (!xtd::expressions::expression_operand<fct_t>) &&
    (!std::same_as<std::decay_t<fct_t>, delegate>) &&
    (!std::same_as<std::decay_t<fct_t>, function_t>) &&
    std::invocable<fct_t&>
    [[nodiscard]] auto operator -(fct_t&& function) noexcept -> delegate {
      delegate result = *this;
      result -= function;
      return result;
    }
    
    template <typename expression_t>
    requires xtd::expressions::expression_operand<expression_t> &&
    requires (expression_t e, arguments_t... args) { { e(args...) } -> std::convertible_to<result_t>;}
    [[nodiscard]] auto operator -(expression_t&& expression) noexcept -> delegate {
      delegate result = *this;
      result -= expression;
      return result;
    }
    
    auto operator -=(const delegate& other) noexcept -> delegate& {
      std::for_each(other.data_->no_arguments_functions.begin(), other.data_->no_arguments_functions.end(), [&](const auto& no_arguments_function) {
        auto iterator = std::find_if(data_->no_arguments_functions.rbegin(), data_->no_arguments_functions.rend(), [&](const auto& item) {return are_equals(item, no_arguments_function);});
        if (iterator != data_->no_arguments_functions.rend()) data_->no_arguments_functions.erase((iterator + 1).base());
      });
      
      std::for_each(other.data_->functions.begin(), other.data_->functions.end(), [&](const auto& function) {
        auto iterator = std::find_if(data_->functions.rbegin(), data_->functions.rend(), [&](const auto& item) {return are_equals(item, function);});
        if (iterator != data_->functions.rend()) data_->functions.erase((iterator + 1).base());
      });
      return *this;
    }
    
    auto operator -=(const function_t& function) noexcept -> delegate& {
      auto iterator = std::find_if(data_->functions.rbegin(), data_->functions.rend(), [&](const auto& item) {return are_equals(item, function);});
      if (iterator != data_->functions.rend()) data_->functions.erase((iterator + 1).base());
      return *this;
    }
    
    auto operator -=(const no_arguments_function_t& no_arguments_function) noexcept -> delegate& {
      auto iterator = std::find_if(data_->no_arguments_functions.rbegin(), data_->no_arguments_functions.rend(), [&](const auto& item) {return are_equals(item, no_arguments_function);});
      if (iterator != data_->no_arguments_functions.rend()) data_->no_arguments_functions.erase((iterator + 1).base());
      return *this;
    }
    
    template <typename fct_t>
    requires (!xtd::expressions::expression_operand<fct_t>) &&
    (!std::same_as<std::decay_t<fct_t>, delegate>) &&
    (!std::same_as<std::decay_t<fct_t>, function_t>) &&
    std::invocable<fct_t&, arguments_t...>
    auto operator -=(fct_t&& function) noexcept -> delegate& {
      auto iterator = std::find_if(data_->functions.rbegin(), data_->functions.rend(), [&](const auto& item) {return are_equals(item, function);});
      if (iterator != data_->functions.rend()) data_->functions.erase((iterator + 1).base());
      return *this;
    }
    
    template <typename fct_t>
    requires (!xtd::expressions::expression_operand<fct_t>) &&
    (!std::same_as<std::decay_t<fct_t>, delegate>) &&
    (!std::same_as<std::decay_t<fct_t>, function_t>) &&
    std::invocable<fct_t&>
    auto operator -=(fct_t&& function) noexcept -> delegate& {
      auto iterator = std::find_if(data_->functions.rbegin(), data_->functions.rend(), [&](const auto& item) {return are_equals(item, function);});
      if (iterator != data_->functions.rend()) data_->functions.erase((iterator + 1).base());
      return *this;
    }
    
    template <typename expression_t>
    requires xtd::expressions::expression_operand<expression_t> &&
    requires (expression_t e, arguments_t... args) { { e(args...) } -> std::convertible_to<result_t>;}
    auto operator -=(expression_t&& expression) noexcept -> delegate& {
      auto iterator = std::find_if(data_->functions.rbegin(), data_->functions.rend(), [&](const auto& item) {return are_equals(item, function_t {expression});});
      if (iterator != data_->functions.rend()) data_->functions.erase((iterator + 1).base());
      return *this;
    }
    
  private:
    struct delegate_async_state;
    
    [[nodiscard]] static auto are_equals(const std::function<result_t(arguments_t...)>& fct1, const std::function<result_t(arguments_t...)>& fct2) noexcept -> bool {
      return fct1.target_type() == fct2.target_type() && (fct1.template target<result_t(*)(arguments_t...)>() == fct2.template target<result_t(*)(arguments_t...)>() || *fct1.template target<result_t(*)(arguments_t...)>() == *fct2.template target<result_t(*)(arguments_t...)>());
    }
    
    [[nodiscard]] static auto are_equals(const std::function<result_t()>& fct1, const std::function<result_t()>& fct2) noexcept -> bool {
      return fct1.target_type() == fct2.target_type() && (fct1.template target<result_t(*)()>() == fct2.template target<result_t(*)()>() || *fct1.template target<result_t(*)()>() == *fct2.template target<result_t(*)()>());
    }
    
    [[nodiscard]] static auto find(typename no_arguments_function_collection::const_iterator begin, typename no_arguments_function_collection::const_iterator end, const no_arguments_function_t& function) noexcept -> typename no_arguments_function_collection::const_iterator {
      auto iterator = std::find_if(begin, end, [&](const auto& item) {return are_equals(item, function);});
      if (iterator != end) return iterator;
      return end;
    }
    
    [[nodiscard]] static auto find(typename function_collection::const_iterator begin, typename function_collection::const_iterator end, const function_t& function) noexcept -> typename function_collection::const_iterator {
      auto iterator = std::find_if(begin, end, [&](const auto& item) {return are_equals(item, function);});
      if (iterator != end) return iterator;
      return end;
    }
    
    xtd::sptr<data> data_ = xtd::new_sptr<data>();
  };

  // Deduction guides for xtd::delegate
  // {
  template<typename>
  struct function_traits;
  
  template<typename result_t, typename... args_t>
  struct function_traits<result_t(args_t...)> {using signature = result_t(args_t...);};
  
  template<typename result_t, typename... args_t>
  struct function_traits<result_t(*)(args_t...)> : function_traits<result_t(args_t...)> {};
  
  template<typename class_t, typename result_t, typename... args_t>
  struct function_traits<result_t(class_t::*)(args_t...) const> : function_traits<result_t(args_t...)> {};
  
  template<typename type_t>
  struct function_traits : function_traits<decltype(&type_t::operator())> {};
  
  template<typename function_t>
  delegate(function_t) -> delegate<typename function_traits<function_t>::signature>;
  
  template<typename result_t, typename... args_t>
  delegate(std::function<result_t(args_t...)>) -> delegate<result_t(args_t...)>;
  // }
}

#define delegate_ \
  [&]
 
// Required for begin_invoke and end_invoke methods implementation.
#include "threading/thread_pool.hpp"