delegate.hpp

Go to the documentation of this file.

#pragma once
#include "any.hpp"
#include "argument_null_exception.hpp"
#include "async_result.hpp"
#include "iequatable.hpp"
#include "object.hpp"
#include "object_ref.hpp"
#include <functional>
#include <stdexcept>
#include <vector>

namespace xtd {
  template<class result_t>
  class delegate;
  
  template<class result_t, class ...arguments_t>
  class delegate<result_t(arguments_t...)>;
  
  using async_callback = xtd::delegate<void(async_result ar)>;
  
  template<class 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);
      xtd::any_object async_state() const noexcept override;
      xtd::threading::wait_handle & async_wait_handle() noexcept override;
      bool completed_synchronously() const noexcept override;
      bool is_completed() const noexcept 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&) = default;
    delegate& operator =(const delegate& delegate) = default;
    
    delegate(const function_t& function) noexcept {data_->functions.push_back(function);} // Can't be explicit by design.
    
    template < class object1_t, class 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, class 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))));
    }

    
    
    const function_collection& functions() const {return data_->functions;}
    
    bool is_empty() const noexcept {return data_->functions.size() == 0;}
    
    size_t size() const noexcept {return data_->functions.size();}
    
    
    void clear() {data_->functions.clear();}
    
    async_result begin_invoke();
    async_result begin_invoke(xtd::async_callback async_callback);
    async_result begin_invoke(xtd::async_callback async_callback, const xtd::any_object& async_state);
    
    result_t end_invoke(async_result async);
    
    result_t invoke() const {return operator()();}
    
    bool equals(const object& obj) const noexcept override {return is < delegate > (obj) && equals(static_cast < const delegate& > (obj));}
    bool equals(const delegate& other) const noexcept override {
      if (data_->functions.size() != other.data_->functions.size())
        return false;
        
      for (size_t i = 0; i < data_->functions.size(); i++)
        if (!are_equals(data_->functions[i], other.data_->functions[i]))
          return false;
          
      return true;
    }

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

    
    
    result_t operator()() const {
      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 (size_t i = 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()();
    }
    
    delegate& operator =(const function_t& function) noexcept {
      data_->functions.clear();
      data_->functions.push_back(function);
      return *this;
    }
    
    delegate operator +(const delegate& other) noexcept {
      delegate result = *this;
      result += other;
      return result;
    }
    
    delegate operator +(const function_t& function) noexcept {
      delegate result = *this;
      result += function;
      return result;
    }
    
    template < class fn_t >
    delegate operator +(fn_t function) noexcept {
      delegate result = *this;
      result += function;
      return result;
    }
    
    delegate & operator +=(const delegate& delegate) noexcept {
      *this = delegate::combine(*this, delegate);
      return *this;
    }
    
    delegate & operator +=(const function_t& function) noexcept {
      *this = delegate::combine(*this, delegate(function));
      return *this;
    }
    
    template < class fn_t >
    delegate & operator +=(fn_t function) noexcept {
      *this = delegate::combine(*this, delegate(function));
      return *this;
    }
    
    delegate operator -(const delegate& other) noexcept {
      delegate result = *this;
      result -= other;
      return result;
    }
    
    delegate operator -(const function_t& function) noexcept {
      delegate result = *this;
      result -= function;
      return result;
    }
    
    template < class fn_t >
    delegate operator -(fn_t function) noexcept {
      delegate result = *this;
      result -= function;
      return result;
    }
    
    delegate & operator -=(const delegate& delegate) noexcept {
      *this = delegate::remove(*this, delegate);
      return *this;
    }
    
    delegate & operator -=(const function_t& function) noexcept {
      *this = delegate::remove(*this, delegate(function));
      return *this;
    }
    
    template < class fn_t >
    delegate & operator -=(fn_t function) noexcept {
      *this = delegate::remove(*this, delegate(function));
      return *this;
    }
    
  private:
    static bool are_equals(const std::function < result_t() > & fct1, const std::function < result_t() > & fct2) noexcept {
      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(*)() > ());
    }
    
    static typename function_collection::const_iterator find(typename function_collection::const_iterator begin, typename function_collection::const_iterator end, const function_t& function) noexcept {
      auto iterator = std::find_if(begin, end, [&](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, class ...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);
      xtd::any_object async_state() const noexcept override;
      xtd::threading::wait_handle & async_wait_handle() noexcept override;
      bool completed_synchronously() const noexcept override;
      bool is_completed() const noexcept 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&) = default;
    delegate& operator =(const delegate & delegate) = default;
    delegate(const delegate < result_t() > & delegate) noexcept {data_->no_arguments_functions = delegate.functions();}
    
    delegate(const function_t& function) noexcept {data_->functions.push_back(function);} // Can't be explicit by design.
    
    delegate(const no_arguments_function_t& function) noexcept {data_->no_arguments_functions.push_back(function);} // Can't be explicit by design.
    
    template < class object1_t, class 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, class 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, class object2_t, class a1_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t) const) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1)));
    }
    
    template < class object1_t, class object2_t, class a1_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t)) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t) const) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t)) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t) const) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t)) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t, class a4_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t, a4_t) const) {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t, class a4_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t, a4_t)) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t, class a4_t, class A5 >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t, a4_t, A5) const) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t, class a4_t, class A5 >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t, a4_t, A5)) {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t, class a4_t, class A5, class a6_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t, a4_t, A5, a6_t) const) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t, class a4_t, class A5, class a6_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t, a4_t, A5, a6_t)) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t, class a4_t, class A5, class a6_t, class a7_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t, a4_t, A5, a6_t, a7_t) const) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6, std::placeholders::_7)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t, class a4_t, class A5, class a6_t, class a7_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t, a4_t, A5, a6_t, a7_t)) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6, std::placeholders::_7)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t, class a4_t, class A5, class a6_t, class a7_t, class a8_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t, a4_t, A5, a6_t, a7_t, a8_t) const) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6, std::placeholders::_7, std::placeholders::_8)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t, class a4_t, class A5, class a6_t, class a7_t, class a8_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t, a4_t, A5, a6_t, a7_t, a8_t)) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6, std::placeholders::_7, std::placeholders::_8)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t, class a4_t, class A5, class a6_t, class a7_t, class a8_t, class a9_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t, a4_t, A5, a6_t, a7_t, a8_t, a9_t) const) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6, std::placeholders::_7, std::placeholders::_8, std::placeholders::_9)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t, class a4_t, class A5, class a6_t, class a7_t, class a8_t, class a9_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t, a4_t, A5, a6_t, a7_t, a8_t, a9_t)) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6, std::placeholders::_7, std::placeholders::_8, std::placeholders::_9)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t, class a4_t, class A5, class a6_t, class a7_t, class a8_t, class a9_t, class a10_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t, a4_t, A5, a6_t, a7_t, a8_t, a9_t, a10_t) const) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6, std::placeholders::_7, std::placeholders::_8, std::placeholders::_9, std::placeholders::_10)));
    }
    
    template < class object1_t, class object2_t, class a1_t, class a2_t, class a3_t, class a4_t, class A5, class a6_t, class a7_t, class a8_t, class a9_t, class a10_t >
    delegate(const object1_t& object, result_t(object2_t::*method)(a1_t, a2_t, a3_t, a4_t, A5, a6_t, a7_t, a8_t, a9_t, a10_t)) noexcept {
      data_->functions.push_back(function_t(std::bind(method, const_cast < object1_t* > (&object), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5, std::placeholders::_6, std::placeholders::_7, std::placeholders::_8, std::placeholders::_9, std::placeholders::_10)));
    }
    
    
    const no_arguments_function_collection & no_arguments_functions() const {return data_->no_arguments_functions;}
    
    const function_collection & functions() const {return data_->functions;}
    
    bool is_empty() const noexcept {return data_->functions.size() == 0 && data_->no_arguments_functions.size() == 0;}
    
    size_t size() const noexcept {return data_->functions.size() + data_->no_arguments_functions.size();}
    
    
    async_result begin_invoke(arguments_t&&... arguments);
    async_result begin_invoke(xtd::async_callback async_callback, arguments_t&&... arguments);
    async_result begin_invoke(xtd::async_callback async_callback, const xtd::any_object & async_state, arguments_t&&... arguments);
    
    result_t end_invoke(async_result async);
    
    result_t invoke(arguments_t&&... arguments) const {return operator()(arguments...);}
    
    bool equals(const object & obj) const noexcept override {return is < delegate > (obj) && equals(static_cast < const delegate& > (obj));}
    bool equals(const delegate & other) const noexcept override {
      if (data_->functions.size() != other.data_->functions.size() || data_->no_arguments_functions.size() != other.data_->no_arguments_functions.size())
        return false;
        
      for (size_t i = 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 (size_t i = 0; i < data_->functions.size(); i++)
        if (!are_equals(data_->functions[i], other.data_->functions[i]))
          return false;
          
      return true;
    }

    
    
    static delegate combine(const array < delegate > & delegates) noexcept {
      delegate result;
      for (const delegate& delegate : delegates) {
        for (const no_arguments_function_t& function : delegate.data_->no_arguments_functions)
          result.data_->no_arguments_functions.push_back(function);
        for (const function_t& function : delegate.data_->functions)
          result.data_->functions.push_back(function);
      }
      return result;
    }
    
    static delegate combine(const delegate & a, const delegate & b) noexcept {
      delegate result = a;
      for (const no_arguments_function_t& function : b.data_->no_arguments_functions)
        result.data_->no_arguments_functions.push_back(function);
      for (const function_t& function : b.data_->functions)
        result.data_->functions.push_back(function);
      return result;
    }
    
    static delegate remove(const delegate & source, const delegate & value) noexcept {
      delegate result = source;
      std::for_each(value.data_->no_arguments_functions.begin(), value.data_->no_arguments_functions.end(), [&](auto no_arguments_function) {
        auto iterator = std::find_if(result.data_->no_arguments_functions.rbegin(), result.data_->no_arguments_functions.rend(), [&](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(), [&](auto function) {
        auto iterator = std::find_if(result.data_->functions.rbegin(), result.data_->functions.rend(), [&](auto item) {return are_equals(item, function);});
        if (iterator != result.data_->functions.rend()) result.data_->functions.erase((iterator + 1).base());
      });
      return result;
    }
    
    static delegate remove_all(const delegate & source, const delegate & value) noexcept {
      delegate result = source;
      for (const no_arguments_function_t& 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 (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;
    }

    
    
    result_t operator()(arguments_t... arguments) const {
      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 (size_t i = 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 (size_t i = 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 < class type_t >
    delegate& operator =(const type_t& function) noexcept {
      data_->no_arguments_functions.clear();
      data_->functions.clear();
      data_->functions.push_back(function_t(function));
      return *this;
    }
    
    delegate& operator =(const function_t& function) noexcept {
      data_->no_arguments_functions.clear();
      data_->functions.clear();
      data_->functions.push_back(function);
      return *this;
    }
    
    delegate& operator =(const no_arguments_function_t& function) noexcept {
      data_->no_arguments_functions.clear();
      data_->functions.clear();
      data_->no_arguments_functions.push_back(function);
      return *this;
    }
    
    delegate operator +(const delegate & other) noexcept {
      delegate result = *this;
      result += other;
      return result;
    }
    
    delegate operator +(const no_arguments_function_t& function) noexcept {
      delegate result = *this;
      result += function;
      return result;
    }
    
    delegate operator +(const function_t& function) noexcept {
      delegate result = *this;
      result += function;
      return result;
    }
    
    template < class fn_t >
    delegate operator +(fn_t function) noexcept {
      delegate result = *this;
      result += function;
      return result;
    }
    
    delegate & operator +=(const delegate & delegate) noexcept {
      *this = delegate::combine(*this, delegate);
      return *this;
    }
    
    delegate & operator +=(const no_arguments_function_t& function) noexcept {
      *this = delegate::combine(*this, delegate(function));
      return *this;
    }
    
    delegate & operator +=(const function_t& function) noexcept {
      *this = delegate::combine(*this, delegate(function));
      return *this;
    }
    
    template < class fn_t >
    delegate & operator +=(fn_t function) noexcept {
      *this = delegate::combine(*this, delegate(function));
      return *this;
    }
    
    delegate operator -(const delegate & other) noexcept {
      delegate result = *this;
      result -= other;
      return result;
    }
    
    delegate operator -(const no_arguments_function_t& function) noexcept {
      delegate result = *this;
      result -= function;
      return result;
    }
    
    delegate operator -(const function_t& function) noexcept {
      delegate result = *this;
      result -= function;
      return result;
    }
    
    template < class fn_t >
    delegate operator -(fn_t function) noexcept {
      delegate result = *this;
      result -= function;
      return result;
    }
    
    delegate & operator -=(const delegate & delegate) noexcept {
      *this = delegate::remove(*this, delegate);
      return *this;
    }
    
    delegate & operator -=(const no_arguments_function_t& function) noexcept {
      *this = delegate::remove(*this, delegate(function));
      return *this;
    }
    
    delegate & operator -=(const function_t& function) noexcept {
      *this = delegate::remove(*this, delegate(function));
      return *this;
    }
    
    template < class fn_t >
    delegate & operator -=(fn_t function) noexcept {
      *this = delegate::remove(*this, delegate(function));
      return *this;
    }
    
  private:
    struct delegate_async_state;
    
    static bool are_equals(const std::function < result_t(arguments_t...) > & fct1, const std::function < result_t(arguments_t...) > & fct2) noexcept {
      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...) > ());
    }
    
    static bool are_equals(const std::function < result_t() > & fct1, const std::function < result_t() > & fct2) noexcept {
      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(*)() > ());
    }
    
    static typename no_arguments_function_collection::const_iterator find(typename no_arguments_function_collection::const_iterator begin, typename no_arguments_function_collection::const_iterator end, const no_arguments_function_t& function) noexcept {
      auto iterator = std::find_if(begin, end, [&](auto item) {return are_equals(item, function);});
      if (iterator != end) return iterator;
      return end;
    }
    
    static typename function_collection::const_iterator find(typename function_collection::const_iterator begin, typename function_collection::const_iterator end, const function_t& function) noexcept {
      auto iterator = std::find_if(begin, end, [&](auto item) {return are_equals(item, function);});
      if (iterator != end) return iterator;
      return end;
    }
    
    xtd::sptr < data > data_ = xtd::new_sptr < data > ();
  };
}

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