//
// 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 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();
-
- virtual void v_disconnected() const;
void setModule(module::Module & module);
: 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
projects / senf.git / blobdiff