// ======================================================================
//
// Copyright (c) 2001 The CGAL Consortium
//
// This software and related documentation is part of an INTERNAL release
// of the Computational Geometry Algorithms Library (CGAL). It is not
// intended for general use.
//
// ----------------------------------------------------------------------
//
// release       : 
// release_date  : 
//
// file          : include/CGAL/event.h
// package       : 
// maintainer    : 
// revision      : $Id$
// revision_date : $Date$
// author(s)     : 
// coordinator   : 
//
// ======================================================================

/*
the CGAL events are based on the LEDA event implementation by Oliver Zlotowski 
*/


#ifndef CGAL_EVENT_H
#define CGAL_EVENT_H

#include <CGAL/basic.h>
#include <list>
#include <map>

CGAL_BEGIN_NAMESPACE

// ---------------------------------------------------------------------------
// event_item : BASE_RECEIVER*;
// ---------------------------------------------------------------------------

struct BASE_RECEIVER;
typedef BASE_RECEIVER* event_item;

struct BASE_EVENT
{ virtual ~BASE_EVENT() {}
  virtual void detach(event_item) = 0;
};

struct BASE_RECEIVER
{ BASE_EVENT* e;
  
  void* data;
  bool  enabled;

  BASE_RECEIVER(BASE_EVENT* x) : e(x), data(0), enabled(true) {}
  virtual ~BASE_RECEIVER() {}
  
  void enable()  { enabled = true; }
  void disable() { enabled = false; }
  bool is_enabled() const { return enabled; }
};


template <class PT>
struct base_receiver : public BASE_RECEIVER
{ base_receiver(BASE_EVENT* e) : BASE_RECEIVER(e) {}
  virtual void notify(const PT&) const = 0;
  virtual ~base_receiver() {}
};

// ---------------------------------------------------------------------------
// parameter structs
// ---------------------------------------------------------------------------

struct param0
{ enum { number = 0 }; 
  explicit param0() {}
};

template <class T> 
struct param1
{ enum { number = 1 }; 
  T val1;    
  explicit param1(T x1) : val1(x1) {}
};

template <class T1, class T2> 
struct param2 : public param1<T1>
{ enum { number = 2 };
  T2 val2;
  explicit param2(T1 x1, T2 x2) : param1<T1>(x1), val2(x2) {}
};

template <class T1, class T2, class T3> 
struct param3 : public param2<T1,T2>
{ enum { number = 3 };
  T3 val3;
  explicit param3(T1 x1, T2 x2, T3 x3) : param2<T1,T2>(x1,x2), val3(x3) {}
};

template <class T1, class T2, class T3, class T4> 
struct param4 : public param3<T1,T2,T3>
{ enum { number = 4 };
  T4 val4;
  explicit param4(T1 x1, T2 x2, T3 x3, T4 x4) 
    : param3<T1,T2,T3>(x1,x2,x3), val4(x4) {}
};

template <class T1, class T2, class T3, class T4, class T5> 
struct param5 : public param4<T1,T2,T3,T4>
{ enum { number = 5 };
  T5 val5;
  explicit param5(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5) 
    : param4<T1,T2,T3,T4>(x1,x2,x3,x4), val5(x5) {}
};

template <class T1, class T2, class T3, class T4, class T5, class T6> 
struct param6 : public param5<T1,T2,T3,T4,T5>
{ enum { number = 6 };
  T6 val6;
  explicit param6(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6) 
    : param5<T1,T2,T3,T4,T5>(x1,x2,x3,x4,x5), val6(x6) {}
};

template <class T1, class T2, class T3, class T4, class T5, class T6, class T7> 
struct param7 : public param6<T1,T2,T3,T4,T5,T6>
{ enum { number = 7 };
  T7 val7;
  explicit param7(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7) 
    : param6<T1,T2,T3,T4,T5,T6>(x1,x2,x3,x4,x5,x6), val7(x7) {}
};

