Attachment #320 for bug #412

View | Details | Raw Unified | Return to bug 412
Collapse All | Expand All




};

// declare the CallbackImpl class
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
class CallbackImpl;
// define CallbackImpl for 0 params
template <typename R>
class CallbackImpl<R,empty,empty,empty,empty,empty,empty,empty,empty,empty> : public CallbackImplBase {
public:
  virtual ~CallbackImpl () {}
  virtual R operator() (void) = 0;
};
// define CallbackImpl for 1 params
template <typename R, typename T1>
class CallbackImpl<R,T1,empty,empty,empty,empty,empty,empty,empty,empty> : public CallbackImplBase {
public:
  virtual ~CallbackImpl () {}
  virtual R operator() (T1) = 0;
};
// define CallbackImpl for 2 params
template <typename R, typename T1, typename T2>
class CallbackImpl<R,T1,T2,empty,empty,empty,empty,empty,empty,empty> : public CallbackImplBase {
public:
  virtual ~CallbackImpl () {}
  virtual R operator() (T1, T2) = 0;
};
// define CallbackImpl for 3 params
template <typename R, typename T1, typename T2, typename T3>
class CallbackImpl<R,T1,T2,T3,empty,empty,empty,empty,empty,empty> : public CallbackImplBase {
public:
  virtual ~CallbackImpl () {}
  virtual R operator() (T1, T2, T3) = 0;
};
// define CallbackImpl for 4 params
template <typename R, typename T1, typename T2, typename T3, typename T4>
class CallbackImpl<R,T1,T2,T3,T4,empty,empty,empty,empty,empty> : public CallbackImplBase {
public:
  virtual ~CallbackImpl () {}
  virtual R operator() (T1, T2, T3, T4) = 0;
};
// define CallbackImpl for 5 params
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5>
class CallbackImpl<R,T1,T2,T3,T4,T5,empty,empty,empty,empty> : public CallbackImplBase {
public:
  virtual ~CallbackImpl () {}
  virtual R operator() (T1, T2, T3, T4, T5) = 0;
};
// define CallbackImpl for 6 params
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
class CallbackImpl<R,T1,T2,T3,T4,T5,T6,empty,empty,empty> : public CallbackImplBase {
public:
  virtual ~CallbackImpl () {}
  virtual R operator() (T1, T2, T3, T4, T5, T6) = 0;
};
// define CallbackImpl for 7 params
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
class CallbackImpl<R,T1,T2,T3,T4,T5,T6,T7,empty,empty> : public CallbackImplBase {
public:
  virtual ~CallbackImpl () {}
  virtual R operator() (T1, T2, T3, T4, T5, T6, T7) = 0;
};
// define CallbackImpl for 8 params
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
class CallbackImpl<R,T1,T2,T3,T4,T5,T6,T7,T8,empty> : public CallbackImplBase {
public:
  virtual ~CallbackImpl () {}
  virtual R operator() (T1, T2, T3, T4, T5, T6, T7, T8) = 0;
};
// define CallbackImpl for 9 params
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
class CallbackImpl : public CallbackImplBase {
public:
  virtual ~CallbackImpl () {}
  virtual R operator() (T1, T2, T3, T4, T5, T6, T7, T8, T9) = 0;
};


