Remove scheduler

src/tests/boost_graph/graph_manager.hpp

@@ -28,7 +28,7 @@
 #define __TESTS_BOOST_GRAPH_GRAPH_MANAGER_HPP 1
 
 #include <paradevs/common/scheduler/HeapScheduler.hpp>
-#include <paradevs/common/scheduler/VectorScheduler.hpp>
+// #include <paradevs/common/scheduler/VectorScheduler.hpp>
 
 #include <paradevs/kernel/pdevs/Coordinator.hpp>
 #include <paradevs/kernel/pdevs/GraphManager.hpp>
@@ -41,28 +41,28 @@
 
 namespace paradevs { namespace tests { namespace boost_graph {
 
-struct SchedulerHandle;
+// struct SchedulerHandle;
 
-typedef typename paradevs::common::scheduler::HeapScheduler <
-    common::DoubleTime, SchedulerHandle >::type SchedulerType;
+// typedef typename paradevs::common::scheduler::HeapScheduler <
+//     common::DoubleTime, SchedulerHandle >::type SchedulerType;
 
-struct SchedulerHandle
-{
-    SchedulerHandle()
-    { }
+// struct SchedulerHandle
+// {
+//     SchedulerHandle()
+//     { }
 
-    SchedulerHandle(const SchedulerType::handle_type& handle)
-        : _handle(handle)
-    { }
+//     SchedulerHandle(const SchedulerType::handle_type& handle)
+//         : _handle(handle)
+//     { }
 
-    const SchedulerHandle& handle() const
-    { return *this; }
+//     const SchedulerHandle& handle() const
+//     { return *this; }
 
-    void handle(const SchedulerHandle& handle)
-    { _handle = handle._handle; }
+//     void handle(const SchedulerHandle& handle)
+//     { _handle = handle._handle; }
 
-    SchedulerType::handle_type _handle;
-};
+//     SchedulerType::handle_type _handle;
+// };
 
 struct GraphParameters
 {
@@ -77,18 +77,15 @@ struct GraphParameters
     { }
 };
 
-template < class SchedulerHandle, class Parameters >
+template < class Parameters >
 class FlatGraphManager :
         public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               SchedulerHandle,
                                                Parameters >
 {
 public:
-    FlatGraphManager(common::Coordinator < common::DoubleTime,
-                                           SchedulerHandle >* coordinator,
+    FlatGraphManager(common::Coordinator < common::DoubleTime >* coordinator,
         const Parameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime, SchedulerHandle,
-                                        Parameters >(
+        paradevs::pdevs::GraphManager < common::DoubleTime, Parameters >(
             coordinator, parameters)
     { }
 
@@ -119,11 +116,10 @@ public:
             case TOP_PIXEL:
                 _top_simulators[g[*vertexIt]._index] =
                     new pdevs::Simulator <
-                        common::DoubleTime, TopPixel < SchedulerHandle >,
-                        SchedulerHandle,
+                        common::DoubleTime, TopPixel,
                         TopPixelParameters >(ss.str(), TopPixelParameters());
                 _top_simulators[g[*vertexIt]._index]->add_out_port("out");
-                FlatGraphManager < SchedulerHandle, Parameters >::add_child(
+                FlatGraphManager < Parameters >::add_child(
                     _top_simulators[g[*vertexIt]._index]);
                 break;
             case NORMAL_PIXEL:
@@ -151,12 +147,12 @@ public:
                 }
                 _normal_simulators[g[*vertexIt]._index] =
                     new pdevs::Simulator <
-                        common::DoubleTime, NormalPixel < SchedulerHandle >,
-                        SchedulerHandle, NormalPixelParameters >(
+                        common::DoubleTime, NormalPixel,
+                        NormalPixelParameters >(
                             ss.str(), NormalPixelParameters(n));
                 _normal_simulators[g[*vertexIt]._index]->add_in_port("in");
                 _normal_simulators[g[*vertexIt]._index]->add_out_port("out");
-                FlatGraphManager < SchedulerHandle, Parameters >::add_child(
+                FlatGraphManager < Parameters >::add_child(
                     _normal_simulators[g[*vertexIt]._index]);
                 break;
             };
@@ -170,10 +166,8 @@ public:
             boost::tie(neighbourIt, neighbourEnd) =
                 boost::adjacent_vertices(*vertexIt, g);
             for (; neighbourIt != neighbourEnd; ++neighbourIt) {
-                paradevs::common::Model < common::DoubleTime,
-                                          SchedulerHandle >* a = 0;
-                paradevs::common::Model < common::DoubleTime,
-                                          SchedulerHandle >* b = 0;
+                paradevs::common::Model < common::DoubleTime >* a = 0;
+                paradevs::common::Model < common::DoubleTime >* b = 0;
 
                 if (g[*vertexIt]._type == TOP_PIXEL) {
                     a = _top_simulators[g[*vertexIt]._index];
@@ -185,8 +179,7 @@ public:
                 } else {
                     b = _normal_simulators[g[*neighbourIt]._index];
                 }
-                FlatGraphManager < SchedulerHandle,
-                                   Parameters >::add_link(a, "out",
+                FlatGraphManager < Parameters >::add_link(a, "out",
                                                           b, "in");
             }
         }
@@ -195,32 +188,28 @@ public:
 protected:
     typedef std::map < int, pdevs::Simulator <
                                 common::DoubleTime,
-                                TopPixel < SchedulerHandle >,
-                                SchedulerHandle,
+                                TopPixel,
                                 TopPixelParameters >* > TopSimulators;
     typedef std::map < int, pdevs::Simulator <
                                 common::DoubleTime,
-                                NormalPixel < SchedulerHandle >,
-                                SchedulerHandle,
+                                NormalPixel,
                                 NormalPixelParameters >* > NormalSimulators;
 
     TopSimulators    _top_simulators;
     NormalSimulators _normal_simulators;
 };
 
-template < class SchedulerHandle >
 class BuiltFlatGraphManager :
-        public FlatGraphManager < SchedulerHandle, GraphParameters >
+        public FlatGraphManager < GraphParameters >
 {
 public:
     BuiltFlatGraphManager(
-        common::Coordinator < common::DoubleTime,
-                              SchedulerHandle >* coordinator,
+        common::Coordinator < common::DoubleTime >* coordinator,
         const GraphParameters& parameters) :
-        FlatGraphManager < SchedulerHandle, GraphParameters >(
+        FlatGraphManager < GraphParameters >(
             coordinator, parameters)
     {
-        BuiltFlatGraphManager < SchedulerHandle >::build_flat_graph(
+        BuiltFlatGraphManager::build_flat_graph(
             parameters._graph, parameters._input_edges);
         // input
 
@@ -234,10 +223,9 @@ public:
             if (not coordinator->exist_in_port(ss_in.str())) {
                 coordinator->add_in_port(ss_in.str());
             }
-            BuiltFlatGraphManager < SchedulerHandle>::add_link(
+            BuiltFlatGraphManager::add_link(
                 coordinator, ss_in.str(),
-                BuiltFlatGraphManager <
-                    SchedulerHandle >::_normal_simulators[it->second], "in");
+                BuiltFlatGraphManager::_normal_simulators[it->second], "in");
 
             // std::cout << "link = " << coordinator->get_name()
             //           << "::" << ss_in.str() << " -> "
@@ -259,17 +247,13 @@ public:
                 coordinator->add_out_port(ss_out.str());
             }
 
-            if (BuiltFlatGraphManager <
-                    SchedulerHandle >::_normal_simulators.find(it->first) !=
-                BuiltFlatGraphManager <
-                    SchedulerHandle >::_normal_simulators.end()) {
-                if (not BuiltFlatGraphManager < SchedulerHandle>::exist_link(
-                        BuiltFlatGraphManager <
-                            SchedulerHandle >::_normal_simulators[it->first],
+            if (BuiltFlatGraphManager::_normal_simulators.find(it->first) !=
+                BuiltFlatGraphManager::_normal_simulators.end()) {
+                if (not BuiltFlatGraphManager::exist_link(
+                        BuiltFlatGraphManager::_normal_simulators[it->first],
                         "out", coordinator, ss_out.str())) {
-                    BuiltFlatGraphManager < SchedulerHandle>::add_link(
-                        BuiltFlatGraphManager <
-                            SchedulerHandle >::_normal_simulators[it->first],
+                    BuiltFlatGraphManager::add_link(
+                        BuiltFlatGraphManager::_normal_simulators[it->first],
                         "out", coordinator, ss_out.str());
 
                     // std::cout << "link = " << BuiltFlatGraphManager <
@@ -280,13 +264,11 @@ public:
                     //           << std::endl;
                 }
             } else {
-                if (not BuiltFlatGraphManager < SchedulerHandle>::exist_link(
-                        BuiltFlatGraphManager <
-                            SchedulerHandle >::_top_simulators[it->first],
+                if (not BuiltFlatGraphManager::exist_link(
+                        BuiltFlatGraphManager::_top_simulators[it->first],
                         "out", coordinator, ss_out.str())) {
-                    BuiltFlatGraphManager < SchedulerHandle>::add_link(
-                        BuiltFlatGraphManager <
-                            SchedulerHandle >::_top_simulators[it->first],
+                    BuiltFlatGraphManager::add_link(
+                        BuiltFlatGraphManager::_top_simulators[it->first],
                         "out", coordinator, ss_out.str());
 
                     // std::cout << "link = " << BuiltFlatGraphManager <
@@ -305,19 +287,17 @@ public:
     { }
 };
 
-template < class SchedulerHandle >
 class ParallelBuiltFlatGraphManager :
-        public FlatGraphManager < SchedulerHandle, GraphParameters >
+        public FlatGraphManager < GraphParameters >
 {
 public:
     ParallelBuiltFlatGraphManager(
-        common::Coordinator < common::DoubleTime,
-                              SchedulerHandle >* coordinator,
+        common::Coordinator < common::DoubleTime >* coordinator,
         const GraphParameters& parameters) :
-        FlatGraphManager < SchedulerHandle, GraphParameters >(
+        FlatGraphManager < GraphParameters >(
             coordinator, parameters)
     {
-        ParallelBuiltFlatGraphManager < SchedulerHandle >::build_flat_graph(
+        ParallelBuiltFlatGraphManager::build_flat_graph(
             parameters._graph, parameters._input_edges);
         // input
         for (Edges::const_iterator it = parameters._input_edges.begin();
@@ -328,10 +308,10 @@ public:
             if (not coordinator->exist_in_port(ss_in.str())) {
                 coordinator->add_in_port(ss_in.str());
             }
-            ParallelBuiltFlatGraphManager < SchedulerHandle>::add_link(
+            ParallelBuiltFlatGraphManager::add_link(
                 coordinator, ss_in.str(),
-                ParallelBuiltFlatGraphManager <
-                    SchedulerHandle >::_normal_simulators[it->second], "in");
+                ParallelBuiltFlatGraphManager::_normal_simulators[it->second],
+                "in");
         }
         // output
         for (Edges::const_iterator it = parameters._output_edges.begin();
@@ -342,13 +322,12 @@ public:
             if (not coordinator->exist_out_port(ss_out.str())) {
                 coordinator->add_out_port(ss_out.str());
             }
-            if (not ParallelBuiltFlatGraphManager < SchedulerHandle >::exist_link(
-                ParallelBuiltFlatGraphManager <
-                    SchedulerHandle >::_normal_simulators[it->first], "out",
+            if (not ParallelBuiltFlatGraphManager::exist_link(
+                ParallelBuiltFlatGraphManager::_normal_simulators[it->first],
+                "out",
                 coordinator, ss_out.str())) {
-                ParallelBuiltFlatGraphManager < SchedulerHandle>::add_link(
-                    ParallelBuiltFlatGraphManager <
-                        SchedulerHandle >::_normal_simulators[it->first], "out",
+                ParallelBuiltFlatGraphManager::add_link(
+                    ParallelBuiltFlatGraphManager::_normal_simulators[it->first], "out",
                     coordinator, ss_out.str());
             }
         }
@@ -361,8 +340,7 @@ public:
     { }
 
     void transition(
-        const common::Models < common::DoubleTime,
-                               SchedulerHandle >& /* receivers */,
+        const common::Models < common::DoubleTime >& /* receivers */,
         common::DoubleTime::type /* t */)
     { }
 
@@ -370,17 +348,15 @@ public:
     { }
 };
 
-template < class SchedulerHandle, class GraphBuilder >
+template < class GraphBuilder >
 class InBuildFlatGraphManager :
-        public FlatGraphManager < SchedulerHandle,
-                                  paradevs::common::NoParameters >
+        public FlatGraphManager < paradevs::common::NoParameters >
 {
 public:
     InBuildFlatGraphManager(
-        common::Coordinator < common::DoubleTime,
-                              SchedulerHandle >* coordinator,
+        common::Coordinator < common::DoubleTime >* coordinator,
         const paradevs::common::NoParameters& parameters) :
-        FlatGraphManager < SchedulerHandle, paradevs::common::NoParameters >(
+        FlatGraphManager < paradevs::common::NoParameters >(
             coordinator, parameters)
     {
         GraphBuilder   builder;
@@ -390,8 +366,7 @@ public:
         Connections    parent_connections;
 
         builder.build(graphs, input_edges, output_edges, parent_connections);
-        InBuildFlatGraphManager < SchedulerHandle,
-                                  GraphBuilder >::build_flat_graph(
+        InBuildFlatGraphManager < GraphBuilder >::build_flat_graph(
                                       graphs.front(), InputEdges());
     }
 
@@ -417,18 +392,16 @@ struct PartitioningParameters
     { }
 };
 
-template < class SchedulerHandle, class GraphBuilder >
+template < class GraphBuilder >
 class HeapHierarchicalGraphManager :
         public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               SchedulerHandle,
                                                PartitioningParameters >
 {
 public:
     HeapHierarchicalGraphManager(
-        common::Coordinator < common::DoubleTime,
-                              SchedulerHandle >* coordinator,
+        common::Coordinator < common::DoubleTime >* coordinator,
         const PartitioningParameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime, SchedulerHandle,
+        paradevs::pdevs::GraphManager < common::DoubleTime,
                                         PartitioningParameters >(
                                             coordinator, parameters)
     {
@@ -446,7 +419,7 @@ public:
                             parent_connections);
 
         // build coordinators (graphs)
-        //boost::timer t; 
+        //boost::timer t;
 
         for (unsigned int i = 0; i < graphs.size(); ++i) {
             Coordinator* coordinator = 0;
@@ -458,8 +431,7 @@ public:
                                 GraphParameters(graphs[i], input_edges[i],
                                                 output_edges[i]));
             _coordinators.push_back(coordinator);
-            HeapHierarchicalGraphManager < SchedulerHandle,
-                                           GraphBuilder >::add_child(
+            HeapHierarchicalGraphManager < GraphBuilder >::add_child(
                                                coordinator);
 
         }
@@ -477,7 +449,7 @@ public:
             ss_in << "in_" << connection.first.second;
 
             if (not HeapHierarchicalGraphManager <
-                    SchedulerHandle, GraphBuilder >::exist_link(
+                    GraphBuilder >::exist_link(
                         _coordinators[connection.first.first - 1],
                         ss_out.str(),
                         _coordinators[connection.second.first - 1],
@@ -492,7 +464,7 @@ public:
                 //           << "::" << ss_in.str() << std::endl;
 
                 HeapHierarchicalGraphManager <
-                    SchedulerHandle, GraphBuilder >::add_link(
+                    GraphBuilder >::add_link(
                         _coordinators[connection.first.first - 1],
                         ss_out.str(),
                         _coordinators[connection.second.first - 1],
@@ -514,9 +486,7 @@ public:
 private:
     typedef paradevs::pdevs::Coordinator <
         common::DoubleTime,
-        SchedulerType,
-        SchedulerHandle,
-        BuiltFlatGraphManager < SchedulerHandle >,
+        BuiltFlatGraphManager,
         common::NoParameters,
         GraphParameters > Coordinator;
     typedef std::vector < Coordinator* > Coordinators;
@@ -524,111 +494,16 @@ private:
     Coordinators _coordinators;
 };
 
-template < class SchedulerHandle, class GraphBuilder >
-class VectorHierarchicalGraphManager :
-        public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               SchedulerHandle,
-                                               PartitioningParameters >
-{
-public:
-    VectorHierarchicalGraphManager(
-        common::Coordinator < common::DoubleTime,
-                              SchedulerHandle >* coordinator,
-        const PartitioningParameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime, SchedulerHandle,
-                                        PartitioningParameters >(
-                                            coordinator, parameters)
-    {
-        GraphBuilder   graph_builder(parameters.cluster_number,
-                                     parameters.partitioning_method_name,
-                                     parameters.contraction_coef,
-                                     parameters.contraction_coef_flag,
-                                     parameters.generator);
-        OrientedGraphs graphs;
-        InputEdgeList  input_edges;
-        OutputEdgeList output_edges;
-        Connections    parent_connections;
-
-        graph_builder.build(graphs, input_edges, output_edges,
-                            parent_connections);
-
-        // build coordinators (graphs)
-        for (unsigned int i = 0; i < graphs.size(); ++i) {
-            Coordinator* coordinator = 0;
-            std::ostringstream ss;
-
-            ss << "S" << i;
-            coordinator =
-                new Coordinator(ss.str(), paradevs::common::NoParameters(),
-                                GraphParameters(graphs[i], input_edges[i],
-                                                output_edges[i]));
-            _coordinators.push_back(coordinator);
-            VectorHierarchicalGraphManager < SchedulerHandle,
-                                             GraphBuilder >::add_child(
-                                                 coordinator);
-
-        }
-
-        // builds internal connections (edges)
-        for (Connections::const_iterator it = parent_connections.begin();
-             it != parent_connections.end(); ++it) {
-            const Connection& connection = *it;
-            std::ostringstream ss_out;
-            std::ostringstream ss_in;
-
-            ss_out << "out_" << connection.first.second;
-            ss_in << "in_" << connection.first.second;
-
-            if (not VectorHierarchicalGraphManager <
-                    SchedulerHandle, GraphBuilder >::exist_link(
-                        _coordinators[connection.first.first - 1],
-                        ss_out.str(),
-                        _coordinators[connection.second.first - 1],
-                        ss_in.str())) {
-                VectorHierarchicalGraphManager <
-                    SchedulerHandle, GraphBuilder >::add_link(
-                        _coordinators[connection.first.first - 1],
-                        ss_out.str(),
-                        _coordinators[connection.second.first - 1],
-                        ss_in.str());
-            }
-        }
-    }
-
-    virtual ~VectorHierarchicalGraphManager()
-    {
-        for (typename Coordinators::const_iterator it = _coordinators.begin();
-             it != _coordinators.end(); ++it) {
-            delete *it;
-        }
-    }
-
-private:
-    typedef paradevs::pdevs::Coordinator <
-    common::DoubleTime,
-    paradevs::common::scheduler::VectorScheduler <
-        paradevs::common::DoubleTime >,
-    paradevs::common::scheduler::NoSchedulerHandle,
-    BuiltFlatGraphManager < paradevs::common::scheduler::NoSchedulerHandle >,
-    common::NoParameters,
-    GraphParameters > Coordinator;
-    typedef std::vector < Coordinator* > Coordinators;
-
-    Coordinators _coordinators;
-};
-
-template < class SchedulerHandle, class GraphBuilder >
+template < class GraphBuilder >
 class ParallelHeapHierarchicalGraphManager :
         public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               SchedulerHandle,
                                                PartitioningParameters >
 {
 public:
     ParallelHeapHierarchicalGraphManager(
-        common::Coordinator < common::DoubleTime,
-                              SchedulerHandle >* coordinator,
+        common::Coordinator < common::DoubleTime >* coordinator,
         const PartitioningParameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime, SchedulerHandle,
+        paradevs::pdevs::GraphManager < common::DoubleTime,
                                         PartitioningParameters >(
                                             coordinator, parameters)
     {
@@ -658,9 +533,8 @@ public:
                                                         input_edges[i],
                                                         output_edges[i]));
             _coordinators.push_back(coordinator);
-            ParallelHeapHierarchicalGraphManager < SchedulerHandle,
-                                                   GraphBuilder >::add_child(
-                                                       coordinator);
+            ParallelHeapHierarchicalGraphManager < GraphBuilder >::add_child(
+                coordinator);
 
         }
 
@@ -675,13 +549,13 @@ public:
             ss_in << "in_" << connection.first.second;
 
             if (not ParallelHeapHierarchicalGraphManager <
-                    SchedulerHandle, GraphBuilder >::exist_link(
+                    GraphBuilder >::exist_link(
                         _coordinators[connection.first.first - 1],
                         ss_out.str(),
                         _coordinators[connection.second.first - 1],
                         ss_in.str())) {
                 ParallelHeapHierarchicalGraphManager <
-                    SchedulerHandle, GraphBuilder >::add_link(
+                    GraphBuilder >::add_link(
                         _coordinators[connection.first.first - 1],
                         ss_out.str(),
                         _coordinators[connection.second.first - 1],
@@ -705,15 +579,11 @@ public:
             (*it)->set_sender(
                 dynamic_cast < paradevs::pdevs::multithreading::Coordinator <
                     common::DoubleTime,
-                    SchedulerType,
-                    SchedulerHandle,
                     ParallelHeapHierarchicalGraphManager <
-                        SchedulerHandle,
                         PartitioningGraphBuilder >,
                     paradevs::common::NoParameters,
                     PartitioningParameters >*
-                >(ParallelHeapHierarchicalGraphManager < SchedulerHandle,
-                                                         GraphBuilder >::
+                >(ParallelHeapHierarchicalGraphManager < GraphBuilder >::
                   get_coordinator())->get_sender());
         }
     }
@@ -728,8 +598,7 @@ public:
         }
     }
 
-    void transition(const common::Models < common::DoubleTime,
-                    SchedulerHandle >& receivers,
+    void transition(const common::Models < common::DoubleTime >& receivers,
                     paradevs::common::DoubleTime::type t)
     {
         typename Coordinators::const_iterator it = _coordinators.begin();
@@ -751,10 +620,7 @@ public:
 private:
     typedef paradevs::pdevs::multithreading::Coordinator <
     common::DoubleTime,
-    SchedulerType,
-    SchedulerHandle,
-    ParallelBuiltFlatGraphManager
-    < SchedulerHandle >,
+    ParallelBuiltFlatGraphManager,
     common::NoParameters,
     GraphParameters > ParallelCoordinator;
 

src/tests/boost_graph/models.hpp

@@ -35,15 +35,13 @@ namespace paradevs { namespace tests { namespace boost_graph {
 struct TopPixelParameters
 { };
 
-template < class SchedulerHandle>
 class TopPixel :
-    public paradevs::pdevs::Dynamics < common::DoubleTime, SchedulerHandle,
-                                       TopPixelParameters >
+    public paradevs::pdevs::Dynamics < common::DoubleTime, TopPixelParameters >
 {
 public:
     TopPixel(const std::string& name,
              const TopPixelParameters& parameters) :
-        paradevs::pdevs::Dynamics < common::DoubleTime, SchedulerHandle,
+        paradevs::pdevs::Dynamics < common::DoubleTime,
                                     TopPixelParameters >(name, parameters),
         _value(0)
     { }
@@ -69,18 +67,17 @@ public:
         typename common::DoubleTime::type /* t */) const
     { return 1; }
 
-    virtual common::Bag < common::DoubleTime, SchedulerHandle > lambda(
+    virtual common::Bag < common::DoubleTime > lambda(
         typename common::DoubleTime::type /* t */) const
     {
 
         // std::cout << TopPixel < SchedulerHandle >::get_name() << " at "
         //           << t << ": lambda" << std::endl;
 
-        common::Bag < common::DoubleTime, SchedulerHandle > bag;
+        common::Bag < common::DoubleTime > bag;
 
-        bag.push_back(common::ExternalEvent <
-                          common::DoubleTime, SchedulerHandle >(
-                              "out", (void*)&_value));
+        bag.push_back(common::ExternalEvent < common::DoubleTime >(
+                          "out", (void*)&_value));
         return bag;
     }
 
@@ -96,15 +93,14 @@ struct NormalPixelParameters
     unsigned int _neighbour_number;
 };
 
-template < class SchedulerHandle>
 class NormalPixel :
-    public paradevs::pdevs::Dynamics < common::DoubleTime, SchedulerHandle,
+    public paradevs::pdevs::Dynamics < common::DoubleTime,
                                        NormalPixelParameters >
 {
 public:
     NormalPixel(const std::string& name,
              const NormalPixelParameters& parameters) :
-        paradevs::pdevs::Dynamics < common::DoubleTime, SchedulerHandle,
+        paradevs::pdevs::Dynamics < common::DoubleTime,
                                     NormalPixelParameters >(name, parameters),
         _neighbour_number(parameters._neighbour_number), _value(0)
     { }
@@ -127,16 +123,14 @@ public:
 
     virtual void dext(typename common::DoubleTime::type t,
                       typename common::DoubleTime::type /* e */,
-                      const common::Bag < common::DoubleTime,
-                                          SchedulerHandle >& bag)
+                      const common::Bag < common::DoubleTime >& bag)
     {
 
         // std::cout << NormalPixel < SchedulerHandle >::get_name() << " at "
         //           << t << ": dext -> "
         //           << bag.to_string() << std::endl;
 
-        for (typename common::Bag < common::DoubleTime,
-                                    SchedulerHandle >::const_iterator it =
+        for (typename common::Bag < common::DoubleTime >::const_iterator it =
                  bag.begin(); it != bag.end(); ++it) {
             if (it->on_port("in")) {
                 if (_last_time == t) {
@@ -183,19 +177,18 @@ public:
         }
     }
 
-    virtual common::Bag < common::DoubleTime, SchedulerHandle > lambda(
+    virtual common::Bag < common::DoubleTime > lambda(
         typename common::DoubleTime::type /* t */) const
     {
 
         // std::cout << NormalPixel < SchedulerHandle >::get_name() << " at "
         //           << t << ": lambda" << std::endl;
 
-        common::Bag < common::DoubleTime, SchedulerHandle > bag;
+        common::Bag < common::DoubleTime > bag;
 
         if (_phase == SEND) {
-            bag.push_back(common::ExternalEvent <
-                              common::DoubleTime, SchedulerHandle >(
-                                  "out", (void*)&_value));
+            bag.push_back(common::ExternalEvent < common::DoubleTime >(
+                              "out", (void*)&_value));
         }
         return bag;
     }

src/tests/boost_graph/tests.cpp

@@ -52,33 +52,29 @@ void flat_heap_test(double duration)
         DoubleTime,
         paradevs::pdevs::Coordinator <
             DoubleTime,
-            SchedulerType,
-            SchedulerHandle,
-            InBuildFlatGraphManager <
-                SchedulerHandle,
-                GraphBuilder > >
-    > rc(0, duration, "root");
+            InBuildFlatGraphManager < GraphBuilder > >
+        > rc(0, duration, "root");
 
     rc.run();
 }
 
-template < class GraphBuilder >
-void flat_vector_test(double duration)
-{
-    RootCoordinator <
-        DoubleTime,
-        paradevs::pdevs::Coordinator <
-            DoubleTime,
-            paradevs::common::scheduler::VectorScheduler <
-                paradevs::common::DoubleTime >,
-            paradevs::common::scheduler::NoSchedulerHandle,
-            InBuildFlatGraphManager <
-                paradevs::common::scheduler::NoSchedulerHandle,
-                GraphBuilder > >
-    > rc(0, duration, "root");
-
-    rc.run();
-}
+// template < class GraphBuilder >
+// void flat_vector_test(double duration)
+// {
+//     RootCoordinator <
+//         DoubleTime,
+//         paradevs::pdevs::Coordinator <
+//             DoubleTime,
+//             paradevs::common::scheduler::VectorScheduler <
+//                 paradevs::common::DoubleTime >,
+//             paradevs::common::scheduler::NoSchedulerHandle,
+//             InBuildFlatGraphManager <
+//                 paradevs::common::scheduler::NoSchedulerHandle,
+//                 GraphBuilder > >
+//     > rc(0, duration, "root");
+
+//     rc.run();
+// }
 
 /* partitionning models */
 
@@ -94,11 +90,7 @@ void partitionning_heap_test(double duration,
         DoubleTime,
         paradevs::pdevs::Coordinator <
             DoubleTime,
-            SchedulerType,
-            SchedulerHandle,
-            HeapHierarchicalGraphManager <
-                SchedulerHandle,
-                PartitioningGraphBuilder>,
+            HeapHierarchicalGraphManager < PartitioningGraphBuilder>,
             paradevs::common::NoParameters,
             PartitioningParameters >
         > rc(0, duration, "root", NoParameters(),
@@ -109,32 +101,32 @@ void partitionning_heap_test(double duration,
     rc.run();
 }
 
-template < class GraphGenerator >
-void partitionning_vector_test(double duration,
-                               int cluster_number,
-                               std::string partitioning_method_name,
-                               int contraction_coef,
-                               bool contraction_coef_flag,
-                               GraphGenerator& g)
-{
-    RootCoordinator <
-        DoubleTime,
-        paradevs::pdevs::Coordinator <
-            DoubleTime,
-            paradevs::common::scheduler::VectorScheduler <
-                paradevs::common::DoubleTime >,
-            paradevs::common::scheduler::NoSchedulerHandle,
-            VectorHierarchicalGraphManager <
-                paradevs::common::scheduler::NoSchedulerHandle,
-                PartitioningGraphBuilder >,
-            paradevs::common::NoParameters,
-            PartitioningParameters >
-        > rc(0, duration, "root", NoParameters(),
-             PartitioningParameters(cluster_number, partitioning_method_name,
-                                    contraction_coef, contraction_coef_flag, g));
-
-    rc.run();
-}
+// template < class GraphGenerator >
+// void partitionning_vector_test(double duration,
+//                                int cluster_number,
+//                                std::string partitioning_method_name,
+//                                int contraction_coef,
+//                                bool contraction_coef_flag,
+//                                GraphGenerator& g)
+// {
+//     RootCoordinator <
+//         DoubleTime,
+//         paradevs::pdevs::Coordinator <
+//             DoubleTime,
+//             paradevs::common::scheduler::VectorScheduler <
+//                 paradevs::common::DoubleTime >,
+//             paradevs::common::scheduler::NoSchedulerHandle,
+//             VectorHierarchicalGraphManager <
+//                 paradevs::common::scheduler::NoSchedulerHandle,
+//                 PartitioningGraphBuilder >,
+//             paradevs::common::NoParameters,
+//             PartitioningParameters >
+//         > rc(0, duration, "root", NoParameters(),
+//              PartitioningParameters(cluster_number, partitioning_method_name,
+//                                     contraction_coef, contraction_coef_flag, g));
+
+//     rc.run();
+// }
 
 /* iteration for partitionning methods */
 
@@ -148,7 +140,7 @@ void test(double duration, std::string partitioning_method_name,
 {
     boost::timer t;
 	int nbr_ite = 10;
-	
+
     log_file << "==== " << partitioning_method_name << " with ";
     if (contraction_coef_flag) {
         log_file << "/";
@@ -184,10 +176,10 @@ void test(double duration, std::string partitioning_method_name,
                 double t1 = t.elapsed();
 
                 for (unsigned int i = 0; i < nbr_ite; ++i) {
-                    partitionning_vector_test(duration, n,
-                                              partitioning_method_name,
-                                              contraction_coef,
-                                              contraction_coef_flag, g);
+                    // partitionning_vector_test(duration, n,
+                    //                           partitioning_method_name,
+                    //                           contraction_coef,
+                    //                           contraction_coef_flag, g);
                 }
 
                 double t2 = t.elapsed();
@@ -218,10 +210,10 @@ void test(double duration, std::string partitioning_method_name,
             double t1 = t.elapsed();
 
             for (unsigned int i = 0; i < nbr_ite; ++i) {
-                partitionning_vector_test(duration, contraction_coef,
-                                          partitioning_method_name,
-                                          contraction_coef,
-                                          contraction_coef_flag, g);
+                // partitionning_vector_test(duration, contraction_coef,
+                //                           partitioning_method_name,
+                //                           contraction_coef,
+                //                           contraction_coef_flag, g);
             }
 
             double t2 = t.elapsed();
@@ -253,7 +245,7 @@ void test_flat_38()
 
     log_file << "flat graph with vector = ";
     for (unsigned int i = 0; i < 20; ++i) {
-        flat_vector_test< FlatGraphBuilder >(duration_38);
+        // flat_vector_test< FlatGraphBuilder >(duration_38);
     }
 
     double t3 = t.elapsed();
@@ -318,7 +310,7 @@ void test_partitioning_random()
     std::vector < int > levels = {/*5,4,*/ 3, 2  };
     int nbr_sommets = 200;
     int sources = nbr_sommets/100*1;
-    
+
     RandomGraphGenerator g(nbr_sommets, levels, sources, 2, 3);
 
     /*test < RandomGraphGenerator >(duration_random, "gggp_pond", 2, 200, 2,
@@ -332,7 +324,7 @@ void test_partitioning_random()
     test < RandomGraphGenerator >(duration_random, "gggp_pond", 2, 50, 2,
                                   false, true, 60, true, g);*/
     test < RandomGraphGenerator >(duration_random, "gggp_pond", 2, 200, 2,
-                                  false, true, 1 , true, g);   
+                                  false, true, 1 , true, g);
    /* test < RandomGraphGenerator >(duration_random, "gggp_pond", 2, 32, 2,
                                   false, true, 100, true, g);
     test < RandomGraphGenerator >(duration_random, "gggp_pond", 2, 30, 2,
@@ -366,7 +358,7 @@ void test_partitioning_random()
     test < RandomGraphGenerator >(duration_random, "ggp", 2, 32, 2,
                                   false, true, 60, true, g);
     test < RandomGraphGenerator >(duration_random, "ggp", 2, 32, 2,
-                                  false, true, 80, true, g);   
+                                  false, true, 80, true, g);
     test < RandomGraphGenerator >(duration_random, "ggp", 2, 30, 2,
                                   false, true, 100, true, g);*/
 
@@ -441,14 +433,14 @@ void test_partitioning_random_grid()
 	const char *edge_weight;
 	edge_weight = "../../sortie_graphe/tests_grid.txt";
 	bool rec = false;
-        
+
     RandomGridGraphGenerator g(side, vertex_selection,  weight_vertex, edge_weight, rec);
 
     test < RandomGridGraphGenerator >(duration_random_grid, "gggp_pond", 2, 100, 2,
-                                  false, true, 80 , true, g); 
-                                  
+                                  false, true, 80 , true, g);
+
     test < RandomGridGraphGenerator >(duration_random_grid, "gggp_pond", 2, 100, 2,
-                                  false, true, 40 , true, g);   
+                                  false, true, 40 , true, g);
 
 
 }
@@ -499,13 +491,13 @@ void test_partitioning_random_linked()
     test < RandomLinkedGraphGenerator >(duration_random_linked, "gggp_pond", 2, 50, 2,
                                   false, true, 60, true, g);
     /*test < RandomLinkedGraphGenerator >(duration_random_linked, "gggp_pond", 2, 50, 2,
-                                  false, true, 80, true, g);   
+                                  false, true, 80, true, g);
     test < RandomLinkedGraphGenerator >(duration_random_linked, "gggp_pond", 2, 50, 2,
                                   false, true, 100, true, g);
     test < RandomLinkedGraphGenerator >(duration_random_linked, "gggp_pond", 2, 50, 2,
                                   false, true, 200, true, g);*/
-                                  
-    // ggp 
+
+    // ggp
     /*test < RandomLinkedGraphGenerator >(duration_random_linked, "ggp", 2, 50, 2,
                                   false, true, 5, true, g);
     test < RandomLinkedGraphGenerator >(duration_random_linked, "ggp", 2, 50, 2,
@@ -517,7 +509,7 @@ void test_partitioning_random_linked()
     test < RandomLinkedGraphGenerator >(duration_random_linked, "ggp", 2, 50, 2,
                                   false, true, 60, true, g);
     test < RandomLinkedGraphGenerator >(duration_random_linked, "ggp", 2, 50, 2,
-                                  false, true, 80, true, g);   
+                                  false, true, 80, true, g);
     test < RandomLinkedGraphGenerator >(duration_random_linked, "ggp", 2, 50, 2,
                                   false, true, 100, true, g);*/
 
@@ -543,7 +535,7 @@ void test_flat_corsen()
 
     log_file << "flat graph with vector = ";
     for (unsigned int i = 0; i < 20; ++i) {
-        flat_vector_test< CorsenFlatGraphBuilder >(corsen_duration);
+        // flat_vector_test< CorsenFlatGraphBuilder >(corsen_duration);
     }
 
     double t3 = t.elapsed();

src/tests/common/CMakeLists.txt

@@ -9,4 +9,4 @@ LINK_DIRECTORIES(
   ${GLIBMM_LIBRARY_DIRS}
   ${LIBXML_LIBRARY_DIR})
 
-ADD_SUBDIRECTORY(scheduler)
+#ADD_SUBDIRECTORY(scheduler)

src/tests/common/scheduler/tests.cpp

@@ -42,32 +42,31 @@ using namespace paradevs::pdevs;
 
 using namespace std::chrono;
 
-struct SchedulerHandle;
+// struct SchedulerHandle;
 
-typedef typename HeapScheduler < DoubleTime,
-                                 SchedulerHandle >::type SchedulerType;
+// typedef typename HeapScheduler < DoubleTime,
+//                                  SchedulerHandle >::type SchedulerType;
 
-struct SchedulerHandle
-{
-    SchedulerHandle()
-    { }
+// struct SchedulerHandle
+// {
+//     SchedulerHandle()
+//     { }
 
-    SchedulerHandle(const SchedulerType::handle_type& handle)
-        : _handle(handle)
-    { }
+//     SchedulerHandle(const SchedulerType::handle_type& handle)
+//         : _handle(handle)
+//     { }
 
-    const SchedulerHandle& handle() const
-    { return *this; }
+//     const SchedulerHandle& handle() const
+//     { return *this; }
 
-    void handle(const SchedulerHandle& handle)
-    { _handle = handle._handle; }
+//     void handle(const SchedulerHandle& handle)
+//     { _handle = handle._handle; }
 
-    SchedulerType::handle_type _handle;
-};
+//     SchedulerType::handle_type _handle;
+// };
 
-typedef Dynamics < DoubleTime, SchedulerHandle > MyDynamics;
-typedef paradevs::pdevs::Simulator < DoubleTime, MyDynamics,
-                                     SchedulerHandle > MySimulator;
+typedef Dynamics < DoubleTime > MyDynamics;
+typedef paradevs::pdevs::Simulator < DoubleTime, MyDynamics > MySimulator;
 typedef std::vector < MySimulator* > MySimulators;
 
 const int simulator_number = 5000;
@@ -77,7 +76,7 @@ const int sample_number = 20;
 double unit_test(unsigned int n)
 {
     MySimulators simulators;
-    HeapScheduler < DoubleTime, SchedulerHandle > scheduler;
+    HeapScheduler < DoubleTime > scheduler;
 
     for (unsigned int i = 0; i < simulator_number; ++i) {
         std::ostringstream ss;

src/tests/dtss/graph_manager.hpp

@@ -27,24 +27,22 @@
 #ifndef TESTS_DTSS_GRAPH_MANAGER_HPP
 #define TESTS_DTSS_GRAPH_MANAGER_HPP 1
 
+#include <tests/dtss/models.hpp>
+
 #include <paradevs/kernel/dtss/Coordinator.hpp>
 #include <paradevs/kernel/dtss/GraphManager.hpp>
 #include <paradevs/kernel/dtss/Simulator.hpp>
 
-#include <tests/dtss/models.hpp>
-
 namespace paradevs { namespace tests { namespace dtss {
 
-template < class SchedulerHandle >
 struct Policy
 {
-    const common::Bag < common::DoubleTime, SchedulerHandle >& bag() const
+    const common::Bag < common::DoubleTime >& bag() const
     { return _bag; }
 
     virtual void operator()(
         common::DoubleTime::type /* t */,
-        const common::ExternalEvent < common::DoubleTime,
-                                      SchedulerHandle >& event,
+        const common::ExternalEvent < common::DoubleTime >& event,
         common::DoubleTime::type /* tl */,
         common::DoubleTime::type /* tn */)
     {
@@ -53,65 +51,56 @@ struct Policy
     }
 
 private:
-    common::Bag < common::DoubleTime, SchedulerHandle > _bag;
+    common::Bag < common::DoubleTime > _bag;
 };
 
-template < class SchedulerHandle >
 class OnlyOneGraphManager :
         public paradevs::dtss::GraphManager < common::DoubleTime,
-                                              SchedulerHandle,
                                               paradevs::common::NoParameters >
 {
 public:
-    OnlyOneGraphManager(common::Coordinator < common::DoubleTime,
-                                              SchedulerHandle >* coordinator,
+    OnlyOneGraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                         const paradevs::common::NoParameters& parameters) :
-        paradevs::dtss::GraphManager < common::DoubleTime, SchedulerHandle,
+        paradevs::dtss::GraphManager < common::DoubleTime,
                                        paradevs::common::NoParameters >(
                                            coordinator, parameters),
-        a("a", 1, common::NoParameters())
+        a("a", 1., common::NoParameters())
     {
-        OnlyOneGraphManager < SchedulerHandle >::add_child(&a);
+        add_child(&a);
     }
 
     virtual ~OnlyOneGraphManager()
     { }
 
 private:
-    paradevs::dtss::Simulator < common::DoubleTime, A < SchedulerHandle >,
-                                SchedulerHandle > a;
+    paradevs::dtss::Simulator < common::DoubleTime, A > a;
 };
 
-template < class SchedulerHandle >
 class TwoGraphManager :
         public paradevs::dtss::GraphManager < common::DoubleTime,
-                                              SchedulerHandle,
                                               paradevs::common::NoParameters >
 {
 public:
-    TwoGraphManager(common::Coordinator < common::DoubleTime,
-                                          SchedulerHandle >* coordinator,
+    TwoGraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                     const paradevs::common::NoParameters& parameters) :
-        paradevs::dtss::GraphManager < common::DoubleTime, SchedulerHandle,
+        paradevs::dtss::GraphManager < common::DoubleTime,
                                        paradevs::common::NoParameters >(
                                            coordinator, parameters),
-        a("a", 1, common::NoParameters()), b("b", 1, common::NoParameters())
+        a("a", 1., common::NoParameters()), b("b", 1., common::NoParameters())
     {
-        TwoGraphManager < SchedulerHandle >::add_child(&a);
-        TwoGraphManager < SchedulerHandle >::add_child(&b);
+        add_child(&a);
+        add_child(&b);
         a.add_out_port("out");
         b.add_in_port("in");
-        TwoGraphManager < SchedulerHandle >::add_link(&a, "out", &b, "in");
+        add_link(&a, "out", &b, "in");
     }
 
     virtual ~TwoGraphManager()
     { }
 
 private:
-    paradevs::dtss::Simulator < common::DoubleTime, A < SchedulerHandle >,
-                                SchedulerHandle > a;
-    paradevs::dtss::Simulator < common::DoubleTime, B < SchedulerHandle >,
-                                SchedulerHandle > b;
+    paradevs::dtss::Simulator < common::DoubleTime, A > a;
+    paradevs::dtss::Simulator < common::DoubleTime, B > b;
 };
 
 } } } // namespace paradevs tests dtss

src/tests/dtss/models.hpp

@@ -27,21 +27,21 @@
 #ifndef TESTS_DTSS_MODELS_HPP
 #define TESTS_DTSS_MODELS_HPP 1
 
-#include <paradevs/kernel/dtss/Dynamics.hpp>
-
 #include <paradevs/common/time/DoubleTime.hpp>
+#include <paradevs/common/utils/Trace.hpp>
+
+#include <paradevs/kernel/dtss/Dynamics.hpp>
 
 namespace paradevs { namespace tests { namespace dtss {
 
-template < class SchedulerHandle>
 class A :
-        public paradevs::dtss::Dynamics < common::DoubleTime, SchedulerHandle,
+        public paradevs::dtss::Dynamics < common::DoubleTime,
                                           paradevs::common::NoParameters >
 {
 public:
     A(const std::string& name,
       const paradevs::common::NoParameters& parameters) :
-        paradevs::dtss::Dynamics < common::DoubleTime, SchedulerHandle,
+        paradevs::dtss::Dynamics < common::DoubleTime,
                                    paradevs::common::NoParameters >(name,
                                                                     parameters),
         _value(0)
@@ -49,8 +49,7 @@ public:
     virtual ~A()
     { }
 
-    void transition(const common::Bag < common::DoubleTime,
-                    SchedulerHandle >& /* x */,
+    void transition(const common::Bag < common::DoubleTime >& /* x */,
                     common::DoubleTime::type t)
     {
 
@@ -61,7 +60,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::DELTA_INT);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -78,7 +77,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::START);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -86,7 +85,7 @@ public:
         return 0;
     }
 
-    common::Bag < common::DoubleTime, SchedulerHandle > lambda(
+    common::Bag < common::DoubleTime > lambda(
         common::DoubleTime::type t) const
     {
 
@@ -94,16 +93,16 @@ public:
         (void)t;
 #endif
 
-        common::Bag < common::DoubleTime, SchedulerHandle > msgs;
+        common::Bag < common::DoubleTime > msgs;
 
         msgs.push_back(common::ExternalEvent <
-                           common::DoubleTime, SchedulerHandle >(
+                           common::DoubleTime >(
                                "out", (void*)&_value));
 
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::LAMBDA)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
@@ -116,15 +115,14 @@ private:
     double _value;
 };
 
-template < class SchedulerHandle>
 class B :
-        public paradevs::dtss::Dynamics < common::DoubleTime, SchedulerHandle,
+        public paradevs::dtss::Dynamics < common::DoubleTime,
                                           paradevs::common::NoParameters >
 {
 public:
     B(const std::string& name,
       const paradevs::common::NoParameters& parameters) :
-        paradevs::dtss::Dynamics < common::DoubleTime, SchedulerHandle,
+        paradevs::dtss::Dynamics < common::DoubleTime,
                                    paradevs::common::NoParameters >(name,
                                                                     parameters),
         _value(0)
@@ -132,8 +130,7 @@ public:
     virtual ~B()
     { }
 
-    void transition(const common::Bag < common::DoubleTime,
-                    SchedulerHandle >& x,
+    void transition(const common::Bag < common::DoubleTime >& x,
                     common::DoubleTime::type t)
     {
 
@@ -145,7 +142,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::DELTA_INT)
             << "x = " << x.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
@@ -162,7 +159,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::START);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -170,7 +167,7 @@ public:
         return 0;
     }
 
-    common::Bag < common::DoubleTime, SchedulerHandle > lambda(
+    common::Bag < common::DoubleTime > lambda(
         common::DoubleTime::type t) const
     {
 
@@ -178,17 +175,16 @@ public:
         (void)t;
 #endif
 
-        common::Bag < common::DoubleTime, SchedulerHandle > msgs;
+        common::Bag < common::DoubleTime > msgs;
 
         msgs.push_back(common::ExternalEvent <
-                           common::DoubleTime, SchedulerHandle >(
+                           common::DoubleTime >(
                                "out", (void*)&_value));
 
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B < SchedulerHandle >::get_name(), t,
-                common::LAMBDA)
+                get_name(), t, common::LAMBDA)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
 #endif

src/tests/dtss/tests.cpp

@@ -24,8 +24,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <paradevs/common/scheduler/SchedulerHandle.hpp>
-
 #include <tests/dtss/graph_manager.hpp>
 #include <tests/dtss/models.hpp>
 
@@ -43,10 +41,8 @@ TEST_CASE("dtss/only_one", "run")
     paradevs::common::RootCoordinator <
         DoubleTime, paradevs::dtss::Coordinator <
             DoubleTime,
-            Policy < paradevs::common::scheduler::NoSchedulerHandle >,
-            OnlyOneGraphManager <
-                paradevs::common::scheduler::NoSchedulerHandle >,
-            paradevs::common::scheduler::NoSchedulerHandle,
+            Policy,
+            OnlyOneGraphManager,
             paradevs::dtss::Parameters < DoubleTime > >
         > rc(0, 10, "root",
              paradevs::dtss::Parameters < DoubleTime >(1),
@@ -76,10 +72,8 @@ TEST_CASE("dtss/two", "run")
     paradevs::common::RootCoordinator <
         DoubleTime, paradevs::dtss::Coordinator <
             DoubleTime,
-            Policy < paradevs::common::scheduler::NoSchedulerHandle >,
-            TwoGraphManager <
-                paradevs::common::scheduler::NoSchedulerHandle >,
-            paradevs::common::scheduler::NoSchedulerHandle,
+            Policy,
+            TwoGraphManager,
             paradevs::dtss::Parameters < DoubleTime > >
         > rc(0, 10, "root",
              paradevs::dtss::Parameters < DoubleTime >(1),

src/tests/mixed/graph_manager.hpp

@@ -27,8 +27,7 @@
 #ifndef TESTS_MIXED_GRAPH_MANAGER_HPP
 #define TESTS_MIXED_GRAPH_MANAGER_HPP 1
 
-#include <paradevs/common/scheduler/VectorScheduler.hpp>
-#include <paradevs/common/scheduler/HeapScheduler.hpp>
+#include <tests/mixed/models.hpp>
 
 #include <paradevs/kernel/dtss/Coordinator.hpp>
 #include <paradevs/kernel/dtss/GraphManager.hpp>
@@ -38,43 +37,16 @@
 #include <paradevs/kernel/pdevs/GraphManager.hpp>
 #include <paradevs/kernel/pdevs/Simulator.hpp>
 
-#include <tests/mixed/models.hpp>
-
 namespace paradevs { namespace tests { namespace mixed {
 
-struct SchedulerHandle;
-
-typedef typename paradevs::common::scheduler::HeapScheduler <
-    common::DoubleTime, SchedulerHandle >::type SchedulerType;
-
-struct SchedulerHandle
-{
-    SchedulerHandle()
-    { }
-
-    SchedulerHandle(const SchedulerType::handle_type& handle)
-        : _handle(handle)
-    { }
-
-    const SchedulerHandle& handle() const
-    { return *this; }
-
-    void handle(const SchedulerHandle& handle)
-    { _handle = handle._handle; }
-
-    SchedulerType::handle_type _handle;
-};
-
-template < class SchedulerHandle >
 struct LastBagPolicy
 {
-    const common::Bag < common::DoubleTime, SchedulerHandle >& bag() const
+    const common::Bag < common::DoubleTime >& bag() const
     { return _bag; }
 
     virtual void operator()(
         typename common::DoubleTime::type /* t */,
-        const common::ExternalEvent < common::DoubleTime,
-                                      SchedulerHandle >& event,
+        const common::ExternalEvent < common::DoubleTime >& event,
         typename common::DoubleTime::type /* tl */,
         typename common::DoubleTime::type /* tn */)
     {
@@ -83,54 +55,48 @@ struct LastBagPolicy
     }
 
 private:
-    common::Bag < common::DoubleTime, SchedulerHandle > _bag;
+    common::Bag < common::DoubleTime > _bag;
 };
 
-template < class SchedulerHandle >
 struct IgnorePolicy
 {
-    const common::Bag < common::DoubleTime, SchedulerHandle >& bag() const
+    const common::Bag < common::DoubleTime >& bag() const
     { return _bag; }
 
     virtual void operator()(
         typename common::DoubleTime::type /* t */,
-        const common::ExternalEvent < common::DoubleTime,
-                                      SchedulerHandle >& /* event */,
+        const common::ExternalEvent < common::DoubleTime >& /* event */,
         typename common::DoubleTime::type /* tl */,
         typename common::DoubleTime::type /* tn */)
     { }
 
 private:
-    common::Bag < common::DoubleTime, SchedulerHandle > _bag;
+    common::Bag < common::DoubleTime > _bag;
 };
 
-template < class SchedulerHandle >
 class S1GraphManager :
-        public pdevs::GraphManager < common::DoubleTime, SchedulerHandle,
+        public pdevs::GraphManager < common::DoubleTime,
                                      paradevs::common::NoParameters >
 {
 public:
-    S1GraphManager(common::Coordinator < common::DoubleTime,
-                                         SchedulerHandle >* coordinator,
+    S1GraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                    const paradevs::common::NoParameters& parameters) :
-        pdevs::GraphManager < common::DoubleTime, SchedulerHandle,
+        pdevs::GraphManager < common::DoubleTime,
                               paradevs::common::NoParameters >(
                                   coordinator, parameters),
         a("a1", paradevs::common::NoParameters()),
         b("b1", paradevs::common::NoParameters())
     {
-        S1GraphManager < SchedulerHandle >::add_child(&a);
-        S1GraphManager < SchedulerHandle >::add_child(&b);
+        add_child(&a);
+        add_child(&b);
 
         a.add_out_port("out");
         b.add_in_port("in");
         b.add_out_port("out");
         coordinator->add_out_port("out");
 
-        S1GraphManager < SchedulerHandle >::add_link(&a, "out",
-                                                     &b, "in");
-        S1GraphManager < SchedulerHandle >::add_link(&b, "out",
-                                                     coordinator, "out");
+        add_link(&a, "out", &b, "in");
+        add_link(&b, "out", coordinator, "out");
     }
 
     virtual ~S1GraphManager()
@@ -138,39 +104,33 @@ public:
 
 private:
     pdevs::Simulator < common::DoubleTime,
-                       A1 < SchedulerHandle >,
-                       SchedulerHandle,
+                       A1,
                        paradevs::common::NoParameters > a;
     pdevs::Simulator < common::DoubleTime,
-                       B1 < SchedulerHandle >,
-                       SchedulerHandle,
+                       B1,
                        paradevs::common::NoParameters > b;
 };
 
-template < class SchedulerHandle >
 class S2GraphManager :
-        public dtss::GraphManager < common::DoubleTime, SchedulerHandle >
+        public dtss::GraphManager < common::DoubleTime >
 {
 public:
-    S2GraphManager(common::Coordinator < common::DoubleTime,
-                                         SchedulerHandle >* coordinator,
+    S2GraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                    const paradevs::common::NoParameters& parameters) :
-        dtss::GraphManager < common::DoubleTime,
-                             SchedulerHandle >(coordinator, parameters),
+        dtss::GraphManager < common::DoubleTime >(coordinator, parameters),
         a("a2", 20, paradevs::common::NoParameters()),
         b("b2", 20, paradevs::common::NoParameters())
     {
-        S2GraphManager < SchedulerHandle >::add_child(&a);
-        S2GraphManager < SchedulerHandle >::add_child(&b);
+        add_child(&a);
+        add_child(&b);
 
         a.add_in_port("in");
         a.add_out_port("out");
         b.add_in_port("in");
         coordinator->add_in_port("in");
 
-        S2GraphManager < SchedulerHandle >::add_link(&a, "out", &b, "in");
-        S2GraphManager < SchedulerHandle >::add_link(coordinator, "in",
-                                                     &a, "in");
+        add_link(&a, "out", &b, "in");
+        add_link(coordinator, "in", &a, "in");
     }
 
     virtual ~S2GraphManager()
@@ -178,24 +138,19 @@ public:
 
 private:
     dtss::Simulator < common::DoubleTime,
-                      A2 < SchedulerHandle >,
-                      SchedulerHandle
-                    > a;
+                      A2 > a;
     dtss::Simulator < common::DoubleTime,
-                      B2 < SchedulerHandle >,
-                      SchedulerHandle
-                    > b;
+                      B2 > b;
 };
 
 class RootGraphManager :
-        public pdevs::GraphManager < common::DoubleTime, SchedulerHandle,
+        public pdevs::GraphManager < common::DoubleTime,
                                      paradevs::common::NoParameters >
 {
 public:
-    RootGraphManager(common::Coordinator < common::DoubleTime,
-                                           SchedulerHandle >* coordinator,
+    RootGraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                      const paradevs::common::NoParameters& parameters) :
-        pdevs::GraphManager < common::DoubleTime, SchedulerHandle,
+        pdevs::GraphManager < common::DoubleTime,
                               paradevs::common::NoParameters >(
                                   coordinator, parameters),
         S1("S1", paradevs::common::NoParameters(),
@@ -214,29 +169,24 @@ public:
 private:
     paradevs::pdevs::Coordinator <
         common::DoubleTime,
-        SchedulerType,
-        SchedulerHandle,
-        S1GraphManager < SchedulerHandle >
-    > S1;
+        S1GraphManager > S1;
     paradevs::dtss::Coordinator <
         common::DoubleTime,
-        LastBagPolicy < SchedulerHandle >,
-        S2GraphManager < SchedulerHandle >,
-        SchedulerHandle,
+        LastBagPolicy,
+        S2GraphManager,
         paradevs::dtss::Parameters < common::DoubleTime >
     > S2;
 };
 
-template < int size, class SchedulerHandle >
+template < int size >
 class LinearGraphManager :
-        public pdevs::GraphManager < common::DoubleTime, SchedulerHandle,
+        public pdevs::GraphManager < common::DoubleTime,
                                      paradevs::common::NoParameters >
 {
 public:
-    LinearGraphManager(common::Coordinator < common::DoubleTime,
-                                             SchedulerHandle >* coordinator,
+    LinearGraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                        const paradevs::common::NoParameters& parameters) :
-        pdevs::GraphManager < common::DoubleTime, SchedulerHandle,
+        pdevs::GraphManager < common::DoubleTime,
                               paradevs::common::NoParameters >(
                                   coordinator, parameters)
     {
@@ -246,21 +196,19 @@ public:
             ss << "a" << i;
             _models.push_back(
                 new pdevs::Simulator < common::DoubleTime,
-                                       Beep < SchedulerHandle >,
-                                       SchedulerHandle,
+                                       Beep,
                                        paradevs::common::NoParameters >(
                                            ss.str(),
                                            paradevs::common::NoParameters()));
         }
         for (unsigned int i = 0; i < size; ++i) {
-            LinearGraphManager < size, SchedulerHandle >::add_child(_models[i]);
+            LinearGraphManager < size >::add_child(_models[i]);
 
             _models[i]->add_in_port("in");
             _models[i]->add_out_port("out");
         }
         for (unsigned int i = 0; i < size - 1; ++i) {
-            LinearGraphManager < size,
-                                 SchedulerHandle >::add_link(_models[i],
+            LinearGraphManager < size >::add_link(_models[i],
                                                              "out",
                                                              _models[i + 1],
                                                              "in");
@@ -277,21 +225,18 @@ public:
 private:
     std::vector <
     pdevs::Simulator < common::DoubleTime,
-                       Beep < SchedulerHandle >,
-                       SchedulerHandle,
+                       Beep,
                        paradevs::common::NoParameters >* > _models;
 };
 
-template < class SchedulerHandle >
 class Linear2GraphManager :
-        public pdevs::GraphManager < common::DoubleTime, SchedulerHandle,
+        public pdevs::GraphManager < common::DoubleTime,
                                      paradevs::common::NoParameters >
 {
 public:
-    Linear2GraphManager(common::Coordinator < common::DoubleTime,
-                                              SchedulerHandle >* coordinator,
+    Linear2GraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                         const paradevs::common::NoParameters& parameters) :
-        pdevs::GraphManager < common::DoubleTime, SchedulerHandle,
+        pdevs::GraphManager < common::DoubleTime,
                               paradevs::common::NoParameters >(
                                   coordinator, parameters)
     {
@@ -301,31 +246,26 @@ public:
             ss << "a" << i;
             _models.push_back(
                 new pdevs::Simulator < common::DoubleTime,
-                                       Beep < SchedulerHandle >,
-                                       SchedulerHandle,
+                                       Beep,
                                        paradevs::common::NoParameters >(
                                            ss.str(),
                                            paradevs::common::NoParameters()));
         }
         for (unsigned int i = 0; i < 100; ++i) {
-            Linear2GraphManager < SchedulerHandle >::add_child(_models[i]);
+            add_child(_models[i]);
 
             _models[i]->add_in_port("in");
             _models[i]->add_out_port("out");
         }
         for (unsigned int i = 0; i < 99; ++i) {
-            Linear2GraphManager < SchedulerHandle >::add_link(_models[i], "out",
-                                                              _models[i + 1],
-                                                              "in");
+            add_link(_models[i], "out", _models[i + 1], "in");
         }
 
         coordinator->add_in_port("in");
         coordinator->add_out_port("out");
 
-        Linear2GraphManager < SchedulerHandle >::add_link(coordinator, "in",
-                                                          _models[0], "in");
-        Linear2GraphManager < SchedulerHandle >::add_link(_models[49], "out",
-                                                          coordinator, "out");
+        add_link(coordinator, "in", _models[0], "in");
+        add_link(_models[49], "out", coordinator, "out");
     }
 
     virtual ~Linear2GraphManager()
@@ -337,20 +277,18 @@ public:
 
 private:
     std::vector <
-        pdevs::Simulator < common::DoubleTime, Beep < SchedulerHandle >,
-                           SchedulerHandle,
+        pdevs::Simulator < common::DoubleTime, Beep,
                            paradevs::common::NoParameters >* > _models;
 };
 
 class Root2GraphManager :
-        public pdevs::GraphManager < common::DoubleTime, SchedulerHandle,
+        public pdevs::GraphManager < common::DoubleTime,
                                      paradevs::common::NoParameters >
 {
 public:
-    Root2GraphManager(common::Coordinator < common::DoubleTime,
-                                            SchedulerHandle >* coordinator,
+    Root2GraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                       const paradevs::common::NoParameters& parameters) :
-        pdevs::GraphManager < common::DoubleTime, SchedulerHandle,
+        pdevs::GraphManager < common::DoubleTime,
                               paradevs::common::NoParameters >(
                                   coordinator, parameters),
         S1("S1", paradevs::common::NoParameters(),
@@ -369,30 +307,23 @@ public:
 private:
     paradevs::pdevs::Coordinator <
         common::DoubleTime,
-        SchedulerType,
-        SchedulerHandle,
-        Linear2GraphManager < SchedulerHandle > > S1;
+        Linear2GraphManager > S1;
     paradevs::pdevs::Coordinator <
         common::DoubleTime,
-        SchedulerType,
-        SchedulerHandle,
-        Linear2GraphManager < SchedulerHandle > > S2;
+        Linear2GraphManager > S2;
 };
 
 class Root3GraphManager :
         public pdevs::GraphManager <
             common::DoubleTime,
-            paradevs::common::scheduler::NoSchedulerHandle,
             paradevs::common::NoParameters >
 {
 public:
     Root3GraphManager(
         common::Coordinator <
-            common::DoubleTime,
-            paradevs::common::scheduler::NoSchedulerHandle >* coordinator,
+            common::DoubleTime >* coordinator,
         const paradevs::common::NoParameters& parameters) :
         pdevs::GraphManager < common::DoubleTime,
-                              paradevs::common::scheduler::NoSchedulerHandle,
                               paradevs::common::NoParameters >(
                                   coordinator, parameters),
         S1("S1", paradevs::common::NoParameters(),
@@ -411,16 +342,10 @@ public:
 private:
     pdevs::Coordinator <
         common::DoubleTime,
-        paradevs::common::scheduler::VectorScheduler < common::DoubleTime >,
-        paradevs::common::scheduler::NoSchedulerHandle,
-        Linear2GraphManager < paradevs::common::scheduler::NoSchedulerHandle >
-    > S1;
+        Linear2GraphManager > S1;
     pdevs::Coordinator <
         common::DoubleTime,
-        paradevs::common::scheduler::VectorScheduler < common::DoubleTime >,
-        paradevs::common::scheduler::NoSchedulerHandle,
-        Linear2GraphManager < paradevs::common::scheduler::NoSchedulerHandle >
-    > S2;
+        Linear2GraphManager > S2;
 };
 
 } } } // namespace paradevs tests mixed

src/tests/mixed/models.hpp

@@ -36,15 +36,14 @@
 
 namespace paradevs { namespace tests { namespace mixed {
 
-template < class SchedulerHandle>
 class A1 :
-        public paradevs::pdevs::Dynamics < common::DoubleTime, SchedulerHandle,
+        public paradevs::pdevs::Dynamics < common::DoubleTime,
                                            paradevs::common::NoParameters >
 {
 public:
     A1(const std::string& name,
        const paradevs::common::NoParameters& parameters) :
-        paradevs::pdevs::Dynamics < common::DoubleTime, SchedulerHandle,
+        paradevs::pdevs::Dynamics < common::DoubleTime,
                                     paradevs::common::NoParameters >(
                                         name, parameters), _value(0)
     { }
@@ -61,7 +60,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace() <<
             common::TraceElement < common::DoubleTime >(
-                A1 < SchedulerHandle >::get_name(), t, common::DELTA_INT);
+                get_name(), t, common::DELTA_INT);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
 
@@ -72,7 +71,7 @@ public:
 
     void dext(typename common::DoubleTime::type t,
               typename common::DoubleTime::type /* e */,
-              const common::Bag < common::DoubleTime, SchedulerHandle >& msgs)
+              const common::Bag < common::DoubleTime >& msgs)
     {
 
 #ifndef WITH_TRACE
@@ -83,7 +82,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A1 < SchedulerHandle >::get_name(), t, common::DELTA_EXT)
+                get_name(), t, common::DELTA_EXT)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -93,7 +92,7 @@ public:
 
     void dconf(typename common::DoubleTime::type t,
                typename common::DoubleTime::type /* e */,
-               const common::Bag < common::DoubleTime, SchedulerHandle >& msgs)
+               const common::Bag < common::DoubleTime >& msgs)
     {
 
 #ifndef WITH_TRACE
@@ -104,7 +103,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A1 < SchedulerHandle >::get_name(), t, common::DELTA_CONF)
+                get_name(), t, common::DELTA_CONF)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -120,7 +119,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A1 < SchedulerHandle >::get_name(), t, common::START);
+                get_name(), t, common::START);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
         _phase = WAIT;
@@ -137,7 +136,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A1 < SchedulerHandle >::get_name(), t, common::TA);
+                get_name(), t, common::TA);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
         if (_phase == WAIT) {
@@ -147,7 +146,7 @@ public:
         }
     }
 
-    common::Bag < common::DoubleTime, SchedulerHandle > lambda(
+    common::Bag < common::DoubleTime > lambda(
         typename common::DoubleTime::type t) const
     {
 
@@ -155,16 +154,16 @@ public:
         (void)t;
 #endif
 
-        common::Bag < common::DoubleTime, SchedulerHandle > msgs;
+        common::Bag < common::DoubleTime > msgs;
 
         msgs.push_back(common::ExternalEvent <
-                           common::DoubleTime, SchedulerHandle >(
+                           common::DoubleTime >(
                                "out", (void*)&_value));
 
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A1 < SchedulerHandle >::get_name(), t, common::LAMBDA)
+                get_name(), t, common::LAMBDA)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -179,15 +178,14 @@ private:
     double _value;
 };
 
-template < class SchedulerHandle>
 class B1 :
-        public paradevs::pdevs::Dynamics < common::DoubleTime, SchedulerHandle,
+        public paradevs::pdevs::Dynamics < common::DoubleTime,
                                            paradevs::common::NoParameters >
 {
 public:
     B1(const std::string& name,
        const paradevs::common::NoParameters& parameters) :
-        paradevs::pdevs::Dynamics < common::DoubleTime, SchedulerHandle,
+        paradevs::pdevs::Dynamics < common::DoubleTime,
                                     paradevs::common::NoParameters >(
                                         name, parameters)
     { }
@@ -204,7 +202,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B1 < SchedulerHandle >::get_name(), t, common::DELTA_INT);
+                get_name(), t, common::DELTA_INT);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
 
@@ -215,7 +213,7 @@ public:
 
     void dext(typename common::DoubleTime::type t,
               typename common::DoubleTime::type /* e */,
-              const common::Bag < common::DoubleTime, SchedulerHandle >& msgs)
+              const common::Bag < common::DoubleTime >& msgs)
     {
 
 #ifndef WITH_TRACE
@@ -226,7 +224,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B1 < SchedulerHandle >::get_name(), t, common::DELTA_EXT)
+                get_name(), t, common::DELTA_EXT)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -236,7 +234,7 @@ public:
 
     void dconf(typename common::DoubleTime::type t,
                typename common::DoubleTime::type /* e */,
-               const common::Bag < common::DoubleTime, SchedulerHandle >& msgs)
+               const common::Bag < common::DoubleTime >& msgs)
     {
 
 #ifndef WITH_TRACE
@@ -247,7 +245,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B1 < SchedulerHandle >::get_name(), t, common::DELTA_CONF)
+                get_name(), t, common::DELTA_CONF)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -264,7 +262,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B1 < SchedulerHandle >::get_name(), t, common::START);
+                get_name(), t, common::START);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
 
@@ -283,7 +281,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B1 < SchedulerHandle >::get_name(), t, common::TA);
+                get_name(), t, common::TA);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
 
@@ -294,23 +292,23 @@ public:
         }
     }
 
-    common::Bag < common::DoubleTime, SchedulerHandle > lambda(
+    common::Bag < common::DoubleTime > lambda(
         typename common::DoubleTime::type t) const
     {
 
 #ifndef WITH_TRACE
         (void)t;
 #endif
-        common::Bag < common::DoubleTime, SchedulerHandle > msgs;
+        common::Bag < common::DoubleTime > msgs;
 
         msgs.push_back(common::ExternalEvent <
-                           common::DoubleTime, SchedulerHandle >(
+                           common::DoubleTime >(
                                "out", (void*)&t));
 
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B1 < SchedulerHandle >::get_name(), t, common::LAMBDA)
+                get_name(), t, common::LAMBDA)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -324,14 +322,13 @@ private:
     Phase _phase;
 };
 
-template < class SchedulerHandle >
 class A2 :
-        public paradevs::dtss::Dynamics < common::DoubleTime, SchedulerHandle >
+        public paradevs::dtss::Dynamics < common::DoubleTime >
 {
 public:
     A2(const std::string& name,
        const paradevs::common::NoParameters& parameters) :
-        paradevs::dtss::Dynamics < common::DoubleTime, SchedulerHandle,
+        paradevs::dtss::Dynamics < common::DoubleTime,
                                    paradevs::common::NoParameters >(
                                        name, parameters), _value(0)
     { }
@@ -339,7 +336,7 @@ public:
     { }
 
     void transition(
-        const common::Bag < common::DoubleTime, SchedulerHandle >& x,
+        const common::Bag < common::DoubleTime >& x,
         typename common::DoubleTime::type t)
     {
 
@@ -351,7 +348,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A2 < SchedulerHandle >::get_name(), t, common::DELTA_INT)
+                get_name(), t, common::DELTA_INT)
             << "x = " << x.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -368,30 +365,29 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A2 < SchedulerHandle >::get_name(), t, common::START);
+                get_name(), t, common::START);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
 
         return 0;
     }
 
-    common::Bag < common::DoubleTime, SchedulerHandle > lambda(
+    common::Bag < common::DoubleTime > lambda(
         typename common::DoubleTime::type t) const
     {
 
 #ifndef WITH_TRACE
         (void)t;
 #endif
-        common::Bag < common::DoubleTime, SchedulerHandle > msgs;
+        common::Bag < common::DoubleTime > msgs;
 
         msgs.push_back(
-            common::ExternalEvent < common::DoubleTime,
-                                    SchedulerHandle >( "out", (void*)&_value));
+            common::ExternalEvent < common::DoubleTime >( "out", (void*)&_value));
 
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A2 < SchedulerHandle >::get_name(), t, common::LAMBDA)
+                get_name(), t, common::LAMBDA)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -403,14 +399,13 @@ private:
     double _value;
 };
 
-template < class SchedulerHandle >
 class B2 :
-        public paradevs::dtss::Dynamics < common::DoubleTime, SchedulerHandle >
+        public paradevs::dtss::Dynamics < common::DoubleTime >
 {
 public:
     B2(const std::string& name,
        const paradevs::common::NoParameters& parameters) :
-        paradevs::dtss::Dynamics < common::DoubleTime, SchedulerHandle,
+        paradevs::dtss::Dynamics < common::DoubleTime,
                                    paradevs::common::NoParameters >(
                                        name, parameters), _value(0)
     { }
@@ -418,7 +413,7 @@ public:
     { }
 
     void transition(
-        const common::Bag < common::DoubleTime, SchedulerHandle >& x,
+        const common::Bag < common::DoubleTime >& x,
         typename common::DoubleTime::type t)
     {
 
@@ -430,7 +425,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B2 < SchedulerHandle >::get_name(), t, common::DELTA_INT)
+                get_name(), t, common::DELTA_INT)
             << "x = " << x.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -447,30 +442,29 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B2 < SchedulerHandle >::get_name(), t, common::START);
+                get_name(), t, common::START);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
 
         return 0;
     }
 
-    common::Bag < common::DoubleTime, SchedulerHandle > lambda(
+    common::Bag < common::DoubleTime > lambda(
         typename common::DoubleTime::type t) const
     {
 
 #ifndef WITH_TRACE
         (void)t;
 #endif
-        common::Bag < common::DoubleTime, SchedulerHandle > msgs;
+        common::Bag < common::DoubleTime > msgs;
 
         msgs.push_back(
-            common::ExternalEvent < common::DoubleTime,
-                                    SchedulerHandle >("out", (void*)&_value));
+            common::ExternalEvent < common::DoubleTime >("out", (void*)&_value));
 
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B2 < SchedulerHandle >::get_name(), t, common::LAMBDA)
+                get_name(), t, common::LAMBDA)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -482,16 +476,14 @@ private:
     double _value;
 };
 
-template < class SchedulerHandle>
 class Beep :
-        public paradevs::pdevs::Dynamics < common::DoubleTime, SchedulerHandle,
+        public paradevs::pdevs::Dynamics < common::DoubleTime,
                                            paradevs::common::NoParameters >
 {
 public:
     Beep(const std::string& name,
          const paradevs::common::NoParameters& parameters) :
         paradevs::pdevs::Dynamics < common::DoubleTime,
-                                    SchedulerHandle,
                                     paradevs::common::NoParameters >(
                                         name, parameters), _value(0)
     { }
@@ -508,7 +500,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace() <<
             common::TraceElement < common::DoubleTime >(
-                Beep < SchedulerHandle >::get_name(), t, common::DELTA_INT);
+                get_name(), t, common::DELTA_INT);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
 
@@ -519,7 +511,7 @@ public:
 
     void dext(typename common::DoubleTime::type t,
               typename common::DoubleTime::type /* e */,
-              const common::Bag < common::DoubleTime, SchedulerHandle >& msgs)
+              const common::Bag < common::DoubleTime >& msgs)
     {
 
 #ifndef WITH_TRACE
@@ -530,7 +522,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                Beep < SchedulerHandle >::get_name(), t, common::DELTA_EXT)
+                get_name(), t, common::DELTA_EXT)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -540,7 +532,7 @@ public:
 
     void dconf(typename common::DoubleTime::type t,
                typename common::DoubleTime::type /* e */,
-               const common::Bag < common::DoubleTime, SchedulerHandle >& msgs)
+               const common::Bag < common::DoubleTime >& msgs)
     {
 
 #ifndef WITH_TRACE
@@ -551,7 +543,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                Beep < SchedulerHandle >::get_name(), t, common::DELTA_CONF)
+                get_name(), t, common::DELTA_CONF)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -568,7 +560,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                Beep < SchedulerHandle >::get_name(), t, common::START);
+                get_name(), t, common::START);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
 
@@ -587,7 +579,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                Beep < SchedulerHandle >::get_name(), t, common::TA);
+                get_name(), t, common::TA);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
 
@@ -598,23 +590,23 @@ public:
         }
     }
 
-    common::Bag < common::DoubleTime, SchedulerHandle > lambda(
+    common::Bag < common::DoubleTime > lambda(
         typename common::DoubleTime::type t) const
     {
 
 #ifndef WITH_TRACE
         (void)t;
 #endif
-        common::Bag < common::DoubleTime, SchedulerHandle > msgs;
+        common::Bag < common::DoubleTime > msgs;
 
         msgs.push_back(common::ExternalEvent <
-                           common::DoubleTime, SchedulerHandle >(
+                           common::DoubleTime >(
                                "out", (void*)&_value));
 
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                Beep < SchedulerHandle >::get_name(), t, common::LAMBDA)
+                get_name(), t, common::LAMBDA)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
 #endif

src/tests/mixed/tests.cpp

@@ -41,9 +41,6 @@ TEST_CASE("mixed/hierachical", "run")
         DoubleTime,
         paradevs::pdevs::Coordinator <
             DoubleTime,
-            paradevs::common::scheduler::HeapScheduler <
-                DoubleTime, SchedulerHandle >,
-            SchedulerHandle,
             RootGraphManager >
         > rc(0, 100, "root");
 

src/tests/multithreading/graph_manager.hpp

@@ -36,31 +36,27 @@
 
 namespace paradevs { namespace tests { namespace multithreading {
 
-template < class SchedulerHandle >
 class S1GraphManager :
-        public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               SchedulerHandle >
+        public paradevs::pdevs::GraphManager < common::DoubleTime >
 {
 public:
-    S1GraphManager(common::Coordinator < common::DoubleTime,
-                                         SchedulerHandle >* coordinator,
+    S1GraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                    const paradevs::common::NoParameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime,
-                                        SchedulerHandle >(coordinator,
+        paradevs::pdevs::GraphManager < common::DoubleTime >(coordinator,
                                                           parameters),
-        a("a1", common::NoParameters()), b("b1", common::NoParameters())
+        a("a1", common::NoParameters()),
+        b("b1", common::NoParameters())
     {
-        S1GraphManager < SchedulerHandle >::add_child(&a);
-        S1GraphManager < SchedulerHandle >::add_child(&b);
+        add_child(&a);
+        add_child(&b);
 
         a.add_out_port("out");
         b.add_in_port("in");
         b.add_out_port("out");
         coordinator->add_out_port("out");
 
-        S1GraphManager < SchedulerHandle >::add_link(&a, "out", &b, "in");
-        S1GraphManager < SchedulerHandle >::add_link(&b, "out",
-                                                     coordinator, "out");
+        add_link(&a, "out", &b, "in");
+        add_link(&b, "out", coordinator, "out");
     }
 
     void init()
@@ -70,8 +66,7 @@ public:
     { }
 
     void transition(
-        const common::Models < common::DoubleTime,
-                               pdevs::SchedulerHandle >& /* receivers */,
+        const common::Models < common::DoubleTime >& /* receivers */,
         common::DoubleTime::type /* t */)
     { }
 
@@ -79,39 +74,30 @@ public:
     { }
 
 private:
-    paradevs::pdevs::Simulator < common::DoubleTime,
-                                 pdevs::A < SchedulerHandle >,
-                                 SchedulerHandle > a;
-    paradevs::pdevs::Simulator < common::DoubleTime,
-                                 pdevs::B < SchedulerHandle >,
-                                 SchedulerHandle > b;
+    paradevs::pdevs::Simulator < common::DoubleTime, pdevs::A  > a;
+    paradevs::pdevs::Simulator < common::DoubleTime, pdevs::B  > b;
 };
 
-template < class SchedulerHandle >
 class S2GraphManager :
-        public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               SchedulerHandle >
+        public paradevs::pdevs::GraphManager < common::DoubleTime >
 {
 public:
-    S2GraphManager(common::Coordinator < common::DoubleTime,
-                                         SchedulerHandle >* coordinator,
+    S2GraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                    const paradevs::common::NoParameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime,
-                                        SchedulerHandle >(coordinator,
-                                                          parameters),
+        paradevs::pdevs::GraphManager < common::DoubleTime >(coordinator,
+                                                             parameters),
         a("a2", common::NoParameters()), b("b2", common::NoParameters())
     {
-        S2GraphManager < SchedulerHandle >::add_child(&a);
-        S2GraphManager < SchedulerHandle >::add_child(&b);
+        add_child(&a);
+        add_child(&b);
 
         a.add_in_port("in");
         a.add_out_port("out");
         b.add_in_port("in");
         coordinator->add_in_port("in");
 
-        S2GraphManager < SchedulerHandle >::add_link(&a, "out", &b, "in");
-        S2GraphManager < SchedulerHandle >::add_link(coordinator, "in",
-                                                     &a, "in");
+        add_link(&a, "out", &b, "in");
+        add_link(coordinator, "in", &a, "in");
     }
 
     void init()
@@ -121,8 +107,7 @@ public:
     { }
 
     void transition(
-        const common::Models < common::DoubleTime,
-                               pdevs::SchedulerHandle >& /* receivers */,
+        const common::Models < common::DoubleTime >& /* receivers */,
         common::DoubleTime::type /* t */)
     { }
 
@@ -130,25 +115,18 @@ public:
     { }
 
 private:
-    paradevs::pdevs::Simulator < common::DoubleTime,
-                                 pdevs::A < SchedulerHandle >,
-                                 SchedulerHandle > a;
-    paradevs::pdevs::Simulator < common::DoubleTime,
-                                 pdevs::B < SchedulerHandle >,
-                                 SchedulerHandle > b;
+    paradevs::pdevs::Simulator < common::DoubleTime, pdevs::A  > a;
+    paradevs::pdevs::Simulator < common::DoubleTime, pdevs::B  > b;
 };
 
 class RootGraphManager :
-        public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               pdevs::SchedulerHandle >
+        public paradevs::pdevs::GraphManager < common::DoubleTime >
 {
 public:
     RootGraphManager(
-        common::Coordinator < common::DoubleTime,
-                              pdevs::SchedulerHandle >* coordinator,
+        common::Coordinator < common::DoubleTime >* coordinator,
         const paradevs::common::NoParameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime,
-                                        pdevs::SchedulerHandle >(
+        paradevs::pdevs::GraphManager < common::DoubleTime >(
                                             coordinator, parameters),
         S1("S1", paradevs::common::NoParameters(),
            paradevs::common::NoParameters()),
@@ -166,17 +144,11 @@ public:
         S1.set_sender(
             dynamic_cast < paradevs::pdevs::multithreading::Coordinator <
                 common::DoubleTime,
-                paradevs::common::scheduler::HeapScheduler <
-                    common::DoubleTime, pdevs::SchedulerHandle >,
-                pdevs::SchedulerHandle,
                 paradevs::tests::multithreading::RootGraphManager >*
             >(get_coordinator())->get_sender());
         S2.set_sender(
             dynamic_cast < paradevs::pdevs::multithreading::Coordinator <
                 common::DoubleTime,
-                paradevs::common::scheduler::HeapScheduler <
-                    common::DoubleTime, pdevs::SchedulerHandle >,
-                pdevs::SchedulerHandle,
                 paradevs::tests::multithreading::RootGraphManager >*
             >(get_coordinator())->get_sender());
     }
@@ -191,8 +163,7 @@ public:
                 common::DoubleTime >(t));
     }
 
-    void transition(const common::Models < common::DoubleTime,
-                                           pdevs::SchedulerHandle >& receivers,
+    void transition(const common::Models < common::DoubleTime >& receivers,
                     common::DoubleTime::type t)
     {
         if (std::find(receivers.begin(), receivers.end(),
@@ -215,28 +186,20 @@ public:
 private:
     paradevs::pdevs::multithreading::Coordinator <
         common::DoubleTime,
-        pdevs::SchedulerType,
-        pdevs::SchedulerHandle,
-        S1GraphManager < pdevs::SchedulerHandle > > S1;
+        S1GraphManager > S1;
     paradevs::pdevs::multithreading::Coordinator <
         common::DoubleTime,
-        pdevs::SchedulerType,
-        pdevs::SchedulerHandle,
-        S2GraphManager < pdevs::SchedulerHandle > > S2;
+        S2GraphManager > S2;
 };
 
-template < class SchedulerHandle >
 class S3GraphManager :
-        public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               SchedulerHandle >
+        public paradevs::pdevs::GraphManager < common::DoubleTime >
 {
 public:
-    S3GraphManager(common::Coordinator < common::DoubleTime,
-                                         SchedulerHandle >* coordinator,
+    S3GraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                    const paradevs::common::NoParameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime,
-                                        SchedulerHandle >(coordinator,
-                                                          parameters)
+        paradevs::pdevs::GraphManager < common::DoubleTime >(coordinator,
+                                                             parameters)
     {
         coordinator->add_out_port("out");
         for (unsigned int i = 0; i < 10; ++i) {
@@ -246,7 +209,7 @@ public:
 
             ss << "a" << (i + 1);
             _simulators.push_back(s);
-            S3GraphManager < SchedulerHandle >::add_child(s);
+            add_child(s);
             s->add_out_port("out");
         }
     }
@@ -258,8 +221,7 @@ public:
     { }
 
     void transition(
-        const common::Models < common::DoubleTime,
-                               pdevs::SchedulerHandle >& /* receivers */,
+        const common::Models < common::DoubleTime >& /* receivers */,
         common::DoubleTime::type /* t */)
     { }
 
@@ -273,23 +235,19 @@ public:
 
 private:
     typedef paradevs::pdevs::Simulator < common::DoubleTime,
-                                         pdevs::A < SchedulerHandle >,
-                                         SchedulerHandle > simulator_type;
+                                         pdevs::A > simulator_type;
 
     std::vector < simulator_type* > _simulators;
 };
 
 class Root2GraphManager :
-        public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               pdevs::SchedulerHandle >
+        public paradevs::pdevs::GraphManager < common::DoubleTime >
 {
 public:
     Root2GraphManager(
-        common::Coordinator < common::DoubleTime,
-                              pdevs::SchedulerHandle >* coordinator,
+        common::Coordinator < common::DoubleTime >* coordinator,
         const paradevs::common::NoParameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime,
-                                        pdevs::SchedulerHandle >(
+        paradevs::pdevs::GraphManager < common::DoubleTime >(
                                             coordinator, parameters),
         S1("S1", paradevs::common::NoParameters(),
            paradevs::common::NoParameters()),
@@ -305,17 +263,11 @@ public:
         S1.set_sender(
             dynamic_cast < paradevs::pdevs::multithreading::Coordinator <
                 common::DoubleTime,
-                paradevs::common::scheduler::HeapScheduler <
-                    common::DoubleTime, pdevs::SchedulerHandle >,
-                pdevs::SchedulerHandle,
                 paradevs::tests::multithreading::Root2GraphManager >*
             >(get_coordinator())->get_sender());
         S2.set_sender(
             dynamic_cast < paradevs::pdevs::multithreading::Coordinator <
                 common::DoubleTime,
-                paradevs::common::scheduler::HeapScheduler <
-                    common::DoubleTime, pdevs::SchedulerHandle >,
-                pdevs::SchedulerHandle,
                 paradevs::tests::multithreading::Root2GraphManager >*
             >(get_coordinator())->get_sender());
     }
@@ -330,8 +282,7 @@ public:
                 common::DoubleTime >(t));
     }
 
-    void transition(const common::Models < common::DoubleTime,
-                                           pdevs::SchedulerHandle >& receivers,
+    void transition(const common::Models < common::DoubleTime >& receivers,
                     common::DoubleTime::type t)
     {
         if (std::find(receivers.begin(), receivers.end(),
@@ -354,27 +305,20 @@ public:
 private:
     paradevs::pdevs::multithreading::Coordinator <
         common::DoubleTime,
-        pdevs::SchedulerType,
-        pdevs::SchedulerHandle,
-        S3GraphManager < pdevs::SchedulerHandle > > S1;
+        S3GraphManager > S1;
     paradevs::pdevs::multithreading::Coordinator <
         common::DoubleTime,
-        pdevs::SchedulerType,
-        pdevs::SchedulerHandle,
-        S3GraphManager < pdevs::SchedulerHandle > > S2;
+        S3GraphManager > S2;
 };
 
 class Root3GraphManager :
-        public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               pdevs::SchedulerHandle >
+        public paradevs::pdevs::GraphManager < common::DoubleTime >
 {
 public:
     Root3GraphManager(
-        common::Coordinator < common::DoubleTime,
-                              pdevs::SchedulerHandle >* coordinator,
+        common::Coordinator < common::DoubleTime >* coordinator,
         const paradevs::common::NoParameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime,
-                                        pdevs::SchedulerHandle >(
+        paradevs::pdevs::GraphManager < common::DoubleTime >(
                                             coordinator, parameters),
         S1("S1", paradevs::common::NoParameters(),
            paradevs::common::NoParameters()),
@@ -391,14 +335,10 @@ public:
 private:
     paradevs::pdevs::Coordinator <
         common::DoubleTime,
-        pdevs::SchedulerType,
-        pdevs::SchedulerHandle,
-        S3GraphManager < pdevs::SchedulerHandle > > S1;
+        S3GraphManager > S1;
     paradevs::pdevs::Coordinator <
         common::DoubleTime,
-        pdevs::SchedulerType,
-        pdevs::SchedulerHandle,
-        S3GraphManager < pdevs::SchedulerHandle > > S2;
+        S3GraphManager > S2;
 };
 
 } } } // namespace paradevs tests multithreading

src/tests/multithreading/tests.cpp

@@ -46,9 +46,6 @@ TEST_CASE("pdevs/multithreading/hierachical", "run")
     paradevs::common::RootCoordinator <
         DoubleTime, paradevs::pdevs::multithreading::Coordinator <
             DoubleTime,
-            paradevs::common::scheduler::HeapScheduler <
-                DoubleTime, SchedulerHandle >,
-            SchedulerHandle,
             paradevs::tests::multithreading::RootGraphManager >
         > rc(0, 100, "root", paradevs::common::NoParameters(),
              paradevs::common::NoParameters());
@@ -71,9 +68,6 @@ TEST_CASE("pdevs/classic/hierachical", "run")
     paradevs::common::RootCoordinator <
         DoubleTime, paradevs::pdevs::Coordinator <
             DoubleTime,
-            paradevs::common::scheduler::HeapScheduler <
-                DoubleTime, SchedulerHandle >,
-            SchedulerHandle,
             paradevs::tests::pdevs::RootGraphManager >
         > rc(0, 100, "root", paradevs::common::NoParameters(),
              paradevs::common::NoParameters());
@@ -95,9 +89,6 @@ TEST_CASE("pdevs/multithreading/independant", "run")
     paradevs::common::RootCoordinator <
         DoubleTime, paradevs::pdevs::multithreading::Coordinator <
             DoubleTime,
-            paradevs::common::scheduler::HeapScheduler <
-                DoubleTime, SchedulerHandle >,
-            SchedulerHandle,
             paradevs::tests::multithreading::Root2GraphManager >
         > rc(0, 100, "root", paradevs::common::NoParameters(),
              paradevs::common::NoParameters());
@@ -120,9 +111,6 @@ TEST_CASE("pdevs/classic/independant", "run")
     paradevs::common::RootCoordinator <
         DoubleTime, paradevs::pdevs::Coordinator <
             DoubleTime,
-            paradevs::common::scheduler::HeapScheduler <
-                DoubleTime, SchedulerHandle >,
-            SchedulerHandle,
             paradevs::tests::multithreading::Root3GraphManager >
         > rc(0, 100, "root", paradevs::common::NoParameters(),
              paradevs::common::NoParameters());
@@ -136,4 +124,3 @@ TEST_CASE("pdevs/classic/independant", "run")
 
     std::cout << "classic/independant -> " << time_span.count() << std::endl;
 }
-

src/tests/pdevs/graph_manager.hpp

@@ -29,121 +29,80 @@
 
 #include <tests/pdevs/models.hpp>
 
-#include <paradevs/common/scheduler/HeapScheduler.hpp>
-
 #include <paradevs/kernel/pdevs/Coordinator.hpp>
 #include <paradevs/kernel/pdevs/GraphManager.hpp>
 #include <paradevs/kernel/pdevs/Simulator.hpp>
 
 namespace paradevs { namespace tests { namespace pdevs {
 
-struct SchedulerHandle;
-
-typedef typename paradevs::common::scheduler::HeapScheduler <
-    common::DoubleTime, SchedulerHandle >::type SchedulerType;
-
-struct SchedulerHandle
-{
-    SchedulerHandle()
-    { }
-
-    SchedulerHandle(const SchedulerType::handle_type& handle)
-        : _handle(handle)
-    { }
-
-    const SchedulerHandle& handle() const
-    { return *this; }
-
-    void handle(const SchedulerHandle& handle)
-    { _handle = handle._handle; }
-
-    SchedulerType::handle_type _handle;
-};
-
-template < class SchedulerHandle >
 class S1GraphManager :
-        public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               SchedulerHandle >
+        public paradevs::pdevs::GraphManager < common::DoubleTime >
 {
 public:
-    S1GraphManager(common::Coordinator < common::DoubleTime,
-                                         SchedulerHandle >* coordinator,
+    S1GraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                    const paradevs::common::NoParameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime,
-                                        SchedulerHandle >(coordinator,
+        paradevs::pdevs::GraphManager < common::DoubleTime >(coordinator,
                                                           parameters),
         a("a1", common::NoParameters()), b("b1", common::NoParameters())
     {
-        S1GraphManager < SchedulerHandle >::add_child(&a);
-        S1GraphManager < SchedulerHandle >::add_child(&b);
+        add_child(&a);
+        add_child(&b);
 
         a.add_out_port("out");
         b.add_in_port("in");
         b.add_out_port("out");
         coordinator->add_out_port("out");
 
-        S1GraphManager < SchedulerHandle >::add_link(&a, "out", &b, "in");
-        S1GraphManager < SchedulerHandle >::add_link(&b, "out",
-                                                     coordinator, "out");
+        add_link(&a, "out", &b, "in");
+        add_link(&b, "out", coordinator, "out");
     }
 
     virtual ~S1GraphManager()
     { }
 
 private:
-    paradevs::pdevs::Simulator < common::DoubleTime, A < SchedulerHandle >,
-                                 SchedulerHandle > a;
-    paradevs::pdevs::Simulator < common::DoubleTime, B < SchedulerHandle >,
-                                 SchedulerHandle > b;
+    paradevs::pdevs::Simulator < common::DoubleTime, A > a;
+    paradevs::pdevs::Simulator < common::DoubleTime, B > b;
 };
 
-template < class SchedulerHandle >
 class S2GraphManager :
-        public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               SchedulerHandle >
+        public paradevs::pdevs::GraphManager < common::DoubleTime >
 {
 public:
-    S2GraphManager(common::Coordinator < common::DoubleTime,
-                                         SchedulerHandle >* coordinator,
+    S2GraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                    const paradevs::common::NoParameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime,
-                                        SchedulerHandle >(coordinator,
+        paradevs::pdevs::GraphManager < common::DoubleTime >(coordinator,
                                                           parameters),
         a("a2", common::NoParameters()), b("b2", common::NoParameters())
     {
-        S2GraphManager < SchedulerHandle >::add_child(&a);
-        S2GraphManager < SchedulerHandle >::add_child(&b);
+        add_child(&a);
+        add_child(&b);
 
         a.add_in_port("in");
         a.add_out_port("out");
         b.add_in_port("in");
         coordinator->add_in_port("in");
 
-        S2GraphManager < SchedulerHandle >::add_link(&a, "out", &b, "in");
-        S2GraphManager < SchedulerHandle >::add_link(coordinator, "in",
-                                                     &a, "in");
+        add_link(&a, "out", &b, "in");
+        add_link(coordinator, "in", &a, "in");
     }
 
     virtual ~S2GraphManager()
     { }
 
 private:
-    paradevs::pdevs::Simulator < common::DoubleTime, A < SchedulerHandle >,
-                                 SchedulerHandle > a;
-    paradevs::pdevs::Simulator < common::DoubleTime, B < SchedulerHandle >,
-                                 SchedulerHandle > b;
+    paradevs::pdevs::Simulator < common::DoubleTime, A > a;
+    paradevs::pdevs::Simulator < common::DoubleTime, B > b;
 };
 
 class RootGraphManager :
-        public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               SchedulerHandle >
+        public paradevs::pdevs::GraphManager < common::DoubleTime >
 {
 public:
     RootGraphManager(
-        common::Coordinator < common::DoubleTime,
-                              SchedulerHandle >* coordinator,
+        common::Coordinator < common::DoubleTime >* coordinator,
         const paradevs::common::NoParameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime, SchedulerHandle >(
+        paradevs::pdevs::GraphManager < common::DoubleTime >(
                                             coordinator, parameters),
         S1("S1", paradevs::common::NoParameters(),
            paradevs::common::NoParameters()),
@@ -162,60 +121,47 @@ public:
 private:
     paradevs::pdevs::Coordinator <
         common::DoubleTime,
-        SchedulerType,
-        SchedulerHandle,
-        S1GraphManager < SchedulerHandle > > S1;
+        S1GraphManager > S1;
     paradevs::pdevs::Coordinator <
         common::DoubleTime,
-        SchedulerType,
-        SchedulerHandle,
-        S2GraphManager < SchedulerHandle > > S2;
+        S2GraphManager > S2;
 };
 
-template < class SchedulerHandle >
 class OnlyOneGraphManager :
-        public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               SchedulerHandle >
+        public paradevs::pdevs::GraphManager < common::DoubleTime >
 {
 public:
-    OnlyOneGraphManager(common::Coordinator < common::DoubleTime,
-                                              SchedulerHandle >* coordinator,
+    OnlyOneGraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                         const paradevs::common::NoParameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime,
-                                        SchedulerHandle >(coordinator,
+        paradevs::pdevs::GraphManager < common::DoubleTime >(coordinator,
                                                           parameters),
         a("a", common::NoParameters())
     {
-        OnlyOneGraphManager < SchedulerHandle >::add_child(&a);
+        add_child(&a);
     }
 
     virtual ~OnlyOneGraphManager()
     { }
 
 private:
-    paradevs::pdevs::Simulator < common::DoubleTime, A < SchedulerHandle >,
-                                 SchedulerHandle > a;
+    paradevs::pdevs::Simulator < common::DoubleTime, A > a;
 };
 
-template < class SchedulerHandle >
 class FlatGraphManager :
-        public paradevs::pdevs::GraphManager < common::DoubleTime,
-                                               SchedulerHandle >
+        public paradevs::pdevs::GraphManager < common::DoubleTime >
 {
 public:
-    FlatGraphManager(common::Coordinator < common::DoubleTime,
-                                           SchedulerHandle >* coordinator,
+    FlatGraphManager(common::Coordinator < common::DoubleTime >* coordinator,
                      const paradevs::common::NoParameters& parameters) :
-        paradevs::pdevs::GraphManager < common::DoubleTime,
-                                        SchedulerHandle >(coordinator,
+        paradevs::pdevs::GraphManager < common::DoubleTime >(coordinator,
                                                           parameters),
         a1("a1", common::NoParameters()), b1("b1", common::NoParameters()),
         a2("a2", common::NoParameters()), b2("b2", common::NoParameters())
     {
-        FlatGraphManager < SchedulerHandle >::add_child(&a1);
-        FlatGraphManager < SchedulerHandle >::add_child(&b1);
-        FlatGraphManager < SchedulerHandle >::add_child(&a2);
-        FlatGraphManager < SchedulerHandle >::add_child(&b2);
+        add_child(&a1);
+        add_child(&b1);
+        add_child(&a2);
+        add_child(&b2);
 
         a1.add_out_port("out");
         b1.add_in_port("in");
@@ -224,23 +170,19 @@ public:
         a2.add_out_port("out");
         b2.add_in_port("in");
 
-        FlatGraphManager < SchedulerHandle >::add_link(&a1, "out", &b1, "in");
-        FlatGraphManager < SchedulerHandle >::add_link(&b1, "out", &a2, "in");
-        FlatGraphManager < SchedulerHandle >::add_link(&a2, "out", &b2, "in");
+        add_link(&a1, "out", &b1, "in");
+        add_link(&b1, "out", &a2, "in");
+        add_link(&a2, "out", &b2, "in");
     }
 
     virtual ~FlatGraphManager()
     { }
 
 private:
-    paradevs::pdevs::Simulator < common::DoubleTime, A < SchedulerHandle >,
-                                 SchedulerHandle > a1;
-    paradevs::pdevs::Simulator < common::DoubleTime, B < SchedulerHandle >,
-                                 SchedulerHandle > b1;
-    paradevs::pdevs::Simulator < common::DoubleTime, A < SchedulerHandle >,
-                                 SchedulerHandle > a2;
-    paradevs::pdevs::Simulator < common::DoubleTime, B < SchedulerHandle >,
-                                 SchedulerHandle > b2;
+    paradevs::pdevs::Simulator < common::DoubleTime, A > a1;
+    paradevs::pdevs::Simulator < common::DoubleTime, B > b1;
+    paradevs::pdevs::Simulator < common::DoubleTime, A > a2;
+    paradevs::pdevs::Simulator < common::DoubleTime, B > b2;
 };
 
 } } } // namespace paradevs tests pdevs

src/tests/pdevs/models.hpp

@@ -50,14 +50,12 @@ void delay()
     }
 }
 
-template < class SchedulerHandle>
 class A :
-        public paradevs::pdevs::Dynamics < common::DoubleTime, SchedulerHandle >
+        public paradevs::pdevs::Dynamics < common::DoubleTime >
 {
 public:
     A(const std::string& name, const common::NoParameters& parameters) :
-        paradevs::pdevs::Dynamics < common::DoubleTime,
-                                    SchedulerHandle >(name, parameters),
+        paradevs::pdevs::Dynamics < common::DoubleTime >(name, parameters),
         _value(0)
     { }
     virtual ~A()
@@ -73,7 +71,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::DELTA_INT);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -87,7 +85,7 @@ public:
 
     void dext(typename common::DoubleTime::type t,
               typename common::DoubleTime::type /* e */,
-              const common::Bag < common::DoubleTime, SchedulerHandle >& msgs)
+              const common::Bag < common::DoubleTime >& msgs)
     {
 
 #ifndef WITH_TRACE
@@ -98,7 +96,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::DELTA_EXT)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
@@ -109,7 +107,7 @@ public:
 
     void dconf(typename common::DoubleTime::type t,
                typename common::DoubleTime::type /* e */,
-               const common::Bag < common::DoubleTime, SchedulerHandle >& msgs)
+               const common::Bag < common::DoubleTime >& msgs)
     {
 
 #ifndef WITH_TRACE
@@ -120,7 +118,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::DELTA_CONF)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
@@ -138,7 +136,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::START);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -158,7 +156,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::TA);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -170,22 +168,22 @@ public:
         }
     }
 
-    common::Bag < common::DoubleTime, SchedulerHandle > lambda(
+    common::Bag < common::DoubleTime > lambda(
         typename common::DoubleTime::type t) const
     {
 #ifndef WITH_TRACE
         (void)t;
 #endif
-        common::Bag < common::DoubleTime, SchedulerHandle > msgs;
+        common::Bag < common::DoubleTime > msgs;
 
         msgs.push_back(
-            common::ExternalEvent < common::DoubleTime, SchedulerHandle >(
+            common::ExternalEvent < common::DoubleTime >(
                 "out", (void*)&_value));
 
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                A < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::LAMBDA)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
@@ -204,14 +202,12 @@ private:
     double _value;
 };
 
-template < class SchedulerHandle >
 class B :
-        public paradevs::pdevs::Dynamics < common::DoubleTime, SchedulerHandle >
+        public paradevs::pdevs::Dynamics < common::DoubleTime >
 {
 public:
     B(const std::string& name, const common::NoParameters& parameters) :
-        paradevs::pdevs::Dynamics < common::DoubleTime,
-                                    SchedulerHandle >(name, parameters),
+        paradevs::pdevs::Dynamics < common::DoubleTime >(name, parameters),
         _value(0)
     { }
     virtual ~B()
@@ -227,7 +223,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::DELTA_INT);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -241,7 +237,7 @@ public:
 
     void dext(typename common::DoubleTime::type t,
               typename common::DoubleTime::type /* e */,
-              const common::Bag < common::DoubleTime, SchedulerHandle >& msgs)
+              const common::Bag < common::DoubleTime >& msgs)
     {
 
 #ifndef WITH_TRACE
@@ -252,7 +248,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::DELTA_EXT)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
@@ -263,7 +259,7 @@ public:
 
     void dconf(typename common::DoubleTime::type t,
                typename common::DoubleTime::type /* e */,
-               const common::Bag < common::DoubleTime, SchedulerHandle >& msgs)
+               const common::Bag < common::DoubleTime >& msgs)
     {
 
 #ifndef WITH_TRACE
@@ -274,7 +270,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::DELTA_CONF)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();
@@ -292,7 +288,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::START);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -311,7 +307,7 @@ public:
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::TA);
         common::Trace < common::DoubleTime >::trace().flush();
 #endif
@@ -323,22 +319,22 @@ public:
         }
     }
 
-    common::Bag < common::DoubleTime, SchedulerHandle > lambda(
+    common::Bag < common::DoubleTime > lambda(
         typename common::DoubleTime::type t) const
     {
 #ifndef WITH_TRACE
         (void)t;
 #endif
-        common::Bag < common::DoubleTime, SchedulerHandle > msgs;
+        common::Bag < common::DoubleTime > msgs;
 
         msgs.push_back(common::ExternalEvent <
-                           common::DoubleTime, SchedulerHandle >(
+                           common::DoubleTime >(
                                "out", (void*)&_value));
 
 #ifdef WITH_TRACE
         common::Trace < common::DoubleTime >::trace()
             << common::TraceElement < common::DoubleTime >(
-                B < SchedulerHandle >::get_name(), t,
+                get_name(), t,
                 common::LAMBDA)
             << "messages = " << msgs.to_string();
         common::Trace < common::DoubleTime >::trace().flush();

src/tests/pdevs/tests.cpp

@@ -40,10 +40,7 @@ TEST_CASE("pdevs/only_one", "run")
     paradevs::common::RootCoordinator <
         DoubleTime, paradevs::pdevs::Coordinator <
             DoubleTime,
-            paradevs::common::scheduler::HeapScheduler <
-                DoubleTime, SchedulerHandle >,
-            SchedulerHandle,
-            OnlyOneGraphManager < SchedulerHandle > >
+            OnlyOneGraphManager >
         > rc(0, 10, "root", paradevs::common::NoParameters(),
              paradevs::common::NoParameters());
 
@@ -83,10 +80,7 @@ TEST_CASE("pdevs/flat", "run")
     paradevs::common::RootCoordinator <
         DoubleTime, paradevs::pdevs::Coordinator <
             DoubleTime,
-            paradevs::common::scheduler::HeapScheduler <
-                DoubleTime, SchedulerHandle >,
-            SchedulerHandle,
-            FlatGraphManager < SchedulerHandle> >
+            FlatGraphManager >
         > rc(0, 10, "root", paradevs::common::NoParameters(),
              paradevs::common::NoParameters());
 
@@ -196,9 +190,6 @@ TEST_CASE("pdevs/hierachical", "run")
     paradevs::common::RootCoordinator <
         DoubleTime, paradevs::pdevs::Coordinator <
             DoubleTime,
-            paradevs::common::scheduler::HeapScheduler <
-                DoubleTime, SchedulerHandle >,
-            SchedulerHandle,
             RootGraphManager >
         > rc(0, 10, "root", paradevs::common::NoParameters(),
              paradevs::common::NoParameters());