template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8> 
struct param8 : public param7<T1,T2,T3,T4,T5,T6,T7>
{ enum { number = 8 };
  T8 val8;
  explicit param8(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8) 
    : param7<T1,T2,T3,T4,T5,T6,T7>(x1,x2,x3,x4,x5,x6,x7), val8(x8) {}
};

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7, class T8, class T9> 
struct param9 : public param8<T1,T2,T3,T4,T5,T6,T7,T8>
{ enum { number = 9 };
  T9 val9;
  explicit param9(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8, T9 x9) 
    : param8<T1,T2,T3,T4,T5,T6,T7,T8>(x1,x2,x3,x4,x5,x6,x7,x8), val9(x9) {}
};

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7, class T8, class T9, class T10> 
struct param10 : public param9<T1,T2,T3,T4,T5,T6,T7,T8,T9>
{ enum { number = 10 };
  T10 val10;
  explicit param10(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8, T9 x9, T10 x10) 
    : param9<T1,T2,T3,T4,T5,T6,T7,T8,T9>(x1,x2,x3,x4,x5,x6,x7,x8,x9), val10(x10) {}
};

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7, class T8, class T9, class T10, class T11> 
struct param11 : public param10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
{ enum { number = 11 };
  T11 val11;
  explicit param11(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8, T9 x9, T10 x10, T11 x11) 
    : param10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>(x1,x2,x3,x4,x5,x6,x7,x8,x9,x10), val11(x11) {}
};

template <class T1, class T2, class T3, class T4, class T5, class T6,
          class T7, class T8, class T9, class T10, class T11, class T12> 
struct param12 : public param11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>
{ enum { number = 12 };
  T12 val12;
  explicit param12(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8, T9 x9, T10 x10, T11 x11, T12 x12) 
    : param11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>(x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11), val12(x12) {}
};

// ---------------------------------------------------------------------------
// caller classes
// ---------------------------------------------------------------------------

template <unsigned>
struct caller
{ template <class P, class R, class F>
  caller(const P& p, R r, F f);

  template <class P, class F>
  caller(const P& p, F f);
};  

template <>
struct caller<0>
{ template <class P, class R, class F>
  caller(const P& p, R r, F f) { (r->*f)(); }

  template <class P, class F>
  caller(const P& p, F f) { f(); } 
};

template <>  
struct caller<1> 
{ template <class P, class R, class F>
  caller(const P& p, R r, F f) { (r->*f)(p.val1); } 

  template <class P, class F>
  caller(const P& p, F f) { f(p.val1); } 
};

template <>
struct caller<2> 
{ template <class P, class R, class F>
  caller(const P& p, R r, F f) { (r->*f)(p.val1,p.val2); } 
  
  template <class P, class F>
  caller(const P& p, F f) { f(p.val1,p.val2); } 
};

template <>
struct caller<3> 
{ template <class P, class R, class F>
  caller(const P& p, R r, F f) { (r->*f)(p.val1,p.val2,p.val3); } 

  template <class P, class F>
  caller(const P& p, F f) { f(p.val1,p.val2,p.val3); } 
};

template <>
struct caller<4> 
{ template <class P, class R, class F>
  caller(const P& p, R r, F f) 
  { (r->*f)(p.val1,p.val2,p.val3,p.val4); } 

  template <class P, class F>
  caller(const P& p, F f) { f(p.val1,p.val2,p.val3,p.val4); } 
};

template <>
struct caller<5> 
{ template <class P, class R, class F>
  caller(const P& p, R r, F f) 
  { (r->*f)(p.val1,p.val2,p.val3,p.val4,p.val5); } 

  template <class P, class F>
  caller(const P& p, F f) { f(p.val1,p.val2,p.val3,p.val4,p.val5); } 
};

template <>
struct caller<6> 
{ template <class P, class R, class F>
  caller(const P& p, R r, F f) 
  { (r->*f)(p.val1,p.val2,p.val3,p.val4,p.val5,p.val6); } 

  template <class P, class F>
  caller(const P& p, F f) 
  { f(p.val1,p.val2,p.val3,p.val4,p.val5,p.val6); } 
};

template <>
struct caller<7> 
{ template <class P, class R, class F>
  caller(const P& p, R r, F f) 
  { (r->*f)(p.val1,p.val2,p.val3,p.val4,p.val5,p.val6,p.val7); } 

  template <class P, class F>
  caller(const P& p, F f) 
  { f(p.val1,p.val2,p.val3,p.val4,p.val5,p.val6,p.val7); } 
};

template <>
struct caller<8> 
{ template <class P, class R, class F>
  caller(const P& p, R r, F f) 
  { (r->*f)(p.val1,p.val2,p.val3,p.val4,p.val5,p.val6,p.val7,p.val8); } 