// an impl for Functors:
template <typename T, typename R, typename T1, typename T2, typename T3, typename T4,typename T5, typename T6, typename T7, typename T8, typename T9>
class FunctorCallbackImpl : public CallbackImpl<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> {
public:
  FunctorCallbackImpl (T const &functor)
    : m_functor (functor) {}
  virtual ~FunctorCallbackImpl () {}
  R operator() (void) {
    return m_functor ();
  }
  R operator() (T1 a1) {
    return m_functor (a1);
  }
  R operator() (T1 a1,T2 a2) {
    return m_functor (a1,a2);
  }
  R operator() (T1 a1,T2 a2,T3 a3) {
    return m_functor (a1,a2,a3);
  }
  R operator() (T1 a1,T2 a2,T3 a3,T4 a4) {
    return m_functor (a1,a2,a3,a4);
  }
  R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5) {
    return m_functor (a1,a2,a3,a4,a5);
  }
  R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6) {
    return m_functor (a1,a2,a3,a4,a5,a6);
  }
  R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7) {
    return m_functor (a1,a2,a3,a4,a5,a6,a7);
  }
  R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8) {
    return m_functor (a1,a2,a3,a4,a5,a6,a7,a8);
  }
  R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8,T9 a9) {
    return m_functor (a1,a2,a3,a4,a5,a6,a7,a8,a9);
  }
  virtual bool IsEqual (Ptr<const CallbackImplBase> other) const {
    FunctorCallbackImpl<T,R,T1,T2,T3,T4,T5,T6,T7,T8,T9> const *otherDerived = 
      dynamic_cast<FunctorCallbackImpl<T,R,T1,T2,T3,T4,T5,T6,T7,T8,T9> const *> (PeekPointer(other));
    if (otherDerived == 0)
      {
        return false;

};

// an impl for pointer to member functions
template <typename OBJ_PTR, typename MEM_PTR, typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
class MemPtrCallbackImpl : public CallbackImpl<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> {
public:
  MemPtrCallbackImpl (OBJ_PTR const&objPtr, MEM_PTR mem_ptr)
    : m_objPtr (objPtr), m_memPtr (mem_ptr) {}

  R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6) {
    return ((CallbackTraits<OBJ_PTR>::GetReference (m_objPtr)).*m_memPtr) (a1, a2, a3, a4, a5, a6);
  }
  R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7) {
    return ((CallbackTraits<OBJ_PTR>::GetReference (m_objPtr)).*m_memPtr) (a1, a2, a3, a4, a5, a6, a7);
  }
  R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8) {
    return ((CallbackTraits<OBJ_PTR>::GetReference (m_objPtr)).*m_memPtr) (a1, a2, a3, a4, a5, a6, a7, a8);
  }
  R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8, T9 a9) {
    return ((CallbackTraits<OBJ_PTR>::GetReference (m_objPtr)).*m_memPtr) (a1, a2, a3, a4, a5, a6, a7, a8, a9);
  }
  virtual bool IsEqual (Ptr<const CallbackImplBase> other) const {
    MemPtrCallbackImpl<OBJ_PTR,MEM_PTR,R,T1,T2,T3,T4,T5,T6,T7,T8,T9> const *otherDerived = 
      dynamic_cast<MemPtrCallbackImpl<OBJ_PTR,MEM_PTR,R,T1,T2,T3,T4,T5,T6,T7,T8,T9> const *> (PeekPointer (other));
    if (otherDerived == 0)
      {
        return false;

};

// an impl for Bound Functors:
template <typename T, typename R, typename TX, typename T1, typename T2, typename T3, typename T4,typename T5, typename T6, typename T7, typename T8>
class BoundFunctorCallbackImpl : public CallbackImpl<R,T1,T2,T3,T4,T5,T6,T7,T8,empty> {
public:
  template <typename FUNCTOR, typename ARG>
  BoundFunctorCallbackImpl (FUNCTOR functor, ARG a)
    : m_functor (functor), m_a (a) {}
  virtual ~BoundFunctorCallbackImpl () {}
  R operator() (void) {
    return m_functor (m_a);
  }
  R operator() (T1 a1) {
    return m_functor (m_a,a1);
  }
  R operator() (T1 a1,T2 a2) {
    return m_functor (m_a,a1,a2);
  }
  R operator() (T1 a1,T2 a2,T3 a3) {
    return m_functor (m_a,a1,a2,a3);
  }
  R operator() (T1 a1,T2 a2,T3 a3,T4 a4) {
    return m_functor (m_a,a1,a2,a3,a4);
  }
  R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5) {
    return m_functor (m_a,a1,a2,a3,a4,a5);
  }
  R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6) {
    return m_functor (m_a,a1,a2,a3,a4,a5,a6);
  }
  R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7) {
    return m_functor (m_a,a1,a2,a3,a4,a5,a6,a7);
  }
  R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5,T6 a6,T7 a7,T8 a8) {
    return m_functor (m_a,a1,a2,a3,a4,a5,a6,a7,a8);
  }
  virtual bool IsEqual (Ptr<const CallbackImplBase> other) const {
    BoundFunctorCallbackImpl<T,R,TX,T1,T2,T3,T4,T5,T6,T7,T8> const *otherDerived = 
      dynamic_cast<BoundFunctorCallbackImpl<T,R,TX,T1,T2,T3,T4,T5,T6,T7,T8> const *> (PeekPointer (other));
    if (otherDerived == 0)
      {
        return false;

 */

template<typename R, 
         typename T1 = empty, typename T2 = empty, 
         typename T3 = empty, typename T4 = empty,
         typename T5 = empty, typename T6 = empty,
         typename T7 = empty, typename T8 = empty,
         typename T9 = empty>
class Callback : public CallbackBase {
public:
  Callback () {}

  // always properly disambiguited by the c++ compiler
  template <typename FUNCTOR>
  Callback (FUNCTOR const &functor, bool, bool) 
    : CallbackBase (Create<FunctorCallbackImpl<FUNCTOR,R,T1,T2,T3,T4,T5,T6,T7,T8,T9> > (functor))
  {}

  template <typename OBJ_PTR, typename MEM_PTR>
  Callback (OBJ_PTR const &objPtr, MEM_PTR mem_ptr)
    : CallbackBase (Create<MemPtrCallbackImpl<OBJ_PTR,MEM_PTR,R,T1,T2,T3,T4,T5,T6,T7,T8,T9> > (objPtr, mem_ptr))
  {}

  Callback (Ptr<CallbackImpl<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> > const &impl)
    : CallbackBase (impl)
  {}

  template <typename T>
  Callback<R,T2,T3,T4,T5,T6,T7,T8,T9> Bind (T a) {
    Ptr<CallbackImpl<R,T2,T3,T4,T5,T6,T7,T8,T9,empty> > impl =
      Ptr<CallbackImpl<R,T2,T3,T4,T5,T6,T7,T8,T9,empty> > (
                                                  new BoundFunctorCallbackImpl<
                                                  Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9>,
                                                  R,T1,T2,T3,T4,T5,T6,T7,T8,T9> (*this, a), false);
    return Callback<R,T2,T3,T4,T5,T6,T7,T8,T9> (impl);
  }

  bool IsNull (void) const {

  R operator() (T1 a1, T2 a2, T3 a3, T4 a4,T5 a5,T6 a6) const {
    return (*(DoPeekImpl ())) (a1,a2,a3,a4,a5,a6);
  }
  R operator() (T1 a1, T2 a2, T3 a3, T4 a4,T5 a5,T6 a6,T7 a7) const {
    return (*(DoPeekImpl ())) (a1,a2,a3,a4,a5,a6,a7);
  }
  R operator() (T1 a1, T2 a2, T3 a3, T4 a4,T5 a5,T6 a6,T7 a7,T8 a8) const {
    return (*(DoPeekImpl ())) (a1,a2,a3,a4,a5,a6,a7,a8);
  }
  R operator() (T1 a1, T2 a2, T3 a3, T4 a4,T5 a5,T6 a6,T7 a7,T8 a8, T9 a9) const {
    return (*(DoPeekImpl ())) (a1,a2,a3,a4,a5,a6,a7,a8,a9);
  }

  bool IsEqual (const CallbackBase &other) const {
    return m_impl->IsEqual (other.GetImpl ());

    DoAssign (other.GetImpl ());
  }
private:
  CallbackImpl<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> *DoPeekImpl (void) const {
    return static_cast<CallbackImpl<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> *> (PeekPointer (m_impl));
  }
  bool DoCheckType (Ptr<const CallbackImplBase> other) const {
    if (other != 0 && dynamic_cast<const CallbackImpl<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> *> (PeekPointer (other)) != 0)
      {
        return true;
      }

      {
        NS_FATAL_ERROR ("Incompatible types. (feed to \"c++filt -t\")"
                        " got=" << typeid (*other).name () << 
                        ", expected=" << typeid (CallbackImpl<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> *).name ());
      }
    m_impl = const_cast<CallbackImplBase *> (PeekPointer (other));
  }


template <typename R, typename T1, typename T2,
          typename T3, typename T4,
          typename T5, typename T6,
          typename T7, typename T8,
          typename T9>
bool operator != (Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> a, Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> b)
{
  return !a.IsEqual (b);
}

 * \param mem_ptr class method member pointer
 * \param objPtr class instance
 * \return a wrapper Callback
 * Build Callbacks for class method members which takes six arguments
 * and potentially return a value.
 */
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5,typename T6>

template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5, typename T6>
Callback<R,T1,T2,T3,T4,T5,T6> MakeCallback (R (T::*mem_ptr) (T1,T2,T3,T4,T5,T6) const, OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6> (objPtr, mem_ptr);
}

/**
 * \ingroup MakeCallback
 * \param mem_ptr class method member pointer
 * \param objPtr class instance
 * \return a wrapper Callback
 * Build Callbacks for class method members which takes seven arguments
 * and potentially return a value.
 */
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5,typename T6, typename T7>
Callback<R,T1,T2,T3,T4,T5,T6,T7> MakeCallback (R (T::*mem_ptr) (T1,T2,T3,T4,T5,T6,T7), OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7> (objPtr, mem_ptr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5, typename T6, typename T7>
Callback<R,T1,T2,T3,T4,T5,T6,T7> MakeCallback (R (T::*mem_ptr) (T1,T2,T3,T4,T5,T6,T7) const, OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7> (objPtr, mem_ptr);
}


/**
 * \ingroup MakeCallback
 * \param mem_ptr class method member pointer
 * \param objPtr class instance
 * \return a wrapper Callback
 * Build Callbacks for class method members which takes eight arguments
 * and potentially return a value.
 */
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5,typename T6, typename T7, typename T8>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> MakeCallback (R (T::*mem_ptr) (T1,T2,T3,T4,T5,T6,T7,T8), OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> (objPtr, mem_ptr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5, typename T6, typename T7, typename T8>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> MakeCallback (R (T::*mem_ptr) (T1,T2,T3,T4,T5,T6,T7,T8) const, OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> (objPtr, mem_ptr);
}

/**
 * \ingroup MakeCallback
 * \param mem_ptr class method member pointer
 * \param objPtr class instance
 * \return a wrapper Callback
 * Build Callbacks for class method members which takes nine arguments
 * and potentially return a value.
 */
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5,typename T6, typename T7, typename T8, typename T9>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> MakeCallback (R (T::*mem_ptr) (T1,T2,T3,T4,T5,T6,T7,T8,T9), OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> (objPtr, mem_ptr);
}
template <typename T, typename OBJ, typename R, typename T1, typename T2, typename T3, typename T4,typename T5, typename T6, typename T7, typename T8, typename T9>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> MakeCallback (R (T::*mem_ptr) (T1,T2,T3,T4,T5,T6,T7,T8,T9) const, OBJ objPtr) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> (objPtr, mem_ptr);
}

/**

 * \ingroup MakeCallback
 * \param fnPtr function pointer
 * \return a wrapper Callback
 * Build Callbacks for functions which takes six arguments
 * and potentially return a value.
 */
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6>
Callback<R,T1,T2,T3,T4,T5,T6> MakeCallback (R (*fnPtr) (T1,T2,T3,T4,T5,T6)) {
  return Callback<R,T1,T2,T3,T4,T5,T6> (fnPtr, true, true);
}

/**
 * \ingroup MakeCallback
 * \param fnPtr function pointer
 * \return a wrapper Callback
 * Build Callbacks for functions which takes seven arguments
 * and potentially return a value.
 */
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6, typename T7>
Callback<R,T1,T2,T3,T4,T5,T6,T7> MakeCallback (R (*fnPtr) (T1,T2,T3,T4,T5,T6,T7)) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7> (fnPtr, true, true);
}

/**
 * \ingroup MakeCallback
 * \param fnPtr function pointer
 * \return a wrapper Callback
 * Build Callbacks for functions which takes eight arguments
 * and potentially return a value.
 */
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6, typename T7, typename T8>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> MakeCallback (R (*fnPtr) (T1,T2,T3,T4,T5,T6,T7,T8)) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> (fnPtr, true, true);
}

/**
 * \ingroup MakeCallback
 * \param fnPtr function pointer
 * \return a wrapper Callback
 * Build Callbacks for functions which takes nine arguments
 * and potentially return a value.
 */
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6, typename T7, typename T8, typename T9>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> MakeCallback (R (*fnPtr) (T1,T2,T3,T4,T5,T6,T7,T8,T9)) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> (fnPtr, true, true);
}



 * \ingroup MakeCallback
 * \overload Callback<R> MakeNullCallback (void)
 * \return a wrapper Callback
 * Build a null callback which takes six arguments
 * and potentially return a value.
 */
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6>
Callback<R,T1,T2,T3,T4,T5,T6> MakeNullCallback (void) {
  return Callback<R,T1,T2,T3,T4,T5,T6> ();
}

/**
 * \ingroup MakeCallback
 * \overload Callback<R> MakeNullCallback (void)
 * \return a wrapper Callback
 * Build a null callback which takes seven arguments
 * and potentially return a value.
 */
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6, typename T7>
Callback<R,T1,T2,T3,T4,T5,T6,T7> MakeNullCallback (void) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7> ();
}

/**
 * \ingroup MakeCallback
 * \overload Callback<R> MakeNullCallback (void)
 * \return a wrapper Callback
 * Build a null callback which takes eight arguments
 * and potentially return a value.
 */
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6, typename T7, typename T8>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> MakeNullCallback (void) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> ();
}

/**
 * \ingroup MakeCallback
 * \overload Callback<R> MakeNullCallback (void)
 * \return a wrapper Callback
 * Build a null callback which takes nine arguments
 * and potentially return a value.
 */
template <typename R, typename T1, typename T2,typename T3,typename T4,typename T5,typename T6, typename T7, typename T8, typename T9>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> MakeNullCallback (void) {
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> ();
}




template <typename R, typename TX, typename ARG>
Callback<R> MakeBoundCallback (R (*fnPtr) (TX), ARG a) {
  Ptr<CallbackImpl<R,empty,empty,empty,empty,empty,empty,empty,empty,empty> > impl =
    Create<BoundFunctorCallbackImpl<R (*) (TX),R,TX,empty,empty,empty,empty,empty,empty,empty,empty> >(fnPtr, a);
  return Callback<R> (impl);
}

template <typename R, typename TX, typename ARG, 
          typename T1>
Callback<R,T1> MakeBoundCallback (R (*fnPtr) (TX,T1), ARG a) {
  Ptr<CallbackImpl<R,T1,empty,empty,empty,empty,empty,empty,empty,empty> > impl =
    Create<BoundFunctorCallbackImpl<R (*) (TX,T1),R,TX,T1,empty,empty,empty,empty,empty,empty,empty> > (fnPtr, a);
  return Callback<R,T1> (impl);
}
template <typename R, typename TX, typename ARG, 
          typename T1, typename T2>
Callback<R,T1,T2> MakeBoundCallback (R (*fnPtr) (TX,T1,T2), ARG a) {
  Ptr<CallbackImpl<R,T1,T2,empty,empty,empty,empty,empty,empty,empty> > impl =
    Create<BoundFunctorCallbackImpl<R (*) (TX,T1,T2),R,TX,T1,T2,empty,empty,empty,empty,empty,empty> > (fnPtr, a);
  return Callback<R,T1,T2> (impl);
}
template <typename R, typename TX, typename ARG,
          typename T1, typename T2,typename T3>
Callback<R,T1,T2,T3> MakeBoundCallback (R (*fnPtr) (TX,T1,T2,T3), ARG a) {
  Ptr<CallbackImpl<R,T1,T2,T3,empty,empty,empty,empty,empty,empty> > impl =
    Create<BoundFunctorCallbackImpl<R (*) (TX,T1,T2,T3),R,TX,T1,T2,T3,empty,empty,empty,empty,empty> > (fnPtr, a);
  return Callback<R,T1,T2,T3> (impl);
}
template <typename R, typename TX, typename ARG,
          typename T1, typename T2,typename T3,typename T4>
Callback<R,T1,T2,T3,T4> MakeBoundCallback (R (*fnPtr) (TX,T1,T2,T3,T4), ARG a) {
  Ptr<CallbackImpl<R,T1,T2,T3,T4,empty,empty,empty,empty,empty> > impl =
    Create<BoundFunctorCallbackImpl<R (*) (TX,T1,T2,T3,T4),R,TX,T1,T2,T3,T4,empty,empty,empty,empty> > (fnPtr, a);
  return Callback<R,T1,T2,T3,T4> (impl);
}
template <typename R, typename TX, typename ARG,
          typename T1, typename T2,typename T3,typename T4,typename T5>
Callback<R,T1,T2,T3,T4,T5> MakeBoundCallback (R (*fnPtr) (TX,T1,T2,T3,T4,T5), ARG a) {
  Ptr<CallbackImpl<R,T1,T2,T3,T4,T5,empty,empty,empty,empty> > impl =
    Create<BoundFunctorCallbackImpl<R (*) (TX,T1,T2,T3,T4,T5),R,TX,T1,T2,T3,T4,T5,empty,empty,empty> > (fnPtr, a);
  return Callback<R,T1,T2,T3,T4,T5> (impl);
}
template <typename R, typename TX, typename ARG,
          typename T1, typename T2,typename T3,typename T4,typename T5, typename T6>
Callback<R,T1,T2,T3,T4,T5,T6> MakeBoundCallback (R (*fnPtr) (TX,T1,T2,T3,T4,T5,T6), ARG a) {
  Ptr<CallbackImpl<R,T1,T2,T3,T4,T5,T6,empty,empty,empty> > impl =
    Create<BoundFunctorCallbackImpl<R (*) (TX,T1,T2,T3,T4,T5,T6),R,TX,T1,T2,T3,T4,T5,T6,empty,empty> > (fnPtr, a);
  return Callback<R,T1,T2,T3,T4,T5,T6> (impl);
}
template <typename R, typename TX, typename ARG,
          typename T1, typename T2,typename T3,typename T4,typename T5, typename T6, typename T7>
Callback<R,T1,T2,T3,T4,T5,T6,T7> MakeBoundCallback (R (*fnPtr) (TX,T1,T2,T3,T4,T5,T6,T7), ARG a) {
  Ptr<CallbackImpl<R,T1,T2,T3,T4,T5,T6,T7,empty,empty> > impl =
    Create<BoundFunctorCallbackImpl<R (*) (TX,T1,T2,T3,T4,T5,T6,T7),R,TX,T1,T2,T3,T4,T5,T6,T7,empty> > (fnPtr, a);
  return Callback<R,T1,T2,T3,T4,T5,T6,T7> (impl);
}
template <typename R, typename TX, typename ARG,
          typename T1, typename T2,typename T3,typename T4,typename T5, typename T6, typename T7, typename T8>
Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> MakeBoundCallback (R (*fnPtr) (TX,T1,T2,T3,T4,T5,T6,T7,T8), ARG a) {
  Ptr<CallbackImpl<R,T1,T2,T3,T4,T5,T6,T7,T8,empty> > impl =
    Create<BoundFunctorCallbackImpl<R (*) (TX,T1,T2,T3,T4,T5,T6,T7,T8),R,TX,T1,T2,T3,T4,T5,T6,T7,T8> > (fnPtr, a);
  return Callback<R,T1,T2,T3,T4,T5,T6,T7,T8> (impl);
}
} // namespace ns3


(-)a/src/core/traced-callback.h (-27 / +105 lines)

Lines 37-43	Link Here

 * the chain of callbacks.

 * the chain of callbacks.

*/

*/

template<typename T1 = empty, typename T2 = empty,

template<typename T1 = empty, typename T2 = empty,

         typename T3 = empty, typename T4 = empty>

         typename T3 = empty, typename T4 = empty,

         typename T5 = empty, typename T6 = empty,

         typename T7 = empty, typename T8 = empty>

class TracedCallback

class TracedCallback

public:

public:

Lines 81-89	Link Here

  void operator() (T1 a1, T2 a2) const;

  void operator() (T1 a1, T2 a2) const;

  void operator() (T1 a1, T2 a2, T3 a3) const;

  void operator() (T1 a1, T2 a2, T3 a3) const;

  void operator() (T1 a1, T2 a2, T3 a3, T4 a4) const;

  void operator() (T1 a1, T2 a2, T3 a3, T4 a4) const;

  void operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) const;

  void operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6) const;

  void operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7) const;

  void operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8) const;

