#ifndef MAKE_EVENT_H
#define MAKE_EVENT_H

namespace ns3 {

class EventImpl;

template <typename MEM, typename OBJ>
EventImpl *MakeEvent (MEM mem_ptr, OBJ obj);

template <typename MEM, typename OBJ, 
          typename T1>
EventImpl *MakeEvent (MEM mem_ptr, OBJ obj, T1 a1);

template <typename MEM, typename OBJ, 
          typename T1, typename T2>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2);

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3);

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4);

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, 
		       T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);

EventImpl * MakeEvent (void (*f) (void));
template <typename U1, 
          typename T1>
EventImpl * MakeEvent (void (*f) (U1), T1 a1);

template <typename U1, typename U2, 
          typename T1, typename T2>
EventImpl * MakeEvent (void (*f) (U1,U2), T1 a1, T2 a2);

template <typename U1, typename U2, typename U3,
          typename T1, typename T2, typename T3>
EventImpl * MakeEvent (void (*f) (U1,U2,U3), T1 a1, T2 a2, T3 a3);

template <typename U1, typename U2, typename U3, typename U4,
          typename T1, typename T2, typename T3, typename T4>
EventImpl * MakeEvent (void (*f) (U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4);

template <typename U1, typename U2, typename U3, typename U4, typename U5,
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventImpl * MakeEvent (void (*f) (U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);

} // namespace ns3

/********************************************************************
   Implementation of templates defined above
 ********************************************************************/

#include "event-impl.h"
#include "ns3/type-traits.h"

namespace ns3 {

template <typename T>
struct EventMemberImplObjTraits;

template <typename T>
struct EventMemberImplObjTraits<T *>
{
  static T &GetReference (T *p) {
    return *p;
  }
};

template <typename MEM, typename OBJ>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj) 
{
  // zero argument version
  class EventMemberImpl0 : public EventImpl {
  public:
    EventMemberImpl0 (OBJ obj, MEM function) 
      : m_obj (obj), 
        m_function (function)
    {}
    virtual ~EventMemberImpl0 () {}
  private:
    virtual void Notify (void) { 
      (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function) (); 
    }
    OBJ m_obj;
    MEM m_function;
  } * ev = new EventMemberImpl0 (obj, mem_ptr);
  return ev;
}


template <typename MEM, typename OBJ, 
          typename T1>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1)
{
  // one argument version
  class EventMemberImpl1 : public EventImpl {
  public:
    EventMemberImpl1 (OBJ obj, MEM function, T1 a1) 
      : m_obj (obj), 
        m_function (function),
        m_a1 (a1)
    {}
  protected:
    virtual ~EventMemberImpl1 () {}
  private:
    virtual void Notify (void) { 
      (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function) (m_a1);
    }
    OBJ m_obj;
    MEM m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
  } *ev = new EventMemberImpl1 (obj, mem_ptr, a1);
  return ev;
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2) 
{
  // two argument version
  class EventMemberImpl2 : public EventImpl {
  public:
    EventMemberImpl2 (OBJ obj, MEM function, T1 a1, T2 a2) 
      : m_obj (obj), 
        m_function (function),
        m_a1 (a1),
        m_a2 (a2)
    { }
  protected:
    virtual ~EventMemberImpl2 () {}
  private:
    virtual void Notify (void) { 
      (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function) (m_a1, m_a2);
    }
    OBJ m_obj;
    MEM m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
  } *ev = new EventMemberImpl2 (obj, mem_ptr, a1, a2);
  return ev;
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3) 
{
  // three argument version
  class EventMemberImpl3 : public EventImpl {
  public:
    EventMemberImpl3 (OBJ obj, MEM function, T1 a1, T2 a2, T3 a3) 
      : m_obj (obj), 
        m_function (function),
        m_a1 (a1),
        m_a2 (a2),
        m_a3 (a3)
    { }
  protected:
    virtual ~EventMemberImpl3 () {}
  private:
    virtual void Notify (void) { 
      (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function) (m_a1, m_a2, m_a3);
    }
    OBJ m_obj;
    MEM m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
    typename TypeTraits<T3>::ReferencedType m_a3;
  } *ev = new EventMemberImpl3 (obj, mem_ptr, a1, a2, a3);
  return ev;
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3, T4 a4) 
{
  // four argument version
  class EventMemberImpl4 : public EventImpl {
  public:
    EventMemberImpl4 (OBJ obj, MEM function, T1 a1, T2 a2, T3 a3, T4 a4) 
      : m_obj (obj), 
        m_function (function),
        m_a1 (a1),
        m_a2 (a2),
        m_a3 (a3),
        m_a4 (a4)
    { }
  protected:
    virtual ~EventMemberImpl4 () {}
  private:
    virtual void Notify (void) { 
      (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function) (m_a1, m_a2, m_a3, m_a4);
    }
    OBJ m_obj;
    MEM m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
    typename TypeTraits<T3>::ReferencedType m_a3;
    typename TypeTraits<T4>::ReferencedType m_a4;
  } *ev = new EventMemberImpl4 (obj, mem_ptr, a1, a2, a3, a4);
  return ev;
}

