using namespace std::placeholders;

  // These lambdas call the DropBeforeEnqueue or DropAfterDequeue methods of this

  // QueueDisc object. Given that a callback to the operator() of these lambdas

  // Remove ambiguity for overloaded member functions

  // is connected to the DropBeforeEnqueue and DropAfterDequeue traces of the

  typedef std::basic_string<char>& (std::basic_string<char>::*Function) (const char*);

  // internal queues, the INTERNAL_QUEUE_DROP constant is passed as the reason

  // why the packet is dropped.

  Function append = &std::basic_string<char>::append,

  m_internalQueueDbeFunctor = [this] (Ptr<const QueueDiscItem> item)

           assign = &std::basic_string<char>::assign;

    {

      return DropBeforeEnqueue (item, INTERNAL_QUEUE_DROP);

  // The operator() of these function objects calls the QueueDisc::DropBeforeEnqueue

    };

  // and QueueDisc::DropAfterDequeue methods of this QueueDisc object (these function

  m_internalQueueDadFunctor = [this] (Ptr<const QueueDiscItem> item)

  // objects are bound to this QueueDisc object), which require two arguments: a

    {

  // Ptr<const QueueDiscItem> and a const char*. Given that a callback to the operator()

      return DropAfterDequeue (item, INTERNAL_QUEUE_DROP);

  // is connected to the DropBeforeEnqueue and DropAfterDequeue traces of the Queue

    };

  // class, the first argument is provided by such traces, while the second argument

  // (the reason why the packet was dropped) is bound to the INTERNAL_QUEUE_DROP constant.

  // These lambdas call the DropBeforeEnqueue or DropAfterDequeue methods of this

  m_internalQueueDbeFunctor = std::bind (&QueueDisc::DropBeforeEnqueue, this,

  // QueueDisc object. Given that a callback to the operator() of these lambdas

                                         _1, (const char*)INTERNAL_QUEUE_DROP);

  // is connected to the DropBeforeEnqueue and DropAfterDequeue traces of the

  m_internalQueueDadFunctor = std::bind (&QueueDisc::DropAfterDequeue, this,

  // child queue discs, the concatenation of the CHILD_QUEUE_DISC_DROP constant

                                         _1, (const char*)INTERNAL_QUEUE_DROP);

  // and the second argument provided by such traces is passed as the reason why

  // the packet is dropped.

  // The operator() of these function objects calls the QueueDisc::DropBeforeEnqueue

  m_childQueueDiscDbeFunctor = [this] (Ptr<const QueueDiscItem> item, const char* r)

  // and QueueDisc::DropAfterDequeue methods of this QueueDisc object (these function

    {

  // objects are bound to this QueueDisc object), which require two arguments: a

      return DropBeforeEnqueue (item,

  // Ptr<const QueueDiscItem> and a const char*. Given that a callback to the operator()

                                m_childQueueDiscDropMsg.assign (CHILD_QUEUE_DISC_DROP).append (r).data ());

  // is connected to the DropBeforeEnqueue and DropAfterDequeue traces of the QueueDisc

    };

  // class, both arguments are provided by such traces. The first argument is provided

  m_childQueueDiscDadFunctor = [this] (Ptr<const QueueDiscItem> item, const char* r)

  // as is, while the second argument (the reason why the packet was dropped) is obtained

    {

  // by calling m_childQueueDiscDropMsg.assign (CHILD_QUEUE_DISC_DROP).append (_2).data ()

      return DropAfterDequeue (item,

  // i.e., the second argument is the concatenation of the CHILD_QUEUE_DISC_DROP constant

                               m_childQueueDiscDropMsg.assign (CHILD_QUEUE_DISC_DROP).append (r).data ());

  // and the second argument provided by the traces of the QueueDisc class.

    };

  m_childQueueDiscDbeFunctor = std::bind (&QueueDisc::DropBeforeEnqueue, this, _1,

                                          std::bind (&std::basic_string<char>::data,

                                                     std::bind (append,

                                                                std::bind (assign,

                                                                           &m_childQueueDiscDropMsg,

                                                                           (const char*)CHILD_QUEUE_DISC_DROP),

                                                                _2)));

  m_childQueueDiscDadFunctor = std::bind (&QueueDisc::DropAfterDequeue, this, _1,

                                          std::bind (&std::basic_string<char>::data,

                                                     std::bind (append,

                                                                std::bind (assign,

                                                                           &m_childQueueDiscDropMsg,

                                                                           (const char*)CHILD_QUEUE_DISC_DROP),

                                                                _2)));

 * the additional time the packet is retained within the queue disc in case it is

 * the additional time the packet is retained within the traffic control

 * requeued.

 * infrastructure in case it is requeued.