private:

private:

  typedef std::list<Callback<void,T1,T2,T3,T4> > CallbackList;

  typedef std::list<Callback<void,T1,T2,T3,T4,T5,T6,T7,T8> > CallbackList;

  CallbackList m_callbackList;

  CallbackList m_callbackList;

};

};

Lines 94-126	Link Here

namespace ns3 {

100

namespace ns3 {

101

template<typename T1, typename T2,

102

template<typename T1, typename T2,

         typename T3, typename T4>

103

         typename T3, typename T4,

TracedCallback<T1,T2,T3,T4>::TracedCallback ()

104

         typename T5, typename T6,

105

         typename T7, typename T8>

106

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::TracedCallback ()

  : m_callbackList ()

107

  : m_callbackList ()

100

{}

108

{}

101

template<typename T1, typename T2,

109

template<typename T1, typename T2,

102

         typename T3, typename T4>

110

         typename T3, typename T4,

111

         typename T5, typename T6,

112

         typename T7, typename T8>

103

void

113

void

104

TracedCallback<T1,T2,T3,T4>::ConnectWithoutContext (const CallbackBase & callback)

114

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::ConnectWithoutContext (const CallbackBase & callback)

105

115

106

  Callback<void,T1,T2,T3,T4> cb;

116

  Callback<void,T1,T2,T3,T4,T5,T6,T7,T8> cb;

107