  template <class P, class F>
  caller(const P& p, F f) 
  { f(p.val1,p.val2,p.val3,p.val4,p.val5,p.val6,p.val7,p.val8); } 
};

template <>
struct caller<9> 
{ template <class P, class R, class F>
  caller(const P& p, R r, F f) 
  { (r->*f)(p.val1,p.val2,p.val3,p.val4,p.val5,p.val6,p.val7,p.val8,p.val9); } 

  template <class P, class F>
  caller(const P& p, F f) 
  { f(p.val1,p.val2,p.val3,p.val4,p.val5,p.val6,p.val7,p.val8,p.val9); } 
};

template <>
struct caller<10> 
{ template <class P, class R, class F>
  caller(const P& p, R r, F f) 
  { (r->*f)(p.val1,p.val2,p.val3,p.val4,p.val5,p.val6,p.val7,p.val8,p.val9,p.val10); } 

  template <class P, class F>
  caller(const P& p, F f) 
  { f(p.val1,p.val2,p.val3,p.val4,p.val5,p.val6,p.val7,p.val8,p.val9,p.val10); } 
};

template <>
struct caller<11> 
{ template <class P, class R, class F>
  caller(const P& p, R r, F f) 
  { (r->*f)(p.val1,p.val2,p.val3,p.val4,p.val5,p.val6,p.val7,p.val8,p.val9,p.val10,p.val11); } 

  template <class P, class F>
  caller(const P& p, F f) 
  { f(p.val1,p.val2,p.val3,p.val4,p.val5,p.val6,p.val7,p.val8,p.val9,p.val10,p.val11); } 
};

template <>
struct caller<12> 
{ template <class P, class R, class F>
  caller(const P& p, R r, F f) 
  { (r->*f)(p.val1,p.val2,p.val3,p.val4,p.val5,p.val6,p.val7,p.val8,p.val9,p.val10,p.val11,p.val12); } 

  template <class P, class F>
  caller(const P& p, F f) 
  { f(p.val1,p.val2,p.val3,p.val4,p.val5,p.val6,p.val7,p.val8,p.val9,p.val10,p.val11,p.val12); } 
};

// ---------------------------------------------------------------------------
// receiver class
// ---------------------------------------------------------------------------

struct _NoClassReceiver {};

template <class PT, class F, class R = _NoClassReceiver>
struct receiver : public base_receiver<PT>
{
  enum { num = PT::number };
  
  typedef PT param_type;

  typedef base_receiver<PT> base;
  typedef receiver<PT,F,R>  self;
  
  R* r; // receiver object
  F  f; // handler function    

  void (self::*call)(const PT& p);

  void c_call(const PT& p) { caller<num>(p,r,f); }
  void f_call(const PT& p) { caller<num>(p,f); }

  receiver(BASE_EVENT& e, const self& x) : base(&e), r(x.r), f(x.f), call(x.call) {}

  receiver(R& _r, F _f) : base(0), r(&_r), f(_f), call(&self::c_call) {}
  receiver(F _f) : base(0), f(_f), call(&self::f_call) {}  

  void notify(const PT& p) const 
  { if (!is_enabled()) return;
    (const_cast<self*>(this)->*call)(p); 
  } 
};


// ---------------------------------------------------------------------------
// event
// ---------------------------------------------------------------------------

class event;

namespace detail {

class base_singleton;

struct data_struct
{ base_singleton* instance;

  typedef std::list< std::list<event_item> >::iterator ev_list_list_it;
  typedef std::list<event_item>::iterator              ev_list_it;

  ev_list_list_it       global;
  ev_list_it            local;  
  data_struct(base_singleton* x) : instance(x) {}
};
  
class base_singleton
{ protected:
  std::list< std::list<event_item> > L;
  
  typedef std::list< std::list<event_item> >::iterator ev_list_list_it;
  typedef std::list<event_item>::iterator              ev_list_it;
    
  typedef std::list< std::list<event_item> >::const_iterator ev_list_list_cit;
  typedef std::list<event_item>::const_iterator              ev_list_cit;
      
  public:
      
