delegate.h

Go to the documentation of this file.

#pragma once

#include <functional>
#include <memory>
#include <stdexcept>
#include <vector>
#include "argument_null_exception.h"
#include "object.h"

namespace xtd {
  template<typename result_t>
  class delegate;
  
  template<typename result_t>
  class delegate<result_t()> : public object {
  public:
    
    using function_t = std::function <result_t()>;
    
    
    delegate() = default;
    delegate(const delegate& delegate) noexcept {
      data_->functions = delegate.data_->functions;
    }
    delegate(const function_t& function) noexcept { data_->functions.push_back(function); }
    delegate& operator=(const delegate& delegate) noexcept {
      data_->functions = delegate.data_->functions;
      return *this;
    }
    
    template<typename 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<typename 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))));
    }
    
    
    const std::vector<function_t>& functions() const {return data_->functions;}
    
    void clear() {data_->functions.clear();}
    
    result_t invoke() const { return operator()(); }
    
    static delegate combine(const std::vector<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;
    }
    
    bool is_empty() const noexcept { return data_->functions.size() == 0; }
    
    size_t size() const noexcept { return data_->functions.size(); }
    
    static delegate remove(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 std::vector<function_t>::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());
              break;
            }
          }
        }
      }
      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 std::vector<function_t>::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) return result_t();
      
      for (size_t i = 0; i < data_->functions.size() - 1; i++) {
        if (data_->functions[i] == nullptr) throw xtd::argument_null_exception(current_stack_frame_);
        data_->functions[i]();
      }
      if (data_->functions.back() == nullptr) throw xtd::argument_null_exception(current_stack_frame_);
      return data_->functions.back()();
    }
    
    bool operator ==(const delegate& delegate) const noexcept {
      if (data_->functions.size() != delegate.data_->functions.size())
        return false;
        
      for (size_t i = 0; i < data_->functions.size(); i++)
        if (!are_equals(data_->functions[i], delegate.data_->functions[i]))
          return false;
          
      return true;
    }
    
    bool operator !=(const delegate& delegate) const { return !operator==(delegate); }
    
    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;
    }
    
    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;
    }
    
    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;
    }
    
    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<typename fn_t>
    delegate& operator-=(fn_t function) noexcept {
      *this = delegate::remove(*this, delegate(function));
      return *this;
    }
    // @endcond
    
  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 std::vector<function_t>::const_iterator find(typename std::vector<function_t>::const_iterator begin, typename std::vector<function_t>::const_iterator end, const function_t& function) noexcept {
      for (typename std::vector<function_t>::const_iterator iterator = begin; iterator != end; ++iterator)
        if (are_equals(*iterator, function))
          return iterator;
      return end;
    }
    
    struct data {
      std::vector<function_t> functions;
    };
    std::shared_ptr<data> data_ = std::make_shared<data>();
  };
  
  template<typename result_t, typename... arguments_t>
  class delegate<result_t(arguments_t...)> : public object {
  public:
    
    using no_arguments_function_t = std::function <result_t()>;
    using function_t = std::function <result_t(arguments_t...)>;
    
    
    delegate() = default;
    delegate(const delegate& delegate) noexcept {
      data_->no_arguments_functions = delegate.data_->no_arguments_functions;
      data_->functions = delegate.data_->functions;
    }
    delegate& operator=(const delegate& delegate) noexcept {
      data_->no_arguments_functions = delegate.data_->no_arguments_functions;
      data_->functions = delegate.data_->functions;
      return *this;
    }
    delegate(const delegate<result_t()>& delegate) noexcept {
      data_->no_arguments_functions = delegate.functions();
    }
    
    delegate(const function_t& function) noexcept {data_->functions.push_back(function);}
    
    delegate(const no_arguments_function_t& function) noexcept { data_->no_arguments_functions.push_back(function); }
    
    template<typename 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<typename 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<typename object1_t, typename object2_t, typename 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<typename object1_t, typename object2_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename a3_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename a3_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename a3_t, typename a4_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename a3_t, typename a4_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename a3_t, typename a4_t, typename A5, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename a3_t, typename a4_t, typename A5, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename a3_t, typename a4_t, typename A5, typename a6_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename a3_t, typename a4_t, typename A5, typename a6_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename a3_t, typename a4_t, typename A5, typename a6_t, typename a7_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename a3_t, typename a4_t, typename A5, typename a6_t, typename a7_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename a3_t, typename a4_t, typename A5, typename a6_t, typename a7_t, typename a8_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename a3_t, typename a4_t, typename A5, typename a6_t, typename a7_t, typename a8_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename a3_t, typename a4_t, typename A5, typename a6_t, typename a7_t, typename a8_t, typename a9_t, typename 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<typename object1_t, typename object2_t, typename a1_t, typename a2_t, typename a3_t, typename a4_t, typename A5, typename a6_t, typename a7_t, typename a8_t, typename a9_t, typename 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 std::vector<no_arguments_function_t>& no_arguments_functions() const {return data_->no_arguments_functions;}
    
    const std::vector<function_t>& functions() const {return data_->functions;}
    
    void clear() {
      data_->no_arguments_functions.clear();
      data_->functions.clear();
    }
    
    result_t invoke(arguments_t... arguments) const { return operator()(arguments...); }
    
    static delegate combine(const std::vector<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;
    }
    
    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(); }
    
    static delegate remove(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 std::vector<no_arguments_function_t>::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());
              break;
            }
          }
        }
      }
      
      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 std::vector<function_t>::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());
              break;
            }
          }
        }
      }
      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 std::vector<function_t>::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 std::vector<function_t>::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) 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) throw xtd::argument_null_exception(current_stack_frame_);
          data_->no_arguments_functions[i]();
        }
        
        if (data_->functions.size() == 0) {
          if (data_->no_arguments_functions.back() == nullptr) throw xtd::argument_null_exception(current_stack_frame_);
          return data_->no_arguments_functions.back()();
        }
      }
      
      for (size_t i = 0; i < data_->functions.size() - 1; i++) {
        if (data_->functions[i] == nullptr) throw xtd::argument_null_exception(current_stack_frame_);
        data_->functions[i](arguments...);
      }
      if (data_->functions.back() == nullptr) throw xtd::argument_null_exception(current_stack_frame_);
      return data_->functions.back()(arguments...);
    }
    
    bool operator==(const delegate& delegate) const noexcept {
      if (data_->functions.size() != delegate.data_->functions.size() || data_->no_arguments_functions.size() != delegate.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], delegate.data_->no_arguments_functions[i]))
          return false;
          
      for (size_t i = 0; i < data_->functions.size(); i++)
        if (!are_equals(data_->functions[i], delegate.data_->functions[i]))
          return false;
          
      return true;
    }
    
    bool operator!=(const delegate& delegate) const { return !operator==(delegate); }
    
    template<typename 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<typename 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<typename 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<typename 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<typename 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(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 std::vector<no_arguments_function_t>::const_iterator find(typename std::vector<no_arguments_function_t>::const_iterator begin, typename std::vector<no_arguments_function_t>::const_iterator end, const no_arguments_function_t& function) noexcept {
      for (typename std::vector<no_arguments_function_t>::const_iterator iterator = begin; iterator != end; ++iterator)
        if (are_equals(*iterator, function))
          return iterator;
      return end;
    }
    
    static typename std::vector<function_t>::const_iterator find(typename std::vector<function_t>::const_iterator begin, typename std::vector<function_t>::const_iterator end, const function_t& function) noexcept {
      for (typename std::vector<function_t>::const_iterator iterator = begin; iterator != end; ++iterator)
        if (are_equals(*iterator, function))
          return iterator;
      return end;
    }
    struct data {
      std::vector<no_arguments_function_t> no_arguments_functions;
      std::vector<function_t> functions;
    };
    std::shared_ptr<data> data_ = std::make_shared<data>();
  };
}