  cb.Assign (callback);

117

  cb.Assign (callback);

108

  m_callbackList.push_back (cb);

118

  m_callbackList.push_back (cb);

109

119

110

template<typename T1, typename T2,

120

template<typename T1, typename T2,

111

         typename T3, typename T4>

121

         typename T3, typename T4,

122

         typename T5, typename T6,

123

         typename T7, typename T8>

112

void

124

void

113

TracedCallback<T1,T2,T3,T4>::Connect (const CallbackBase & callback, std::string path)

125

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::Connect (const CallbackBase & callback, std::string path)

114

126

115

  Callback<void,std::string,T1,T2,T3,T4> cb;

127

  Callback<void,std::string,T1,T2,T3,T4,T5,T6,T7,T8> cb;

116

  cb.Assign (callback);

128

  cb.Assign (callback);

117

  Callback<void,T1,T2,T3,T4> realCb = cb.Bind (path);

129

  Callback<void,T1,T2,T3,T4,T5,T6,T7,T8> realCb = cb.Bind (path);

118

  m_callbackList.push_back (realCb);

130

  m_callbackList.push_back (realCb);

119

131

120

template<typename T1, typename T2,

132

template<typename T1, typename T2,

121

         typename T3, typename T4>

133

         typename T3, typename T4,

134