  template <class RT>
  event_item attach(event& e, event_item& x, const RT& r) 
  { data_struct& T = *(new data_struct(this));
    
    RT* R = new RT(e,r); R->data = &T;    
    if (x != 0)
    { data_struct& S = *(data_struct*) x->data;    
      T.global = S.global;        
    } 
    else
    { L.push_back(std::list<event_item>());   
      ev_list_list_it iter = --L.end();
      T.global = iter;     
      x = R;
    } 
    
    (*(T.global)).push_back(R);
    
    T.local = --(*(T.global)).end();    
    return R;
  }  
  
  template <class PT>     
  void occur(event_item x, const PT& p) const
  { data_struct& D = *(data_struct*) x->data;    
    event_item it;
    
    ev_list_list_it iter = D.global;
    const std::list<event_item>& act_list = *iter;
    
    // iteration on act_list
    ev_list_cit act_it = act_list.begin();
    
    for(;act_it != act_list.end();act_it++){
     it = *act_it;
     ((base_receiver<PT>*)it)->notify(p);  
    }
  }

  virtual event_item detach(event_item x) = 0;
  virtual void clear(event_item x) = 0;
  virtual ~base_singleton() {}
};


template <class T>
class singleton : public base_singleton
{ static void* instance;
  singleton() {}  
  
  typedef std::list< std::list<event_item> >::iterator ev_list_list_it;
  typedef std::list<event_item>::iterator              ev_list_it;    
  
  public:

  event_item detach(event_item x) 
  { data_struct& D = *(data_struct*) x->data;    
    ev_list_list_it item = D.global;    
    
    delete *(D.local);
    (*item).erase(D.local); 
    delete &D;    
    
    if (! (*item).empty()) return (*item).front();
    
    L.erase(item);    
      
    if (L.empty()) 
    { instance = 0;
      delete this;
    }      
    return 0;      
  }  

  void clear(event_item x)
  { data_struct& D = *(data_struct*) x->data;    
    ev_list_list_it item = D.global;    
    
    while (! (*item).empty())
    { event_item x = (*item).front();
      (*item).pop_front(); 
      delete (data_struct*) x->data;
      delete x;
    }
    
    L.erase(item);
    
    if (L.empty()) 
    { instance = 0;
      delete this;
    }      
  }

  static singleton<T>& get()
  { if (instance == 0) instance = new singleton<T>;
    return *(singleton<T>*) instance;
  }
};

template <class T> void* singleton<T>::instance = 0;

}

// ---------------------------------------------------------------------------
// event
// ---------------------------------------------------------------------------

/*{\Manpage {event} {} {Events}}*/

/*{\Mdefinition
Events are designed to support all kinds of Observer Pattern. An event |E|
is able to store arbitrary receivers. Each receiver contains a reference to 
a global function or to a member function of an arbitrary data type. 
Functions can be added/removed by calling the non-member functions |attach|/|detach|. 
If an event occurs, all attached functions with a suitable parameter list
are called. 
}*/

class event : public BASE_EVENT
{ std::map<detail::base_singleton*,event_item> M;
  bool enabled;
  
  typedef std::map<detail::base_singleton*,event_item>::const_iterator  const_iterator;
  
  event(const event& e);
  event& operator=(const event& e);
 
  public:

/*{\Mcreation E }*/
  event() : enabled(true) {}
/*{\Mcreate creates an instance |\Mvar| of type |\Mname| and initializes it
            to the empty receiver list. }*/
   
 ~event() 
  { event_item x;
  
    std::map<detail::base_singleton*,event_item>::iterator it = M.begin();
  
    for(;it != M.end();it++)
    { 
      x = (*it).second;
      if (!x) continue;
      detail::data_struct& d = *(detail::data_struct*) x->data;    
      detail::base_singleton& s = *d.instance;
      s.clear(x);      
    }
  }
  
  template <class RT>
  event_item attach(const RT& r)
  { typedef typename RT::param_type PT;
    detail::singleton<PT>& s = detail::singleton<PT>::get();    
    return s.attach(*this,M[&s],r);
  }

  template <class PT>
  void occur(const PT& x) const 
  { if (!enabled) return;
    detail::singleton<PT>& s = detail::singleton<PT>::get();   
    
    const_iterator cit = M.find(&s);
    
    if (cit != M.end() ) {
      event_item ev_it = (*cit).second;
      if (ev_it != NULL) s.occur(ev_it,x);
    }   
  }
  
  void detach(event_item x)
  { detail::data_struct& d = *(detail::data_struct*) x->data;    
    detail::base_singleton& s = *d.instance;
    M[&s] = s.detach(x);
  }
    
