From cf80396f8b6147e9048c1f3bd50b3086f754d037 Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Mon, 29 Mar 2010 14:29:02 +0200
Subject: Implement semantic graph traversal mechanism

---
 odb/traversal/elements.hxx | 241 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 241 insertions(+)
 create mode 100644 odb/traversal/elements.hxx

(limited to 'odb/traversal/elements.hxx')

diff --git a/odb/traversal/elements.hxx b/odb/traversal/elements.hxx
new file mode 100644
index 0000000..be21b63
--- /dev/null
+++ b/odb/traversal/elements.hxx
@@ -0,0 +1,241 @@
+// file      : odb/traversal/elements.hxx
+// author    : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2009-2010 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_TRAVERSAL_ELEMENTS_HXX
+#define ODB_TRAVERSAL_ELEMENTS_HXX
+
+#include <cutl/compiler/traversal.hxx>
+
+#include <semantics/elements.hxx>
+
+namespace traversal
+{
+  using namespace cutl;
+
+  //
+  //
+  typedef compiler::dispatcher<semantics::node> node_dispatcher;
+  typedef compiler::dispatcher<semantics::edge> edge_dispatcher;
+
+  //
+  //
+  struct node_base: node_dispatcher, edge_dispatcher
+  {
+    void
+    edge_traverser (edge_dispatcher& d)
+    {
+      edge_dispatcher::traverser (d);
+    }
+
+    edge_dispatcher&
+    edge_traverser ()
+    {
+      return *this;
+    }
+
+    using node_dispatcher::dispatch;
+    using edge_dispatcher::dispatch;
+
+    using edge_dispatcher::iterate_and_dispatch;
+  };
+
+  struct edge_base: edge_dispatcher, node_dispatcher
+  {
+    void
+    node_traverser (node_dispatcher& d)
+    {
+      node_dispatcher::traverser (d);
+    }
+
+    node_dispatcher&
+    node_traverser ()
+    {
+      return *this;
+    }
+
+    using edge_dispatcher::dispatch;
+    using node_dispatcher::dispatch;
+
+    using node_dispatcher::iterate_and_dispatch;
+  };
+
+  inline edge_base&
+  operator>> (node_base& n, edge_base& e)
+  {
+    n.edge_traverser (e);
+    return e;
+  }
+
+  inline node_base&
+  operator>> (edge_base& e, node_base& n)
+  {
+    e.node_traverser (n);
+    return n;
+  }
+
+  //
+  //
+  template <typename X>
+  struct node: compiler::traverser_impl<X, semantics::node>,
+               virtual node_base
+  {
+  };
+
+  template <typename X>
+  struct edge: compiler::traverser_impl<X, semantics::edge>,
+               virtual edge_base
+  {
+  };
+
+  //
+  // Edges
+  //
+
+  struct names: edge<semantics::names>
+  {
+    names ()
+    {
+    }
+
+    names (node_dispatcher& n)
+    {
+      node_traverser (n);
+    }
+
+    virtual void
+    traverse (type&);
+  };
+
+  struct declares: edge<semantics::declares>
+  {
+    declares ()
+    {
+    }
+
+    declares (node_dispatcher& n)
+    {
+      node_traverser (n);
+    }
+
+    virtual void
+    traverse (type&);
+  };
+
+  struct defines: edge<semantics::defines>
+  {
+    defines ()
+    {
+    }
+
+    defines (node_dispatcher& n)
+    {
+      node_traverser (n);
+    }
+
+    virtual void
+    traverse (type&);
+  };
+
+  struct typedefs: edge<semantics::typedefs>
+  {
+    typedefs ()
+    {
+    }
+
+    typedefs (node_dispatcher& n)
+    {
+      node_traverser (n);
+    }
+
+    virtual void
+    traverse (type&);
+  };
+
+  struct belongs: edge<semantics::belongs>
+  {
+    belongs ()
+    {
+    }
+
+    belongs (node_dispatcher& n)
+    {
+      node_traverser (n);
+    }
+
+    virtual void
+    traverse (type&);
+  };
+
+  //
+  // Nodes
+  //
+
+  struct nameable: node<semantics::nameable> {};
+
+  //
+  //
+  template <typename T>
+  struct scope_template: node<T>
+  {
+  public:
+    virtual void
+    traverse (T& s)
+    {
+      names (s);
+    }
+
+    virtual void
+    names (T& s)
+    {
+      names (s, *this);
+    }
+
+    virtual void
+    names (T& s, edge_dispatcher& d)
+    {
+      iterate_and_dispatch (s.names_begin (), s.names_end (), d);
+    }
+  };
+
+  struct scope: scope_template<semantics::scope> {};
+
+  //
+  //
+  struct type: node<semantics::type> {};
+
+  //
+  //
+  struct instance: node<semantics::instance>
+  {
+    virtual void
+    traverse (type&);
+
+    virtual void
+    belongs (type&);
+
+    virtual void
+    belongs (type&, edge_dispatcher&);
+  };
+
+  //
+  //
+  struct data_member: node<semantics::data_member>
+  {
+    virtual void
+    traverse (type&);
+
+    virtual void
+    belongs (type&);
+
+    virtual void
+    belongs (type&, edge_dispatcher&);
+  };
+
+  //
+  //
+  struct unsupported_type: node<semantics::unsupported_type> {};
+}
+
+#endif // ODB_TRAVERSAL_ELEMENTS_HXX
-- 
cgit v1.1