         typename T5, typename T6,

135

         typename T7, typename T8>

122

void

136

void

123

TracedCallback<T1,T2,T3,T4>::DisconnectWithoutContext (const CallbackBase & callback)

137

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::DisconnectWithoutContext (const CallbackBase & callback)

124

138

125

  for (typename CallbackList::iterator i = m_callbackList.begin ();

139

  for (typename CallbackList::iterator i = m_callbackList.begin ();

126

       i != m_callbackList.end (); /* empty */)

140

       i != m_callbackList.end (); /* empty */)

Lines 136-154	Link Here

136

150

137

151

138

template<typename T1, typename T2,

152

template<typename T1, typename T2,

139

         typename T3, typename T4>

153

         typename T3, typename T4,

154

         typename T5, typename T6,

155

         typename T7, typename T8>

140

void

156

void

141

TracedCallback<T1,T2,T3,T4>::Disconnect (const CallbackBase & callback, std::string path)

157

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::Disconnect (const CallbackBase & callback, std::string path)

142

158

143

  Callback<void,std::string,T1,T2,T3,T4> cb;

159

  Callback<void,std::string,T1,T2,T3,T4,T5,T6,T7,T8> cb;

144

  cb.Assign (callback);

160

  cb.Assign (callback);

145

  Callback<void,T1,T2,T3,T4> realCb = cb.Bind (path);

161