  void enable()  { enabled = true; }   
  void disable() { enabled = false; }    
  bool is_enabled() const { return enabled; } 
};

/*{\Moperations 1.3 2.7 }*/


/*{\Moptions nextwarning=no}*/
/*
void enable();
*/
/*{\Mop enables |E|, i. e., all attached functions will be notified
        when |E| occurs.}*/

/*{\Moptions nextwarning=no}*/
/*
void disable();
*/
/*{\Mop disables |E|, no function will be notified when |E| occurs.}*/

/*{\Moptions nextwarning=no}*/
/*
bool is_enabled();
*/
/*{\Mop returns |true| if |E| is enabled, otherwise |false|.}*/


/*{\Mtext
\bigskip
{\bf Non-Member Functions} 
}*/

/*{\Moptions nextwarning=no}*/
/*
event_item attach(event& E, observer& o, function f);
*/
/*{\Mfunc    appends a new member function |f| of object |o| to the  
             receiver list of |E| and returns an |event_item| for it. 
             If |E| occurs with suitable parameters, |f| is called 
             for object |o|. }*/ 

/*{\Moptions nextwarning=no}*/
/*
event_item attach(event& E, function f);
*/
/*{\Mfunc    appends a new function |f| to the list of receivers 
             of |E| and returns an |event_item| for it. }*/ 

/*{\Moptions nextwarning=no}*/
/*
template<class T>
void occur(event& E, T p);
*/
/*{\Mfunc  calls all attached functions with |p| as parameter
           of the associated event |E|. There are also |occur| functions 
           for more than one parameter.
}*/ 

/*{\Moptions nextwarning=no}*/
/*
void detach(event_item x)
*/
/*{\Mfunc   removes |x| from the list of receivers of the associated event.}*/

/*{\Moptions nextwarning=no}*/
/*
void enable(event_item x)
*/
/*{\Mfunc   enables |x| in the list of receivers of the associated event.}*/

/*{\Moptions nextwarning=no}*/
/*
void disable(event_item x)
*/
/*{\Mfunc   disables |x| in the list of receivers of the associated event.}*/

/*{\Moptions nextwarning=no}*/
/*
bool is_enabled(event_item x)
*/
/*{\Mfunc   returns |true| if |x| is an enabled receiver in the list of 
            the associated event, otherwise |false|.}*/


/*{\Moptions nextwarning=no}*/
/*
void detach(event_item x, int c) 
*/
/*{\Mfunc  removes |c| receivers handled by vector |x| from the list 
           of receivers of the associated event.}*/

/*{\Moptions nextwarning=no}*/
/*
void enable(event_item x, int c) 
*/
/*{\Mfunc  enables |c| receivers handled by vector |x| of the 
           associated event.}*/

/*{\Moptions nextwarning=no}*/
/*
void disable(event_item x, int c) 
*/
/*{\Mfunc  disables |c| receivers handled by vector |x| of the 
           associated event.}*/

/*{\Mexample  
  \begin{verbatim}
  #include <CGAL/event.h>
  #include <iostream>

  using namespace CGAL;
  using std::cout;

  void by_reference(int& val)
  { cout << "Call by reference:  " << val <<  " Change value! \n";
    val = 3;
  }

  void by_value(int val)
  { cout << "Call by value:      " << val << "\n"; }

  int main()
  {
    event e;  
    attach(e,by_value);
    attach(e,by_reference); 
    int i = 10;  
    occur(e,i);
    occur<int&>(e,i);  
    occur(e,i); 
    return 0;
  }
  \end{verbatim}
}*/

// ---------------------------------------------------------------------------
// non-member functions
// ---------------------------------------------------------------------------

inline void detach(event_item x)
{ BASE_EVENT* e = x->e;
  if (e) e->detach(x);
}

inline void enable(event_item x)     { x->enable(); }

inline void disable(event_item x)    { x->disable(); }

inline bool is_enabled(event_item x) { return x->is_enabled(); }

inline void detach(event_item* x, int c) 
{ while (c > 0) 
  { BASE_EVENT* e = (x[--c]->e);
    if (e) e->detach(x[c]);
  }
}

inline void enable(event_item* x, int c) 
{ while (c > 0) x[--c]->enable(); }

inline void disable(event_item* x, int c) 
{ while (c > 0) x[--c]->disable(); }

