4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
6 // Stefan Bund <g0dil@berlios.de>
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 2 of the License, or
11 // (at your option) any later version.
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the
20 // Free Software Foundation, Inc.,
21 // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 \brief Route internal header */
26 #ifndef IH_SENF_PPI_Route_
27 #define IH_SENF_PPI_Route_ 1
30 #include <boost/type_traits/is_convertible.hpp>
31 #include <boost/type_traits/is_base_of.hpp>
32 #include <boost/mpl/if.hpp>
33 #include <boost/mpl/bool.hpp>
34 #include <boost/static_assert.hpp>
36 ///////////////////////////////ih.p////////////////////////////////////////
44 // This is the RoutingTraits implementation for Connectors. Events are handled in the
45 // specialization below
46 template <class Connector, bool isEvent>
47 struct RoutingTraitsImplementation
49 BOOST_STATIC_ASSERT((boost::is_base_of<connector::Connector, Connector>::value));
51 static bool const event = false;
53 static bool const notifySource = boost::is_base_of<
54 connector::ActiveConnector, Connector>::value;
55 static bool const notifyTarget = boost::is_base_of<
56 connector::PassiveConnector, Connector>::value;
58 static bool const dataSource = boost::is_base_of<
59 connector::InputConnector, Connector>::value;
60 static bool const dataTarget = boost::is_base_of<
61 connector::OutputConnector, Connector>::value;
63 typedef Connector type;
66 // RoutingTraits specialization for Event types. Events may be both dataSource or dataTarget but
67 // cannot be notifySource.
68 template <class Event>
69 struct RoutingTraitsImplementation<Event,true>
71 static bool const event = true;
73 static bool const notifySource = false;
74 static bool const notifyTarget = true;
76 static bool const dataSource = true;
77 static bool const dataTarget = true;
79 typedef EventDescriptor type;
82 // The RoutingTraits give routing related information about the argument type:
83 // - Wether the type is a notifySource or notifyTarget
84 // - Wether the type is dataSource or dataTarget
85 // - Provide the generalized target type
87 // The real implementation is in RoutingTraitsImplementation which is appropriately specialized
89 template <class Object>
91 : public RoutingTraitsImplementation<Object,
92 boost::is_convertible<Object*,
93 EventDescriptor*>::value>
96 // This is the generic route implementation for all routes. It just provides access to the
98 template <class Source, class Target, class Base>
99 class BaseRouteImplementation
103 typedef Source source_type;
104 typedef Target target_type;
106 Source & source() const;
107 Target & target() const;
110 BaseRouteImplementation(module::Module & module, Source & source, Target & target);
113 bool v_hasConnector(connector::Connector const & conn) const;
114 bool v_hasEvent(EventDescriptor const & event) const;
116 bool isSame(connector::Connector const & conn, connector::Connector const & other) const;
117 bool isSame(connector::Connector const & conn, EventDescriptor const & other) const;
118 bool isSame(EventDescriptor const & event, connector::Connector const & other) const;
119 bool isSame(EventDescriptor const & event, EventDescriptor const & other) const;
125 // The ForwardingRouteImplementation is based on the same BaseRouteImplementation
126 // as non-forwarding routes are but injects a different base-class (the third template
127 // argument to BaseRouteImplementation). ForwardingRouteImplementation has two additional
129 // 1) Register the ForwardingRoute with the notifySource
130 // 2) Implement the abstract ForwardingRoute interface
132 // Since we don't know explicitly, which of Source or Target is the notifySource or
133 // notifyTarget, the implementation calls registerRoute and notifyThrottle/notifyUnthrottle on
134 // *both*, the source and target, however qualified with an additional argument of type
135 // boost::mpl::bool_ which is used to select the correct overloads, of which the 'false'
136 // overload always is a no-op. This way, only the correct call will generate any code, the
137 // disabled call will be optimized away.
138 template <class Source, class Target>
139 class ForwardingRouteImplementation
140 : public BaseRouteImplementation<Source, Target, ForwardingRoute>
142 typedef BaseRouteImplementation<Source, Target, ForwardingRoute> Base;
145 ForwardingRouteImplementation(module::Module & module, Source & source, Target & target);
146 ~ForwardingRouteImplementation();
149 // send a throttle/unthrottle notification only if the second argument is a 'true' type
150 template <class T> void notifyThrottle(T & ob, boost::mpl::bool_<true> const &);
151 template <class T> void notifyThrottle(T & ob, boost::mpl::bool_<false> const &);
152 template <class T> void notifyUnthrottle(T & ob, boost::mpl::bool_<true> const &);
153 template <class T> void notifyUnthrottle(T & ob, boost::mpl::bool_<false> const &);
155 template <class T> bool throttled(T & ob, boost::mpl::bool_<true> const &) const;
156 template <class T> bool throttled(T & ob, boost::mpl::bool_<false> const &) const;
158 virtual void v_notifyThrottle();
159 virtual void v_notifyUnthrottle();
160 virtual bool v_throttled() const;
163 // This helper class finds the base-class suitable for a specific route. Routes are classified
165 // 1) A forwarding routes is a routed which forwards notifications from a notifySource to a
166 // notifyTarget. Forwarding routes are implemneted using ForwardingRouteImplementation
167 // 2) Non-forwarding routes don't forward notifications. They are implemented directly
168 // using BaseRouteImplementation
169 template <class Source, class Target>
170 struct RouteImplementationBase
172 typedef RoutingTraits<Source> srcTrait;
173 typedef RoutingTraits<Target> trgTrait;
175 static bool const isForwarding = (srcTrait::notifySource && trgTrait::notifyTarget)
176 || (srcTrait::notifyTarget && trgTrait::notifySource);
178 typedef typename boost::mpl::if_c<
180 ForwardingRouteImplementation<Source,Target>,
181 BaseRouteImplementation<Source,Target,RouteBase> >::type base;
184 // RouteImplementation2 has two purposes:
185 // 1) Ensure, that routing is always from a data source to a data target
186 // 2) To find the correct base-class. This is delegated to RouteImplementationBase
187 template <class Source, class Target>
188 class RouteImplementation2
189 : public RouteImplementationBase<Source,Target>::base
191 typedef typename RouteImplementationBase<Source,Target>::base Base;
193 BOOST_STATIC_ASSERT( RoutingTraits<Source>::dataSource &&
194 RoutingTraits<Target>::dataTarget );
197 RouteImplementation2(module::Module & module, Source & source, Target & target);
200 // RouteImplementation just forwards to RouteImplementation2 replacing the template arguments
201 // with the appropriately generalized type: If either Source or Target is an Event type, it is
202 // replaced with the general Event base-class EventDescriptor. Connector types are left as is.
203 template <class Source, class Target>
204 class RouteImplementation
205 : public RouteImplementation2<typename RoutingTraits<Source>::type,
206 typename RoutingTraits<Target>::type>
208 typedef RouteImplementation2<typename RoutingTraits<Source>::type,
209 typename RoutingTraits<Target>::type> Base;
212 RouteImplementation(module::Module & module, Source & source, Target & target);
219 ///////////////////////////////ih.e////////////////////////////////////////
226 // comment-column: 40
227 // c-file-style: "senf"
228 // indent-tabs-mode: nil
229 // ispell-local-dictionary: "american"
230 // compile-command: "scons -u test"