  Callback<void,T1,T2,T3,T4,T5,T6,T7,T8> realCb = cb.Bind (path);

146

  DisconnectWithoutContext (realCb);

162

  DisconnectWithoutContext (realCb);

147

163

148

template<typename T1, typename T2,

164

template<typename T1, typename T2,

149

         typename T3, typename T4>

165

         typename T3, typename T4,

166

         typename T5, typename T6,

167

         typename T7, typename T8>

150

void

168

void

151

TracedCallback<T1,T2,T3,T4>::operator() (void) const

169

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (void) const

152

170

153

  for (typename CallbackList::const_iterator i = m_callbackList.begin ();

171

  for (typename CallbackList::const_iterator i = m_callbackList.begin ();

154

       i != m_callbackList.end (); i++)

172

       i != m_callbackList.end (); i++)

Lines 157-165	Link Here

157

175

158

176

159

template<typename T1, typename T2,

177

template<typename T1, typename T2,

160

         typename T3, typename T4>

178

         typename T3, typename T4,

179

         typename T5, typename T6,

180

         typename T7, typename T8>

161

void

181

void

162

TracedCallback<T1,T2,T3,T4>::operator() (T1 a1) const

182

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1) const

163

183

164

  for (typename CallbackList::const_iterator i = m_callbackList.begin ();

184

  for (typename CallbackList::const_iterator i = m_callbackList.begin ();

165

       i != m_callbackList.end (); i++)

185

       i != m_callbackList.end (); i++)

Lines 168-176	Link Here

168

188

169

189

170

template<typename T1, typename T2,

190

template<typename T1, typename T2,

171