//-----------------------------------------------------------------------------
// handler without arguments
//-----------------------------------------------------------------------------

template <class R, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)()) 
{ typedef void (R::*F)(); 
  return e.attach(receiver<param0,F,R>(r,f)); 
}

template <class R, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)() const) 
{ typedef void (R::*F)() const; 
  return e.attach(receiver<param0,F,R>(r,f)); 
}

template <class ET>
inline event_item attach(ET& e, void (*f)()) 
{ typedef void (*F)();
  return e.attach(receiver<param0,F>(f));
}

inline void occur(event& e) { e.occur(param0()); }

//-----------------------------------------------------------------------------
// handler with one argument
//-----------------------------------------------------------------------------

template <class R, class T, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T)) 
{ typedef void (R::*F)(T);
  return e.attach(receiver<param1<T>,F,R>(r,f)); 
}

template <class R, class T, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T) const) 
{ typedef void (R::*F)(T) const;
  return e.attach(receiver<param1<T>,F,R>(r,f)); 
}

template <class T, class ET>
inline event_item attach(ET& e, void (*f)(T)) 
{ typedef void (*F)(T);
  return e.attach(receiver<param1<T>,F>(f)); 
}

template <class T>
inline void occur(event& e, T x) { e.occur(param1<T>(x)); }

//-----------------------------------------------------------------------------
// handler with two arguments
//-----------------------------------------------------------------------------

template <class R, class T1, class T2, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2)) 
{ typedef void (R::*F)(T1,T2);
  return e.attach(receiver<param2<T1,T2>,F,R>(r,f)); 
}

template <class R, class T1, class T2, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2) const) 
{ typedef void (R::*F)(T1,T2) const;
  return e.attach(receiver<param2<T1,T2>,F,R>(r,f)); 
}

template <class T1, class T2, class ET>
inline event_item attach(ET& e, void (*f)(T1,T2)) 
{ typedef void (*F)(T1,T2);
  return e.attach(receiver<param2<T1,T2>,F>(f)); 
}

template <class T1, class T2>
inline void occur(event& e, T1 x1, T2 x2) { e.occur(param2<T1,T2>(x1,x2)); }

//-----------------------------------------------------------------------------
// handler with three arguments
//-----------------------------------------------------------------------------

template <class R, class T1, class T2, class T3, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3)) 
{ typedef void (R::*F)(T1,T2,T3);
  return e.attach(receiver<param3<T1,T2,T3>,F,R>(r,f)); 
}

template <class R, class T1, class T2, class T3, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3) const) 
{ typedef void (R::*F)(T1,T2,T3) const;
  return e.attach(receiver<param3<T1,T2,T3>,F,R>(r,f)); 
}

template <class T1, class T2, class T3, class ET>
inline event_item attach(ET& e, void (*f)(T1,T2,T3)) 
{ typedef void (*F)(T1,T2,T3);
  return e.attach(receiver<param3<T1,T2,T3>,F>(f)); 
}

template <class T1, class T2, class T3>
inline void occur(event& e, T1 x1, T2 x2, T3 x3) 
{ e.occur(param3<T1,T2,T3>(x1,x2,x3)); }

//-----------------------------------------------------------------------------
// handler with four arguments
//-----------------------------------------------------------------------------

template <class R, class T1, class T2, class T3, class T4, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4)) 
{ typedef void (R::*F)(T1,T2,T3,T4);
  return e.attach(receiver<param4<T1,T2,T3,T4>,F,R>(r,f));
}

template <class R, class T1, class T2, class T3, class T4, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4) const) 
{ typedef void (R::*F)(T1,T2,T3,T4) const;
  return e.attach(receiver<param4<T1,T2,T3,T4>,F,R>(r,f));
}

template <class T1, class T2, class T3, class T4, class ET>
inline event_item attach(ET& e, void (*f)(T1,T2,T3,T4)) 
{ typedef void (*F)(T1,T2,T3,T4);
  return e.attach(receiver<param4<T1,T2,T3,T4>,F>(f));
}

template <class T1, class T2, class T3, class T4>
inline void occur(event& e, T1 x1, T2 x2, T3 x3, T4 x4) 
{ e.occur(param4<T1,T2,T3,T4>(x1,x2,x3,x4)); }

//-----------------------------------------------------------------------------
// handler with five arguments
//-----------------------------------------------------------------------------

