libns3-dev 3.26+dfsg-1 / usr / include / ns3.26 / ns3 / make-event.h

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2008 INRIA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifndef MAKE_EVENT_H
#define MAKE_EVENT_H

/**
 * \file
 * \ingroup events
 * ns3::MakeEvent function declarations and template implementation.
 */

namespace ns3 {

class EventImpl;

/**
 * \ingroup events
 * \defgroup makeeventmemptr MakeEvent from Member Function Pointer.
 *
 * Create EventImpl instances from class member functions which take
 * varying numbers of arguments.
 */
/**
 * \ingroup makeeventmemptr
 * @{
 */
/**
 * Make an EventImpl from class method members which take
 * varying numbers of arguments.
 *
 * \tparam MEM \deduced The class method function signature.
 * \tparam OBJ \deduced The class type holding the method.
 * \param [in] mem_ptr Class method member function pointer
 * \param [in] obj Class instance.
 * \returns The constructed EventImpl.
 */
template <typename MEM, typename OBJ>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj);

/**
 * \copybrief MakeEvent(MEM,OBJ)
 * \tparam MEM \deduced The class method function signature.
 * \tparam OBJ \deduced The class type holding the method.
 * \tparam T1 \deduced Type of the argument to the underlying function.
 * \param [in] mem_ptr Class method member function pointer
 * \param [in] obj Class instance.
 * \param [in] a1 Argument value to be bound to the underlying function.
 * \returns The constructed EventImpl.
 */
template <typename MEM, typename OBJ,
          typename T1>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1);

/**
 * \copybrief MakeEvent(MEM,OBJ)
 * \tparam MEM \deduced The class method function signature.
 * \tparam OBJ \deduced The class type holding the method.
 * \tparam T1 \deduced Type of the first argument to the underlying function.
 * \tparam T2 \deduced Type of the second argument to the underlying function.
 * \param [in] mem_ptr Class method member function pointer
 * \param [in] obj Class instance.
 * \param [in] a1 First argument value to be bound to the underlying function.
 * \param [in] a2 Second argument value to be bound to the underlying function.
 * \returns The constructed EventImpl.
 */
template <typename MEM, typename OBJ,
          typename T1, typename T2>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2);

/**
 * \copybrief MakeEvent(MEM,OBJ)
 * \tparam MEM \deduced The class method function signature.
 * \tparam OBJ \deduced The class type holding the method.
 * \tparam T1 \deduced Type of the first argument to the underlying function.
 * \tparam T2 \deduced Type of the second argument to the underlying function.
 * \tparam T3 \deduced Type of the third argument to the underlying function.
 * \param [in] mem_ptr Class method member function pointer
 * \param [in] obj Class instance.
 * \param [in] a1 First argument value to be bound to the underlying function.
 * \param [in] a2 Second argument value to be bound to the underlying function.
 * \param [in] a3 Third argument value to be bound to the underlying function.
 * \returns The constructed EventImpl.
 */
template <typename MEM, typename OBJ,
          typename T1, typename T2, typename T3>
EventImpl * MakeEvent (MEM mem_ptr, OBJ obj, T1 a1, T2 a2, T3 a3);

/**
 * \copybrief MakeEvent(MEM,OBJ)
 * \tparam MEM \deduced The class method function signature.
 * \tparam OBJ \deduced The class type holding the method.
 * \tparam T1 \deduced Type of the first argument to the underlying function.
 * \tparam T2 \deduced Type of the second argument to the underlying function.
 * \tparam T3 \deduced Type of the third argument to the underlying function.
 * \tparam T4 \deduced Type of the fourth argument to the underlying function.
 * \param [in] mem_ptr Class method member function pointer
 * \param [in] obj Class instance.
 * \param [in] a1 First argument value to be bound to the underlying function.
 * \param [in] a2 Second argument value to be bound to the underlying function.
 * \param [in] a3 Third argument value to be bound to the underlying function.
 * \param [in] a4 Fourth argument value to be bound to the underlying function.
 * \returns The constructed EventImpl.
 */
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);

/**
 * \copybrief MakeEvent(MEM,OBJ)
 * \tparam MEM \deduced The class method function signature.
 * \tparam OBJ \deduced The class type holding the method.
 * \tparam T1 \deduced Type of the first argument to the underlying function.
 * \tparam T2 \deduced Type of the second argument to the underlying function.
 * \tparam T3 \deduced Type of the third argument to the underlying function.
 * \tparam T4 \deduced Type of the fourth argument to the underlying function.
 * \tparam T5 \deduced Type of the fifth argument to the underlying function.
 * \param [in] mem_ptr Class method member function pointer
 * \param [in] obj Class instance.
 * \param [in] a1 First argument value to be bound to the underlying function.
 * \param [in] a2 Second argument value to be bound to the underlying function.
 * \param [in] a3 Third argument value to be bound to the underlying function.
 * \param [in] a4 Fourth argument value to be bound to the underlying function.
 * \param [in] a5 Fifh argument value to be bound to the underlying function.
 * \returns The constructed EventImpl.
 */
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);
/**@}*/
  
