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>
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();
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
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 discpiline is
+ 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.
*/
public:
PassiveOutput & peer();
- void request(); ///< request more packets without dequeing any packet
+ void request(); ///< request more packets without dequeuing any packet
};
/** \brief Combination of ActiveConnector and OutputConnector
/** \brief Generic event interface baseclass
- The EventDescriptor baseclass provides an interface to manuplate events in a generic
+ The EventDescriptor baseclass provides an interface to manipulate events in a generic
way. This allows to register events or to temporarily disable event processing.
*/
class EventDescriptor
virtual void v_register(CallbackType handler) = 0; ///< Called to register the event
virtual void v_unregister() = 0; ///< Called to unregister the event
virtual void v_enable() = 0; ///< Called to enable the event delivery
- virtual void v_disable() = 0; ///< Called to disable the event delilvery
+ virtual void v_disable() = 0; ///< Called to disable the event delivery
virtual void v_process() = 0; ///< Called whenever the event is signaled
/**< This virtual method is called \e after every call to
the event handler to provide a hook for further
/** \mainpage libPPI : The Packet Processing Infrastructure
- The PPI provides an infrastructure to create packet oriented network processin
+ The PPI provides an infrastructure to create packet oriented network processing
applications. A PPI application is built by combining processing modules in a very flexible
manner.
up. The buffering on the udpInput <-> rateStuffer adaptor is changed so the queue will begin to
throttle only if more than 10 packets are in the queue. The connection will be unthrottled as
soon as there are no more than 5 packets left in the queue. This application will read
- udp-packts coming in on port 1111 and will forward them to port 2222 on host 2.3.4.5 with a
+ udp-packets coming in on port 1111 and will forward them to port 2222 on host 2.3.4.5 with a
fixed rate of 10 packets / second.
\section throttling Throttling
by the template argument.
We register an IOSignaler event. This event will be signaled whenever the socket is
- readable. This event is routet to the output. This routing automates throttling for the socket:
+ readable. This event is routed to the output. This routing automates throttling for the socket:
Whenever the output receives a throttle notifications, the event will be temporarily disabled.
Processing arriving packets happens in the \c data() member: This member simple reads a packet
The return value may be used to alter routing
parameters like throttling parameters.
- \param[in] source Data source, object which controlls
+ \param[in] source Data source, object which controls
incoming data
- \param[in] target Data target, object which controlls
+ \param[in] target Data target, object which controls
outgoing data
\returns Route instance describing this route */
PassiveQueue();
void qdisc(QueueingDiscipline const & disc); ///< Change the queueing discipline
- /**< This call changs the queueing discipline of the queue. This call is just forwarded to
+ /**< This call changes the queueing discipline of the queue. This call is just forwarded to
the \a input connector.
\see connector::PassiveInput::qdisc() */
called to calculate the new throttling state.
\param[in] input Connector holding the queue
- \param[in] event Type of event triggering the upate
+ \param[in] event Type of event triggering the update
\returns new throttling state */
};
class SomeReader
{
public:
- typedef unspecified_type Handle; // type of handle reqeusted
+ typedef unspecified_type Handle; // type of handle requested
SomeReader(); // default constructible
Packet::ptr operator()(Handle handle); // extraction function
};
public:
typedef typename Reader::Handle Handle; ///< Handle type requested by the reader
- connector::ActiveOutput output; ///< Output connector to which the data recevied is writtten
+ connector::ActiveOutput output; ///< Output connector to which the data received is written
ActiveSocketReader(Handle handle); ///< Create new reader for the given handle
/**< Data will be read from \a handle and be parsed by \a
/** \brief Write helper for module::ActiveSocketWriter / module::PassiveSocketWriter
- This write helper will write the packets completely as datagrmas to the given socket.
+ This write helper will write the packets completely as datagrams to the given socket.
*/
class PacketWriter
{
projects / senf.git / commitdiff