#include <deque>
#include <boost/utility.hpp>
#include <boost/scoped_ptr.hpp>
-#include "../Utils/safe_bool.hh"
-#include "../Utils/Exception.hh"
-#include "../Packets/Packets.hh"
+#include <senf/Utils/safe_bool.hh>
+#include <senf/Utils/Exception.hh>
+#include <senf/Packets/Packets.hh>
#include "predecl.hh"
#include "detail/Callback.hh"
#include "Queueing.hh"
#include "ModuleManager.hh"
//#include "Connectors.mpp"
-///////////////////////////////hh.p////////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
namespace senf {
namespace ppi {
We therefore have 4 connector types each of which is parameterized by the type of packet
traversing the connector:
\li senf::ppi::connector::ActiveInput
- \li senf::ppi::connector::ActiveOutput
- \li senf::ppi::connector::PassiveInput
+ \li senf::ppi::connector::ActiveOutput
+ \li senf::ppi::connector::PassiveInput
\li senf::ppi::connector::PassiveOutput.
Connectors are declared as module data members and are then externally connected to other
senf::ppi::connector::ActiveInputJack<senf::EthernetPacket> input;
senf::ppi::connector::ActiveOutputJack<senf::EthernetPacket> output;
- MyGroup()
+ MyGroup()
: queue (), analyzer (), input (queue.input), output (analyzer.output)
{
senf::ppi::connect(queue, analyzer);
void trace(Packet const & p, char const * label);
void throttleTrace(char const * label, char const * type);
-
+
+ void unregisterConnector();
+
+ virtual void v_disconnected();
+ virtual void v_connected();
+
private:
virtual std::type_info const & packetTypeID();
: public virtual Connector
{
public:
+ ~PassiveConnector();
+
template <class Handler>
void onRequest(Handler handler);///< Register I/O event handler
/**< The registered handler will be called, whenever packets
void emit();
+ virtual void v_disconnected();
+ virtual void v_connected();
+
private:
virtual void v_init();
// called by ForwardingRoute to register a new route
void registerRoute(ForwardingRoute & route);
+ void unregisterRoute(ForwardingRoute & route);
+
+ ActiveConnector * peer_;
typedef ppi::detail::Callback<>::type Callback;
Callback callback_;
{
typedef ppi::detail::Callback<>::type Callback;
public:
+ ~ActiveConnector();
+
template <class Handler>
void onThrottle(Handler handler); ///< Register throttle notification handler
/**< The handler register here will be called, whenever a
protected:
ActiveConnector();
+ virtual void v_disconnected();
+ virtual void v_connected();
+
private:
virtual void v_init();
// called by ForwardingRoute to register a new route
void registerRoute(ForwardingRoute & route);
+ void unregisterRoute(ForwardingRoute & route);
+
+ PassiveConnector * peer_;
Callback throttleCallback_;
Callback unthrottleCallback_;
typedef std::vector<ForwardingRoute*> NotifyRoutes;
NotifyRoutes notifyRoutes_;
- bool throttled_;
+ bool throttled_;
friend class senf::ppi::ForwardingRoute;
friend class PassiveConnector;
dequeue a packet from the packet queue. If the
connector is active, the connector will request new
packets from the connected module. If the packet
- request cannot be fulfilled, this is considered to be a
- logic error in the module implementation and an
- exception is raised. */
+ request cannot be fulfilled an in-valid Packet is
+ returned. */
Packet read(); ///< Alias for operator()()
protected:
InputConnector();
+ virtual void v_disconnected();
+ virtual void v_connected();
+
private:
void enqueue(Packet const & p);
virtual void v_enqueueEvent();
virtual void v_dequeueEvent();
+ OutputConnector * peer_;
Queue queue_;
friend class OutputConnector;
protected:
OutputConnector();
+
+ virtual void v_disconnected();
+ virtual void v_connected();
+
+ private:
+ InputConnector * peer_;
};
/** \brief Combination of PassiveConnector and InputConnector
QueueingDiscipline interface.
\param[in] disc New queueing discipline */
+ void qdisc(QueueingDiscipline::None_t);
+ ///< Disable queueing discipline
protected:
GenericPassiveInput();
+ virtual void v_disconnected();
+ virtual void v_connected();
+
private:
void v_enqueueEvent();
void v_dequeueEvent();
void v_unthrottleEvent();
+ GenericActiveOutput * peer_;
boost::scoped_ptr<QueueingDiscipline> qdisc_;
};
protected:
GenericPassiveOutput();
+ virtual void v_disconnected();
+ virtual void v_connected();
+
+ private:
+ GenericActiveInput * peer_;
};
/** \brief Combination of ActiveConnector and InputConnector
protected:
GenericActiveInput();
+ virtual void v_disconnected();
+ virtual void v_connected();
+
private:
void v_requestEvent();
+
+ GenericPassiveOutput * peer_;
};
/** \brief Combination of ActiveConnector and OutputConnector
protected:
GenericActiveOutput();
+ virtual void v_disconnected();
+ virtual void v_connected();
+
+ private:
+ GenericPassiveInput * peer_;
};
+
#ifndef DOXYGEN
# define TypedConnector_Input read
#else
/** \brief Connector actively reading packets
-
+
\tparam PacketType Type of packet to read. Defaults to senf::Packet
The %ActiveInput %connector template reads data actively from a connected %module. This
- class is completely implemented via it's base-class, GenericActiveInput, the only
- difference is that read packets are returned as \a PacketType instead of generic
+ class is completely implemented via it's base-class, GenericActiveInput, the only
+ difference is that read packets are returned as \a PacketType instead of generic
senf::Packet references.
\see GenericActiveInput \n
\tparam PacketType Type of packet to read. Defaults to senf::Packet
The %PassiveInput %connector template receives packets sent to it from a connected
- %module. This class is completely implemented via it's base-class, GenericPassiveInput,
+ %module. This class is completely implemented via it's base-class, GenericPassiveInput,
the only difference is that read packets are returned as \a PacketType instead of generic
senf::Packet references.
\tparam PacketType Type of packet to send. Defaults to senf::Packet
- The %ActiveOutput %connector template sends data actively to a connected %module. This
+ The %ActiveOutput %connector template sends data actively to a connected %module. This
class is completely implemented via it's base-class, GenericActiveOutput, the only
difference is that it only sends packets of type \a PacketType.
class ActiveOutput : public GenericActiveOutput
{
public:
- operator()(PacketType packet); ///< Send out a packet
- void write(PacketType packet); ///< Alias for operator()
+ void operator()(PacketType packet); ///< Send out a packet
+ void write(PacketType packet); ///< Alias for operator()
};
/** \brief Connector passively providing packets
\tparam PacketType Type of packet to send. Defaults to senf::Packet
- The %PassiveOutput %connector template provides data passively to a connected %module
- whenever signaled. This class is completely implemented via it's base-class,
- GenericPassiveOutput, the only difference is that it only sends packets of type
+ The %PassiveOutput %connector template provides data passively to a connected %module
+ whenever signaled. This class is completely implemented via it's base-class,
+ GenericPassiveOutput, the only difference is that it only sends packets of type
\a PacketType.
\see GenericPassiveOutput \n
class PassiveOutput : public GenericPassiveOutput
{
public:
- operator()(PacketType packet); ///< Send out a packet
- void write(PacketType packet); ///< Alias for operator()
+ void operator()(PacketType packet); ///< Send out a packet
+ void write(PacketType packet); ///< Alias for operator()
};
#endif
}}}
-///////////////////////////////hh.e////////////////////////////////////////
+//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "Connectors.cci"
-//#include "Connectors.ct"
+#include "Connectors.ct"
#include "Connectors.cti"
#endif