initial implementation

src/reactor/AbstractEventProcessor.cpp

@@ -0,0 +1,93 @@
+/* @file AbstractEventProcessor.cp */
+
+#include "AbstractEventProcessor.hpp"
+#include "xo/indentlog/print/tostr.hpp"
+#include <unordered_map>
+#include <map>
+
+namespace xo {
+    using ref::rp;
+    using ref::brw;
+    using xo::tostr;
+    using std::uint32_t;
+
+    namespace reactor {
+        namespace {
+            /* search all event processors ep reachable (dowstream) from x,
+             * add to *m;
+             */
+            void
+            map_network_helper(brw<AbstractEventProcessor> x,
+                               uint32_t * tsort_ix,
+                               std::unordered_map<AbstractEventProcessor*, uint32_t> * m)
+            {
+                if (m->contains(x.get()))
+                    return;
+
+                auto fn = [tsort_ix, m]
+                    (brw<AbstractEventProcessor> ep)
+                    {
+                        map_network_helper(ep, tsort_ix, m);
+                    };
+
+                x->visit_direct_consumers(fn);
+
+                /* postorder! */
+                (*m)[x.get()] = ++(*tsort_ix);
+
+            } /*map_network_helper*/
+        } /*namespace*/
+
+        std::vector<rp<AbstractEventProcessor>>
+        AbstractEventProcessor::map_network(rp<AbstractEventProcessor> const & x)
+        {
+            std::unordered_map<AbstractEventProcessor *, std::uint32_t> network_map;
+
+            /* index event processors in reverse topological order:
+             * if B is (directly or indirectly) downstream from A,
+             * then tsort_ix(B) < tsort_ix(A)
+             */
+            uint32_t tsort_ix = 0;
+
+            /* depth-first traversal,  detect and short-circuit on dup paths */
+            map_network_helper(x.borrow(), &tsort_ix, &network_map);
+
+            /* invariant: tsort_ix = #of event processors in network */
+            uint32_t n = tsort_ix;
+
+            /* network_map, now in a topologically sorted order */
+            std::map<uint32_t, AbstractEventProcessor *> tsorted_map;
+            {
+                for(auto const & x : network_map) {
+                    uint32_t tsort_ix = x.second;
+                    AbstractEventProcessor * ep = x.first;
+
+                    tsorted_map[n - tsort_ix] = ep;
+                }
+            }
+
+            std::vector<rp<AbstractEventProcessor>> retval;
+            {
+                for(auto const & x : tsorted_map)
+                    retval.push_back(x.second);
+            }
+
+            return retval;
+        } /*map_network*/
+
+        void
+        AbstractEventProcessor::display(std::ostream & os) const
+        {
+            os << "<AbstractSource>";
+        } /*display*/
+
+        std::string
+        AbstractEventProcessor::display_string() const
+        {
+            return tostr(*this);
+        } /*display_string*/
+
+    } /*namespace reactor*/
+} /*namespace xo*/
+
+/* end AbstractEventProcessor.cpp */