X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=PPI%2FRoute.hh;h=fb2930597f6d1f3d5a97950067d8c2c684aa5c22;hb=5443435c4c2b6e4386c5334b5b8358273f2bae93;hp=54c41396d2499c58001259565d05103ec68a847e;hpb=81ffa1c459b96dd44472bcef37e1e373934ee138;p=senf.git

diff --git a/PPI/Route.hh b/PPI/Route.hh
index 54c4139..fb29305 100644
--- a/PPI/Route.hh
+++ b/PPI/Route.hh
@@ -1,6 +1,8 @@
-// Copyright (C) 2007 
-// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
-// Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
+// $Id$
+//
+// 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
@@ -21,8 +23,8 @@
 /** \file
     \brief Route public header */
 
-#ifndef HH_Route_
-#define HH_Route_ 1
+#ifndef HH_SENF_PPI_Route_
+#define HH_SENF_PPI_Route_ 1
 
 // Custom includes
 #include <boost/type_traits.hpp>
@@ -34,9 +36,45 @@
 namespace senf {
 namespace ppi {
 
+    /** \brief Routing base class
+
+        Routing information is defined within each module to define the control flow. RouteBase is
+        the generic base class for all routing entries.
+     */
     class RouteBase
     {
     public:
+        virtual ~RouteBase();
+
+#ifdef DOXYGEN
+        Source & source() const;        ///< Routing source
+                                        /**< \note The real implementation is in the \c
+                                             BaseRouteImplementation template in \c Route.ih. This
+                                             class is internal and not documented. */
+        Target & target() const;        ///< Routing target
+                                        /**< \note The real implementation is in the \c
+                                             BaseRouteImplementation template in \c Route.ih. This
+                                             class is internal and not documented. */
+#endif
+
+    protected:
+        RouteBase(module::Module & module);
+
+    private:
+        module::Module * module_;
+    };
+
+    /** \brief Forwarding route base class
+
+        All routes which may forward control information are based on
+        ForwardingRoute. ForwardingRoute provides methods to control and query the throttling
+        behavior.
+     */
+    class ForwardingRoute
+        : public RouteBase
+    {
+    public:
+        bool autoThrottling() const;    ///< Query current autoThrottling state
         void autoThrottling(bool state); ///< Change automatic throttle notification forwarding
                                         /**< By default, throttle notifications are automatically
                                              forwarded from active to passive connectors. This may
@@ -50,23 +88,40 @@ namespace ppi {
                                              disable the event whenever a throttling notification
                                              comes in. Respective for unthrottle notifications.
 
-                                             \param[in] state New throttle forwarding state 
-
-                                             \implementation This class will be implemented using a
-                                                 baseclass, this template and several
-                                                 specializations. However, this is an implementation
-                                                 detail which does not affect the exposed
-                                                 interface. */
+                                             \param[in] state New throttle forwarding state */
 
+        bool throttled() const;         ///< \c true, if the route is throttled
+                                        /**< This member checks only the automatic throttling
+                                             state. If autoThrottling() is \c false, this member
+                                             will always return \c false. */
+        
     protected:
-        RouteBase(module::Module & module);
+        ForwardingRoute(module::Module & module);
+
+        // Called to register this route with the connectors forwarding information base
+        template <class T> void registerRoute(T & ob);
+
+        template <class T> void notifyThrottle(T & ob);
+        template <class T> void notifyUnthrottle(T & ob);
 
     private:
-        module::Module * module_;
+        // called to forward a throttling notification along the route
+        void notifyThrottle();
+        void notifyUnthrottle();
+
+        // Implemented in the derived classes to forward throttling notifications
+        virtual void v_notifyThrottle() = 0;
+        virtual void v_notifyUnthrottle() = 0;
+        virtual bool v_throttled() const = 0;
+
+        bool autoThrottling_;
+
+        friend class connector::ActiveConnector;
     };
 
 }}
 
+// We need detail::RouteImplementation here ...
 #include "Route.ih"
 
 namespace senf {
@@ -76,16 +131,24 @@ namespace ppi {
         
         Route instances are created by Module::route statements. The Route class provides an
         interface to manipulate the flow processing.
+
+        Depending on the type of route, one of the following classes will be a baseclass:
+
+        <dl> <dt>ForwardingRoute</dt><dd>If the route is a \e forwarding route. This is a route
+        which forwards throttling notifications. This is the case, if one of the route endpoints is
+        a notify source (a connector::ActiveConnector) and the other is a
+        notify target (a connector::PassiveConnector or an EventDescriptor).
+
+        <dt>RouteBase</dt><dd>If the route is not a forwarding route, it is based directly on the
+        generic route base class</dd></dl>
      */
     template <class Source, class Target>
     class Route
-        : public detail::RouteImplementation< boost::is_base_of<EventDescriptor,Source>::value,
-                                              boost::is_base_of<EventDescriptor,Target>::value >
+        : public detail::RouteImplementation<Source,Target>
     {
     private:
-        typedef detail::RouteImplementation< 
-            boost::is_base_of<EventDescriptor,Source>::value,
-            boost::is_base_of<EventDescriptor,Target>::value > Implementation;
+        typedef detail::RouteImplementation<Source,Target> Base;
+        typedef detail::RouteImplementation<Source,Target> Implementation;
         
         Route(module::Module & module, Source & source, Target & target);
 
@@ -96,7 +159,7 @@ namespace ppi {
 
 ///////////////////////////////hh.e////////////////////////////////////////
 #include "Route.cci"
-//#include "Route.ct"
+#include "Route.ct"
 #include "Route.cti"
 #endif