// $Id$
//
-// Copyright (C) 2007
-// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
-// Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
+// Copyright (C) 2007
+// Fraunhofer Institute for Open Communication Systems (FOKUS)
+// Competence Center NETwork research (NET), St. Augustin, GERMANY
// Stefan Bund <g0dil@berlios.de>
//
// This program is free software; you can redistribute it and/or modify
/** \file
\brief DebugModules public header */
-#ifndef HH_DebugModules_
-#define HH_DebugModules_ 1
+#ifndef HH_SENF_PPI_DebugModules_
+#define HH_SENF_PPI_DebugModules_ 1
// Custom includes
#include <deque>
-#include "Utils/SafeBool.hh"
-#include "Packets/Packets.hh"
+#include "../Utils/safe_bool.hh"
+#include "../Packets/Packets.hh"
#include "Module.hh"
#include "ActiveFeeder.hh"
-#include "Utils/Logger.hh"
+#include "../Utils/Logger/SenfLog.hh"
//#include "DebugModules.mpp"
///////////////////////////////hh.p////////////////////////////////////////
namespace ppi {
namespace module {
namespace debug {
-
+
/** \namespace senf::ppi::module::debug
\brief Debug modules
manually pass packets into a network and read back the output packets.
There are three categories of modules:
-
+
\li <i>Active modules</i> (ActiveSource, ActiveSink) are triggered by external
calls. Calling \c submit() / \c request() will send the request into the module network
synchronously. From this it follows, that senf::ppi::run() should \e not be
signaled in the network</em>.
*/
class ActiveSource
- : public Module,
- public SafeBool<ActiveSource>
+ : public Module,
+ public safe_bool<ActiveSource>
{
SENF_PPI_MODULE(ActiveSource);
public:
- connector::ActiveOutput output;
+ connector::ActiveOutput<> output;
ActiveSource();
- void submit(Packet packet); ///< Submit packet
+ void submit(Packet const & packet); ///< Submit packet
/**< \pre boolean_test() is \c true */
bool boolean_test() const; ///< \c true if \a output is not throttled
};
/** \brief Debug packet source with passive output
-
+
This module provides a queue of packets for reading by the network. Each submit() call adds
a packet to the queue which will be sent into the network when requested. The output is
automatically throttled when the queue becomes empty.
public:
typedef Queue::size_type size_type;
-
- connector::PassiveOutput output;
+
+ connector::PassiveOutput<> output;
PassiveSource();
-
- void submit(Packet packet); ///< Enqueue packet
+
+ void throttle(); ///< Throttle output connector
+ void unthrottle(); ///< Unthrottle output connector
+
+ void submit(Packet const & packet); ///< Enqueue packet
bool empty(); ///< \c true if queue is empty
size_type size(); ///< Number of packets in queue
private:
void request();
- void init();
-
+ virtual void v_init();
+
Queue packets_;
};
-
+
/** \brief Debug packet sink with active input
This module requests packets from the network. Each call to request() will pass a packet
*/
class ActiveSink
: public Module,
- public SafeBool<ActiveSink>
+ public safe_bool<ActiveSink>
{
SENF_PPI_MODULE(ActiveSink);
public:
- connector::ActiveInput input;
+ connector::ActiveInput<> input;
ActiveSink();
typedef Queue::size_type size_type;
typedef Queue::const_iterator iterator;
- connector::PassiveInput input;
-
+ connector::PassiveInput<> input;
+
PassiveSink();
+ void throttle(); ///< Throttle input connection
+ void unthrottle(); ///< Unthrottle input connection
+
bool empty(); ///< \c true, if queue is empty
size_type size(); ///< number of packets in the queue
iterator begin(); ///< begin iterator of packets in the queue
};
/** \brief Active, queue-based packet source
-
+
The ActiveFeederSource contains a packet queue containing the packets to be precessed. These
packets are actively fed into the network when it is run with senf::ppi::run() until it is
empty, when senf::ppi::run() will return.
public:
typedef PassiveSource::size_type size_type;
-
- connector::ActiveOutput & output;
+
+ connector::ActiveOutput<> & output;
ActiveFeederSource();
};
/** \brief Active, queue-based packet sink
-
+
The ActiveFeederSink contains a packet queue to receive the packets from the network. The
ActiveFeederSink will actively request packets from the network until it's input is
throttled.
\note ActiveFeederSink does \e not have a termination condition like ActiveFeederSource, it
- relies on the network to throttle it's input. Also, the same not as for
- ActiveFeederSource applies here too: You need to ensure, that no events are active
- eventually or senf::ppi::run will not return.
+ relies on the network to throttle it's input. Additionally, the restrictions of
+ ActiveFeederSource apply here too: You need to ensure, that no (additional) events are
+ active (eventually) or senf::ppi::run will not return.
ActiveFeederSink is not a module but a collection of two modules: a PassiveSink and an
- ActiveFeeder.
+ ActiveFeeder.
*/
class ActiveFeederSink
{
typedef PassiveSink::size_type size_type;
typedef PassiveSink::iterator iterator;
- connector::ActiveInput & input;
-
+ connector::ActiveInput<> & input;
+
ActiveFeederSink();
bool empty();
void clear();
};
-
+
/** \brief Log received packets
This module will log all packets sent to it's input using SENF_LOG to the given log
- \a Stream, \a Area and \a level.
+ \a Stream, \a Area and \a Level.
*/
- template < class Stream = log::Debug,
- class Area = log::DefaultArea,
- senf::log::Level level = log::VERBOSE >
- class LogWriter
+ template < class Stream = log::Debug,
+ class Area = log::DefaultArea,
+ class Level = log::VERBOSE >
+ class LogSink
: public module::Module
{
- SENF_PPI_MODULE(LogWriter);
+ SENF_PPI_MODULE(LogSink);
public:
- connector::PassiveInput input;
+ connector::PassiveInput<> input;
- LogWriter();
+ LogSink();
private:
void request();