//
// 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
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
+// The contents of this file are subject to the Fraunhofer FOKUS Public License
+// Version 1.0 (the "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+// http://senf.berlios.de/license.html
//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
+// The Fraunhofer FOKUS Public License Version 1.0 is based on,
+// but modifies the Mozilla Public License Version 1.1.
+// See the full license text for the amendments.
//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the
-// Free Software Foundation, Inc.,
-// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+// Software distributed under the License is distributed on an "AS IS" basis,
+// WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+// for the specific language governing rights and limitations under the License.
+//
+// The Original Code is Fraunhofer FOKUS code.
+//
+// The Initial Developer of the Original Code is Fraunhofer-Gesellschaft e.V.
+// (registered association), Hansastraße 27 c, 80686 Munich, Germany.
+// All Rights Reserved.
+//
+// Contributor(s):
+// Stefan Bund <g0dil@berlios.de>
/** \file
\brief Connectors public header */
#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 throttleTrace(char const * label, char const * type);
void unregisterConnector();
-
+
+ virtual void v_disconnected();
+ virtual void v_connected();
+
private:
- virtual std::type_info const & packetTypeID();
-
- virtual void v_disconnected() const;
+ virtual std::type_info const & v_packetTypeId();
void setModule(module::Module & module);
void emit();
+ virtual void v_disconnected();
+ virtual void v_connected();
+
private:
virtual void v_init();
void registerRoute(ForwardingRoute & route);
void unregisterRoute(ForwardingRoute & route);
+ ActiveConnector * peer_;
+
typedef ppi::detail::Callback<>::type Callback;
Callback callback_;
protected:
ActiveConnector();
+ virtual void v_disconnected();
+ virtual void v_connected();
+
private:
virtual void v_init();
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;
typedef Queue::size_type size_type; ///< Unsigned type for counting queue elements
- Packet operator()(); ///< Get a packet
+ Packet const & 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
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()()
+ Packet const & read(); ///< Alias for operator()()
OutputConnector & peer() const;
- queue_iterator begin() const; ///< Access queue begin (head)
- queue_iterator end() const; ///< Access queue past-the-end (tail)
- Packet peek() const; ///< Return head element from the queue
-
size_type queueSize() const; ///< Return number of elements in the queue
bool empty() const; ///< Return queueSize() == 0
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_;
+ Packet const * fastPacket_;
+ Packet slowPacket_;
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
using mixin::operator(); \
using mixin::TypedConnector_ ## dir ; \
private: \
- virtual std::type_info const & packetTypeID() \
+ virtual std::type_info const & v_packetTypeId() \
{ return typeid(typename PacketType::type); } \
friend class detail::Typed ## dir ## Mixin<pType ## dir <PacketType>, PacketType>; \
}; \
#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