template <class R, class T1, class T2, class T3, class T4, class  T5, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5)) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5);
  return e.attach(receiver<param5<T1,T2,T3,T4,T5>,F,R>(r,f));
}

template <class R, class T1, class T2, class T3, class T4, class  T5, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5) const) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5) const;
  return e.attach(receiver<param5<T1,T2,T3,T4,T5>,F,R>(r,f));
}

template <class T1, class T2, class T3, class T4, class T5, class ET>
inline event_item attach(ET& e, void (*f)(T1,T2,T3,T4,T5)) 
{ typedef void (*F)(T1,T2,T3,T4,T5);
  return e.attach(receiver<param5<T1,T2,T3,T4,T5>,F>(f));
}

template <class T1, class T2, class T3, class T4, class T5>
inline void occur(event& e, T1 x1, T2 x2, T3 x3, T4 x4, T5 x5) 
{ e.occur(param5<T1,T2,T3,T4,T5>(x1,x2,x3,x4,x5)); }

//-----------------------------------------------------------------------------
// handler with six arguments
//-----------------------------------------------------------------------------

template <class R, class T1, class T2, class T3, 
          class T4, class T5, class T6, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5,T6)) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5,T6);
  return e.attach(receiver<param6<T1,T2,T3,T4,T5,T6>,F,R>(r,f));
}

template <class R, class T1, class T2, class T3, 
          class T4, class T5, class T6, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5,T6) const) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5,T6) const;
  return e.attach(receiver<param6<T1,T2,T3,T4,T5,T6>,F,R>(r,f));
}

template <class T1, class T2, class T3, class T4, class T5, class T6, class ET>
inline event_item attach(ET& e, void (*f)(T1,T2,T3,T4,T5,T6)) 
{ typedef void (*F)(T1,T2,T3,T4,T5,T6);
  return e.attach(receiver<param6<T1,T2,T3,T4,T5,T6>,F>(f));
}

template <class T1, class T2, class T3, class T4, class T5, class T6>
inline void occur(event& e, T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6) 
{ e.occur(param6<T1,T2,T3,T4,T5,T6>(x1,x2,x3,x4,x5,x6)); }


//-----------------------------------------------------------------------------
// handler with seven arguments
//-----------------------------------------------------------------------------

template <class R, class T1, class T2, class T3, 
          class T4, class T5, class T6, class T7, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5,T6,T7)) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5,T6,T7);
  return e.attach(receiver<param7<T1,T2,T3,T4,T5,T6,T7>,F,R>(r,f));
}

template <class R, class T1, class T2, class T3, 
          class T4, class T5, class T6, class T7, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5,T6,T7) const) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5,T6,T7) const;
  return e.attach(receiver<param7<T1,T2,T3,T4,T5,T6,T7>,F,R>(r,f));
}

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7, class ET>
inline event_item attach(ET& e, void (*f)(T1,T2,T3,T4,T5,T6,T7)) 
{ typedef void (*F)(T1,T2,T3,T4,T5,T6,T7);
  return e.attach(receiver<param7<T1,T2,T3,T4,T5,T6,T7>,F>(f));
}

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7>
inline void occur(event& e, T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7) 
{ e.occur(param7<T1,T2,T3,T4,T5,T6,T7>(x1,x2,x3,x4,x5,x6,x7)); }


//-----------------------------------------------------------------------------
// handler with eight arguments
//-----------------------------------------------------------------------------

template <class R, class T1, class T2, class T3, 
          class T4, class T5, class T6, class T7, class T8, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5,T6,T7,T8)) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5,T6,T7,T8);
  return e.attach(receiver<param8<T1,T2,T3,T4,T5,T6,T7,T8>,F,R>(r,f));
}

template <class R, class T1, class T2, class T3, 
          class T4, class T5, class T6, class T7, class T8, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5,T6,T7,T8) const) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5,T6,T7,T8) const;
  return e.attach(receiver<param8<T1,T2,T3,T4,T5,T6,T7,T8>,F,R>(r,f));
}

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7, class T8, class ET>
inline event_item attach(ET& e, void (*f)(T1,T2,T3,T4,T5,T6,T7,T8)) 
{ typedef void (*F)(T1,T2,T3,T4,T5,T6,T7,T8);
  return e.attach(receiver<param8<T1,T2,T3,T4,T5,T6,T7,T8>,F>(f));
}

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7, class T8>
inline void occur(event& e, T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8) 
{ e.occur(param8<T1,T2,T3,T4,T5,T6,T7,T8>(x1,x2,x3,x4,x5,x6,x7,x8)); }