/**
 * \ingroup events
 * \defgroup makeeventfnptr MakeEvent from Function Pointers.
 *
 * Create EventImpl instances from function pointers which take
 * varying numbers of arguments.
 *
 * @{
 */
/**
 * Make an EventImpl from a function pointer taking varying numbers
 * of arguments.
 *
 * \param [in] f The function pointer.
 * \returns The constructed EventImpl.
 */
EventImpl * MakeEvent (void (*f)(void));

/**
 * \copybrief MakeEvent(void(*f)(void))
 * \tparam U1 \deduced Formal type of the argument to the function.
 * \tparam T1 \deduced Actual type of the argument to the function.
 * \param [in] f The function pointer.
 * \param [in] a1 Argument to be bound to the function.
 * \returns The constructed EventImpl.
 */
template <typename U1,
          typename T1>
EventImpl * MakeEvent (void (*f)(U1), T1 a1);

/**
 * \copybrief MakeEvent(void(*f)(void))
 * \tparam U1 \deduced Formal type of the first argument to the function.
 * \tparam U2 \deduced Formal type of the second argument to the function.
 * \tparam T1 \deduced Actual type of the first argument to the function.
 * \tparam T2 \deduced Actual type of the second argument to the function.
 * \param [in] f The function pointer.
 * \param [in] a1 First argument to be bound to the function.
 * \param [in] a2 Second argument to be bound to the function.
 * \returns The constructed EventImpl.
 */
template <typename U1, typename U2,
          typename T1, typename T2>
EventImpl * MakeEvent (void (*f)(U1,U2), T1 a1, T2 a2);

/**
 * \copybrief MakeEvent(void(*f)(void))
 * \tparam U1 \deduced Formal type of the first argument to the function.
 * \tparam U2 \deduced Formal type of the second argument to the function.
 * \tparam U3 \deduced Formal type of the third argument to the function.
 * \tparam T1 \deduced Actual type of the first argument to the function.
 * \tparam T2 \deduced Actual type of the second argument to the function.
 * \tparam T3 \deduced Actual type of the third argument to the function.
 * \param [in] f The function pointer.
 * \param [in] a1 First argument to be bound to the function.
 * \param [in] a2 Second argument to be bound to the function.
 * \param [in] a3 Third argument to be bound to the function.
 * \returns The constructed EventImpl.
 */
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);

/**
 * \copybrief MakeEvent(void(*f)(void))
 * \tparam U1 \deduced Formal type of the first argument to the function.
 * \tparam U2 \deduced Formal type of the second argument to the function.
 * \tparam U3 \deduced Formal type of the third argument to the function.
 * \tparam U4 \deduced Formal type of the fourth argument to the function.
 * \tparam T1 \deduced Actual type of the first argument to the function.
 * \tparam T2 \deduced Actual type of the second argument to the function.
 * \tparam T3 \deduced Actual type of the third argument to the function.
 * \tparam T4 \deduced Actual type of the fourth argument to the function.
 * \param [in] f The function pointer.
 * \param [in] a1 First argument to be bound to the function.
 * \param [in] a2 Second argument to be bound to the function.
 * \param [in] a3 Third argument to be bound to the function.
 * \param [in] a4 Fourth argument to be bound to the function.
 * \returns The constructed EventImpl.
 */
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);

/**
 * \copybrief MakeEvent(void(*f)(void))
 * \tparam U1 \deduced Formal type of the first argument to the function.
 * \tparam U2 \deduced Formal type of the second argument to the function.
 * \tparam U3 \deduced Formal type of the third argument to the function.
 * \tparam U4 \deduced Formal type of the fourth argument to the function.
 * \tparam U5 \deduced Formal type of the fifth argument to the function.
 * \tparam T1 \deduced Actual type of the first argument to the function.
 * \tparam T2 \deduced Actual type of the second argument to the function.
 * \tparam T3 \deduced Actual type of the third argument to the function.
 * \tparam T4 \deduced Actual type of the fourth argument to the function.
 * \tparam T5 \deduced Actual type of the fifth argument to the function.
 * \param [in] f The function pointer.
 * \param [in] a1 First argument to be bound to the function.
 * \param [in] a2 Second argument to be bound to the function.
 * \param [in] a3 Third argument to be bound to the function.
 * \param [in] a4 Fourth argument to be bound to the function.
 * \param [in] a5 Fifth argument to be bound to the function.
 * \returns The constructed EventImpl.
 */
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 the templates declared above.
 ********************************************************************/

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

namespace ns3 {

/**
 * \ingroup makeeventmemptr
 * Helper for the MakeEvent functions which take a class method.
 *
 * This helper converts a pointer to a reference.
 *
 * This is the generic template declaration (with empty body).
 *
 * \tparam T \explicit The class type.
 */
template <typename T>
struct EventMemberImplObjTraits;

/**
 * \ingroup makeeventmemptr
 * Helper for the MakeEvent functions which take a class method.
 *
 * This helper converts a pointer to a reference.
 *
 * This is the specialization for pointer types.
 *
 * \tparam T \explicit The class type.
 */
template <typename T>
struct EventMemberImplObjTraits<T *>
{
  /**
   * \param [in] p Object pointer.
   * \return A reference to the object pointed to by p.
   */
  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 */