         typename T3, typename T4>

191

         typename T3, typename T4,

192

         typename T5, typename T6,

193

         typename T7, typename T8>

172

void

194

void

173

TracedCallback<T1,T2,T3,T4>::operator() (T1 a1, T2 a2) const

195

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2) const

174

196

175

  for (typename CallbackList::const_iterator i = m_callbackList.begin ();

197

  for (typename CallbackList::const_iterator i = m_callbackList.begin ();

176

       i != m_callbackList.end (); i++)

198

       i != m_callbackList.end (); i++)

Lines 179-187	Link Here

179

201

180

202

181

template<typename T1, typename T2,

203

template<typename T1, typename T2,

182

         typename T3, typename T4>

204

         typename T3, typename T4,

205

         typename T5, typename T6,

206

         typename T7, typename T8>

183

void

207

void

184

TracedCallback<T1,T2,T3,T4>::operator() (T1 a1, T2 a2, T3 a3) const

208

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2, T3 a3) const

185

209

186

  for (typename CallbackList::const_iterator i = m_callbackList.begin ();

210

  for (typename CallbackList::const_iterator i = m_callbackList.begin ();

187

       i != m_callbackList.end (); i++)

211

       i != m_callbackList.end (); i++)

Lines 190-198	Link Here

190

214

