namespace senf {
namespace ppi {
+namespace connector {
/** \brief Connector baseclass
notifications
The accumulative throttling state is generated by combining all sub-states.
-
- \ingroup connectors
*/
class PassiveConnector
: public virtual Connector
Active connectors do not handle any throttling state, they just receive the
notifications. These notifications should then either be processed by the module or be
forwarded to other connectors.
-
- \ingroup connectors
*/
class ActiveConnector
: public virtual Connector
{
public:
template <class Handler>
- void onThrottle(Handler); ///< Register throttle notification handler
+ void onThrottle(Handler handle); ///< Register throttle notification handler
/**< The handler register here will be called, whenever a
throttle notification comes in. The \a handler argument
is either an arbitrary callable object or it is a
this input. In the second case, the pointer will
automatically be bound to the containing instance.
- \param[in] handler Handler to call on throttle
+ \param[in] handle Handler to call on throttle
notifications. */
template <class Handler>
- void onUnthrottle(Handler); ///< Register unthrottle notification handler
+ void onUnthrottle(Handler handle); ///< Register unthrottle notification handler
/**< The handler register here will be called, whenever an
unthrottle notification comes in. The \a handler
argument is either an arbitrary callable object or it
holds this input. In the second case, the pointer will
automatically be bound to the containing instance.
- \param[in] handler Handler to call on unthrottle
+ \param[in] handle Handler to call on unthrottle
notifications. */
PassiveConnector & peer();
packets in batches or generating multiple output packets from a single input packet. The
queues have the potential to greatly simplify the module implementations.
- \ingroup connectors
+ \implementation Which container to use?
+ \li list has good insertion and deletion properties on both ends but it costs a dynamic
+ memory allocation for every insertion. A very good property is, that iterators stay
+ valid across insertions/deletions
+ \li vector is fast and has good amortized dynamic allocation properties. However, it is
+ quite unusable as a queue
+ \li deque has comparable dynamic allocation properties as vector but also has good
+ insertion/removal properties on both ends.
+
+ So probably we will use a deque. I'd like a container which keeps iterators intact on
+ isertion/deletion but I believe that list is just to expensive since every packet will
+ be added to the queue before it can be processed.
*/
class InputConnector
: public virtual Connector
exception is raised. */
operator unspecified_boolean_type (); ///< Check packet availability
/**< Using any input connector in a boolean context will
- check, wether an input request can be fulfilled. This
+ check, whether an input request can be fulfilled. This
is always possible if the queue is non-empty. If the
input is active, it also returns when the connected
passive output is not throttled so new packets can be
An output connector sends out packets. It may be either an ActiveConnector or a
PassiveConnector. An output connector does \e not have an built-in queueing, it relies on
the queueing of the connected input.
-
- \ingroup connectors
*/
class OutputConnector
: public virtual Connector
PassiveConnector();
~PassiveConnector();
};
+
+ ///@{
+ ///\addtogroup connectors
/** \brief Combination of PassiveConnector and InputConnector
- \ingroup connectors
+ In addition to the native and the forwarded throttling state, the PassiveInput manages a
+ queue throttling state. This state is automatically managed by a queueing discipline. The
+ standard queueing discipline is ThresholdQueueing, which throttles the connection whenever
+ the queue length reaches the high threshold and unthrottles the connection when the queue
+ reaches the low threshold. The default queueing discipline is
+ <tt>ThresholdQueueing(1,0)</tt> which will throttle the input whenever the queue is
+ non-empty.
*/
class PassiveInput
: public PassiveConnector, public InputConnector
public:
ActiveOutput & peer();
- template <class QDisc>
- QDisc const & qdisc(QDisc const & disc);
+ template <class QueueingDiscipline>
+ void qdisc(QueueingDiscipline const & disc); ///< Change the queueing discipline
+ /**< The queueing discipline is a class which provides the
+ QueueingDiscipline interface.
+
+ \param[in] disc New queueing discipline */
};
/** \brief Combination of PassiveConnector and OutputConnector
-
- \ingroup connectors
*/
class PassiveOutput
: public PassiveConnector, public OutputConnector
};
/** \brief Combination of ActiveConnector and InputConnector
-
- \ingroup connectors
*/
class ActiveInput
: public ActiveConnector, public InputConnector
{
public:
- void request(); ///< request more packets without dequeing any packet
-
PassiveOutput & peer();
+
+ void request(); ///< request more packets without dequeuing any packet
};
/** \brief Combination of ActiveConnector and OutputConnector
-
- \ingroup connectors
*/
class ActiveOutput
: public ActiveConnector, public OutputConnector
ActiveInput & peer();
};
-}}
+ ///@}
+
+}}}
///////////////////////////////hh.e////////////////////////////////////////
//#include "Conenctors.cci"
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
+// compile-command: "scons -u test"
+// comment-column: 40
// End:
projects / senf.git / blobdiff