template <typename MEM, typename OBJ, 
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, 
                                     T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) 
{
  // five argument version
  class EventMemberImpl5 : public EventImpl {
  public:
    EventMemberImpl5 (OBJ obj, MEM function, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) 
      : m_obj (obj), 
        m_function (function),
        m_a1 (a1),
        m_a2 (a2),
        m_a3 (a3),
        m_a4 (a4),
        m_a5 (a5)
    { }
  protected:
    virtual ~EventMemberImpl5 () {}
  private:
    virtual void Notify (void) { 
      (EventMemberImplObjTraits<OBJ>::GetReference (m_obj).*m_function) (m_a1, m_a2, m_a3, m_a4, m_a5);
    }
    OBJ m_obj;
    MEM m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
    typename TypeTraits<T3>::ReferencedType m_a3;
    typename TypeTraits<T4>::ReferencedType m_a4;
    typename TypeTraits<T5>::ReferencedType m_a5;
  } *ev = new EventMemberImpl5 (obj, mem_ptr, a1, a2, a3, a4, a5);
  return ev;
}

template <typename U1, typename T1>
EventImpl * MakeEvent (void (*f) (U1), T1 a1) 
{
  // one arg version
  class EventFunctionImpl1 : public EventImpl {
  public:
    typedef void (*F)(U1);
      
    EventFunctionImpl1 (F function, T1 a1) 
      : m_function (function),
        m_a1 (a1)
    { }
  protected:
    virtual ~EventFunctionImpl1 () {}
  private:
    virtual void Notify (void) { 
      (*m_function) (m_a1);
    }
    F m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
  } *ev = new EventFunctionImpl1 (f, a1);
  return ev;
}

template <typename U1, typename U2, typename T1, typename T2>
EventImpl * MakeEvent (void (*f) (U1,U2), T1 a1, T2 a2) 
{
  // two arg version
  class EventFunctionImpl2 : public EventImpl {
  public:
    typedef void (*F)(U1, U2);
      
    EventFunctionImpl2 (F function, T1 a1, T2 a2) 
      : m_function (function),
        m_a1 (a1),
        m_a2 (a2)
    {}
  protected:
    virtual ~EventFunctionImpl2 () {}
  private:
    virtual void Notify (void) { 
      (*m_function) (m_a1, m_a2);
    }
    F m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
  } *ev = new EventFunctionImpl2 (f, a1, a2);
  return ev;
}

template <typename U1, typename U2, typename U3,
          typename T1, typename T2, typename T3>
EventImpl * MakeEvent (void (*f) (U1,U2,U3), T1 a1, T2 a2, T3 a3)
{
  // three arg version
  class EventFunctionImpl3 : public EventImpl {
  public:
    typedef void (*F)(U1, U2, U3);
      
    EventFunctionImpl3 (F function, T1 a1, T2 a2, T3 a3) 
      : m_function (function),
        m_a1 (a1),
        m_a2 (a2),
        m_a3 (a3)
    { }
  protected:
    virtual ~EventFunctionImpl3 () {}
  private:
    virtual void Notify (void) { 
      (*m_function) (m_a1, m_a2, m_a3);
    }
    F m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
    typename TypeTraits<T3>::ReferencedType m_a3;
  } *ev = new EventFunctionImpl3 (f, a1, a2, a3);
  return ev;
}

template <typename U1, typename U2, typename U3, typename U4,
          typename T1, typename T2, typename T3, typename T4>
EventImpl * MakeEvent (void (*f) (U1,U2,U3,U4), T1 a1, T2 a2, T3 a3, T4 a4) 
{
  // four arg version
  class EventFunctionImpl4 : public EventImpl {
  public:
    typedef void (*F)(U1, U2, U3, U4);
      
    EventFunctionImpl4 (F function, T1 a1, T2 a2, T3 a3, T4 a4) 
      : m_function (function),
        m_a1 (a1),
        m_a2 (a2),
        m_a3 (a3),
        m_a4 (a4)
    { }
  protected:
    virtual ~EventFunctionImpl4 () {}
  private:
    virtual void Notify (void) { 
      (*m_function) (m_a1, m_a2, m_a3, m_a4);
    }
    F m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
    typename TypeTraits<T3>::ReferencedType m_a3;
    typename TypeTraits<T4>::ReferencedType m_a4;
  } *ev = new EventFunctionImpl4 (f, a1, a2, a3, a4);
  return ev;
}

template <typename U1, typename U2, typename U3, typename U4, typename U5,
          typename T1, typename T2, typename T3, typename T4, typename T5>
EventImpl * MakeEvent (void (*f) (U1,U2,U3,U4,U5), T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) 
{
  // five arg version
  class EventFunctionImpl5 : public EventImpl {
  public:
    typedef void (*F)(U1,U2,U3,U4,U5);
      
    EventFunctionImpl5 (F function, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) 
      : m_function (function),
        m_a1 (a1),
        m_a2 (a2),
        m_a3 (a3),
        m_a4 (a4),
        m_a5 (a5)
    {}
  protected:
    virtual ~EventFunctionImpl5 () {}
  private:
    virtual void Notify (void) { 
      (*m_function) (m_a1, m_a2, m_a3, m_a4, m_a5);
    }
    F m_function;
    typename TypeTraits<T1>::ReferencedType m_a1;
    typename TypeTraits<T2>::ReferencedType m_a2;
    typename TypeTraits<T3>::ReferencedType m_a3;
    typename TypeTraits<T4>::ReferencedType m_a4;
    typename TypeTraits<T5>::ReferencedType m_a5;
  } *ev = new EventFunctionImpl5 (f, a1, a2, a3, a4, a5);
  return ev;
}

} // namespace ns3

#endif /* MAKE_EVENT_H */