191

215

192

template<typename T1, typename T2,

216

template<typename T1, typename T2,

193

         typename T3, typename T4>

217

         typename T3, typename T4,

218

         typename T5, typename T6,

219

         typename T7, typename T8>

194

void

220

void

195

TracedCallback<T1,T2,T3,T4>::operator() (T1 a1, T2 a2, T3 a3, T4 a4) const

221

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2, T3 a3, T4 a4) const

196

222

197

  for (typename CallbackList::const_iterator i = m_callbackList.begin ();

223

  for (typename CallbackList::const_iterator i = m_callbackList.begin ();

198

       i != m_callbackList.end (); i++)

224

       i != m_callbackList.end (); i++)

Lines 200-205	Link Here

200

      (*i) (a1, a2, a3, a4);

226

      (*i) (a1, a2, a3, a4);

201

227

202

228

229

template<typename T1, typename T2,

230

         typename T3, typename T4,

231

         typename T5, typename T6,

232

         typename T7, typename T8>

233

void

234

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) const

235

236

  for (typename CallbackList::const_iterator i = m_callbackList.begin ();

237

       i != m_callbackList.end (); i++)

238

239

      (*i) (a1, a2, a3, a4, a5);

240

241

242

template<typename T1, typename T2,

243

         typename T3, typename T4,

244

         typename T5, typename T6,

245

         typename T7, typename T8>

246

void

247

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6) const

248

249

  for (typename CallbackList::const_iterator i = m_callbackList.begin ();

250

       i != m_callbackList.end (); i++)

251

252

      (*i) (a1, a2, a3, a4, a5, a6);

253

254

255

template<typename T1, typename T2,

256

         typename T3, typename T4,

257

         typename T5, typename T6,

258

         typename T7, typename T8>

259

void

260

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7) const

261

262

  for (typename CallbackList::const_iterator i = m_callbackList.begin ();

263

       i != m_callbackList.end (); i++)

264

265

      (*i) (a1, a2, a3, a4, a5, a6, a7);

266

267

268

template<typename T1, typename T2,

269

         typename T3, typename T4,

270

         typename T5, typename T6,

271

         typename T7, typename T8>

272

void

273

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8) const

274

275

  for (typename CallbackList::const_iterator i = m_callbackList.begin ();

276

       i != m_callbackList.end (); i++)

277

278

      (*i) (a1, a2, a3, a4, a5, a6, a7, a8);

279

280

203

281

204

}//namespace ns3

282

}//namespace ns3

205

283

Return to bug 412