Require exact type matches between a delegate and what it is calling.

Only return the result of the last target called, with no option for customization.

Must call a method with this already bound.

> VD>>delegate bool Predicate<T>(T t);
> VD>>

boost::function<bool(T)> Predicate;

struct push_max {

  typedef int result_type;

  push_max() : max_value(), got_first(false) {}

  // returns false when we want to stop
  bool operator()(int result) {

    if (!got_first) {
      got_first = true;
      max_value = result;
    } else
    if (result > max_value)
      max_value = result;

    if (result > 100)
      return false;

    return true;
  }

  int get_value() const 
  { 
    if (!got_first)
      throw std::runtime_error("Empty!");
    return max_value; 
  }

private:
  int  max_value; 
  bool got_first;
};

typedef boost::signals<int*(void), push_max> sig_type;

sig_type signal;
signal.connect(...);
signal.connect(...);
signal(); //Call signal!

const push_max result=signal.combiner(); //Get combiner

void fun1(int a)
{
    cout << a << endl;
}

void fun2(short a)
{
    cout << a << endl;
}

int main()
{
    signal<void (int)> fun;
    fun.connect(&fun1);
    fun.connect(&fun2);
    fun(10);
}

GetData getDataMulticast = f1 + (GetData)f2 + f3;

int sum = 0;

foreach (GetData getData in getDataMulticast.GetInvocationList())
    sum += getData();

delegate int GetData();
...
GetData[] getDataArray = new GetData[] { f1, f2, f3 };

int sum = 0;

foreach (GetData getData in getDataArray)
    sum += getData();

C>struct push_max {

C>  typedef int result_type;

C>  push_max() : max_value(), got_first(false) {}

C>  // returns false when we want to stop
C>  bool operator()(int result) {

C>    if (!got_first) {
C>      got_first = true;
C>      max_value = result;
C>    } else
C>    if (result > max_value)
C>      max_value = result;

C>    if (result > 100)
C>      return false;

C>    return true;
C>  }

C>  int get_value() const 
C>  { 
C>    if (!got_first)
C>      throw std::runtime_error("Empty!");
C>    return max_value; 
C>  }

C>private:
C>  int  max_value; 
C>  bool got_first;
C>};

C>typedef boost::signals<int*(void), push_max> sig_type;

C>sig_type signal;
C>signal.connect(...);
C>signal.connect(...);
C>signal(); //Call signal!

C>const push_max result=signal.combiner(); //Get combiner
C>

A>void fun1(int a)
A>{
A>    cout << a << endl;
A>}

A>void fun2(short a)
A>{
A>    cout << a << endl;
A>}

A>int main()
A>{
A>    signal<void (int)> fun;
A>    fun.connect(&fun1);
A>    fun.connect(&fun2);
A>    fun(10);
A>}
A>

delegate void Test(int a);

static void Main(string[] args)
{
    Test fun = fun1 + new Test(delegate(int a) { fun2((short)a); });
    fun(10);
}

static void fun1(int a)
{
    Console.WriteLine("void fun1(int a); a = " + a);
}

static void fun2(short a)
{
    Console.WriteLine("void fun1(int a); a = " + a);
}

class A { }
class B : A { }

class Program
{
    delegate void Test(B b);

    static void Main(string[] args)
    {
        Test fun = fun1 + (Test)fun2;
        fun(new B());
    }

    static void fun1(A a)
    {
        Console.WriteLine("void fun1(A a); a is " + a.GetType().Name);
    }

    static void fun2(B b)
    {
        Console.WriteLine("void fun1(B b); b is " + b.GetType().Name);
    }
}