//-----------------------------------------------------------------------------
// handler with nine arguments
//-----------------------------------------------------------------------------

template <class R, class T1, class T2, class T3, 
          class T4, class T5, class T6, class T7, class T8, class T9, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5,T6,T7,T8,T9)) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5,T6,T7,T8,T9);
  return e.attach(receiver<param9<T1,T2,T3,T4,T5,T6,T7,T8,T9>,F,R>(r,f));
}

template <class R, class T1, class T2, class T3, 
          class T4, class T5, class T6, class T7, class T8, class T9, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5,T6,T7,T8,T9) const) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5,T6,T7,T8,T9) const;
  return e.attach(receiver<param9<T1,T2,T3,T4,T5,T6,T7,T8,T9>,F,R>(r,f));
}

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7, class T8, class T9, class ET>
inline event_item attach(ET& e, void (*f)(T1,T2,T3,T4,T5,T6,T7,T8,T9)) 
{ typedef void (*F)(T1,T2,T3,T4,T5,T6,T7,T8,T9);
  return e.attach(receiver<param9<T1,T2,T3,T4,T5,T6,T7,T8,T9>,F>(f));
}

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7, class T8, class T9>
inline void occur(event& e, T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8, T9 x9) 
{ e.occur(param9<T1,T2,T3,T4,T5,T6,T7,T8,T9>(x1,x2,x3,x4,x5,x6,x7,x8,x9)); }


//-----------------------------------------------------------------------------
// handler with ten arguments
//-----------------------------------------------------------------------------

template <class R, class T1, class T2, class T3, 
          class T4, class T5, class T6, class T7, class T8, class T9, class T10, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10);
  return e.attach(receiver<param10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>,F,R>(r,f));
}

template <class R, class T1, class T2, class T3, 
          class T4, class T5, class T6, class T7, class T8, class T9, class T10, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) const) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) const;
  return e.attach(receiver<param10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>,F,R>(r,f));
}

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7, class T8, class T9, class T10, class ET>
inline event_item attach(ET& e, void (*f)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)) 
{ typedef void (*F)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10);
  return e.attach(receiver<param10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>,F>(f));
}

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7, class T8, class T9, class T10>
inline void occur(event& e, T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8, T9 x9, T10 x10) 
{ e.occur(param10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>(x1,x2,x3,x4,x5,x6,x7,x8,x9,x10)); }


//-----------------------------------------------------------------------------
// handler with eleven arguments
//-----------------------------------------------------------------------------

template <class R, class T1, class T2, class T3, 
          class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11);
  return e.attach(receiver<param11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>,F,R>(r,f));
}

template <class R, class T1, class T2, class T3, 
          class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) const) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) const;
  return e.attach(receiver<param11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>,F,R>(r,f));
}

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7, class T8, class T9, class T10, class T11, class ET>
inline event_item attach(ET& e, void (*f)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)) 
{ typedef void (*F)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11);
  return e.attach(receiver<param11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>,F>(f));
}

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7, class T8, class T9, class T10, class T11>
inline void occur(event& e, T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8, T9 x9, T10 x10, T11 x11) 
{ e.occur(param11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>(x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11)); }


//-----------------------------------------------------------------------------
// handler with twelve arguments
//-----------------------------------------------------------------------------

template <class R, class T1, class T2, class T3, 
          class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12);
  return e.attach(receiver<param12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>,F,R>(r,f));
}

template <class R, class T1, class T2, class T3, 
          class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class ET>
inline event_item attach(ET& e, R& r, void (R::*f)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) const) 
{ typedef void (R::*F)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) const;
  return e.attach(receiver<param12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>,F,R>(r,f));
}

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class ET>
inline event_item attach(ET& e, void (*f)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)) 
{ typedef void (*F)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12);
  return e.attach(receiver<param12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>,F>(f));
}

template <class T1, class T2, class T3, class T4, 
          class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
inline void occur(event& e, T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8, T9 x9, T10 x10, T11 x11, T12 x12) 
{ e.occur(param12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>(x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12)); }


CGAL_END_NAMESPACE

#endif