// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
/** \file
- \brief Conenctors public header */
+ \brief Connectors public header */
/** \defgroup connectors Connector classes
senf::ppi::PassiveInput and senf::ppi::PassiveOutput.
*/
-#ifndef HH_Conenctors_
-#define HH_Conenctors_ 1
+#ifndef HH_Connectors_
+#define HH_Connectors_ 1
// Custom includes
+#include <deque>
#include <boost/utility.hpp>
-
-//#include "Conenctors.mpp"
+#include <boost/scoped_ptr.hpp>
+#include "Utils/SafeBool.hh"
+#include "Packets/Packets.hh"
+#include "predecl.hh"
+#include "detail/Callback.hh"
+#include "Queueing.hh"
+
+//#include "Connectors.mpp"
///////////////////////////////hh.p////////////////////////////////////////
namespace senf {
{
public:
Connector & peer(); ///< Get peer connected to this connector
- Module & module(); ///< Get this connectors containing module
+ module::Module & module(); ///< Get this connectors containing module
protected:
- // here to protect
Connector();
- ~Connector();
+ virtual ~Connector();
+
+ void connect(Connector & target);
+
+ private:
+ void setModule(module::Module & module);
+
+ Connector * peer_;
+ module::Module * module_;
+
+ friend class module::Module;
};
/** \brief Passive connector baseclass
ActiveConnector & peer();
protected:
- // here to protect
PassiveConnector();
- ~PassiveConnector();
+
+ void emit();
+
+ private:
+
+ typedef detail::Callback<>::type Callback;
+ Callback callback_;
};
/** \brief Active connector baseclass
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 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();
protected:
- // here to protect
- PassiveConnector();
- ~PassiveConnector();
+ ActiveConnector();
};
/** \brief Input connector baseclass
be added to the queue before it can be processed.
*/
class InputConnector
- : public virtual Connector
+ : public virtual Connector,
+ public SafeBool<InputConnector>
{
+ typedef std::deque<Packet> Queue;
public:
- typedef unspecified queue_iterator; ///< Iterator type of the embedded queue
- typedef unspecified size_type; ///< Unsigned type representing the number of queue elements
+ typedef Queue::const_iterator queue_iterator; ///< Iterator type of the embedded queue
+ typedef Queue::size_type size_type; ///< Unsigned type for counting queue elements
- Packet::ptr operator(); ///< Get a packet
+ Packet operator()(); ///< Get a packet
/**< This member is the primary method to access received
data. On passive connectors, this operator will just
dequeue a packet from the packet queue. If the
request cannot be fulfilled, this is considered to be a
logic error in the module implementation and an
exception is raised. */
- operator unspecified_boolean_type (); ///< Check packet availability
+ bool boolean_test (); ///< 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
\returns \c true if operator() can be called, \c false
otherwise */
- operator ! (); ///< Check packet availability
- /**< Inverse of the boolean conversion operator
- \returns \c false if operator() can be called, \c true
- otherwise */
OutputConnector & peer();
queue_iterator begin(); ///< Access queue begin (head)
queue_iterator end(); ///< Access queue past-the-end (tail)
- Packet::ptr head(); ///< Return head element from the queue
+ Packet peek(); ///< Return head element from the queue
size_type queueSize(); ///< Return number of elements in the queue
bool empty(); ///< Return queueSize() == 0
protected:
- // here to protect
- PassiveConnector();
- ~PassiveConnector();
+ InputConnector();
+
+ private:
+ void enqueue(Packet p);
+
+ virtual void v_enqueueEvent();
+ virtual void v_dequeueEvent();
+
+ Queue queue_;
+
+ friend class OutputConnector;
};
/** \brief Output connector baseclass
: public virtual Connector
{
public:
- void operator(Packet::ptr); ///< Send out a packet
+ void operator()(Packet p); ///< Send out a packet
InputConnector & peer();
protected:
- // here to protect
- PassiveConnector();
- ~PassiveConnector();
+ OutputConnector();
};
///@{
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 PassiveConnector, public InputConnector
{
public:
+ PassiveInput();
+
ActiveOutput & peer();
- template <class QueueingDiscipline>
- void qdisc(QueueingDiscipline const & disc); ///< Change the queueing discipline
+ template <class QDisc>
+ void qdisc(QDisc const & disc); ///< Change the queueing discipline
/**< The queueing discipline is a class which provides the
QueueingDiscipline interface.
\param[in] disc New queueing discipline */
+
+ private:
+ void v_enqueueEvent();
+ void v_dequeueEvent();
+
+ boost::scoped_ptr<QueueingDiscipline> qdisc_;
+ QueueingDiscipline::State qstate_;
};
/** \brief Combination of PassiveConnector and OutputConnector
{
public:
ActiveInput & peer();
+
+ void connect(ActiveInput & target);
};
/** \brief Combination of ActiveConnector and InputConnector
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
{
public:
ActiveInput & peer();
+
+ void connect(PassiveInput & target);
};
///@}
}}}
///////////////////////////////hh.e////////////////////////////////////////
-//#include "Conenctors.cci"
-//#include "Conenctors.ct"
-//#include "Conenctors.cti"
+#include "Connectors.cci"
+//#include "Connectors.ct"
+#include "Connectors.cti"
#endif
\f
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
+// comment-column: 40
// End: