remerge

1 files changed, 411 insertions, 0 deletions

diff --git a/libxsd-frontend/xsd-frontend/traversal/elements.hxx b/libxsd-frontend/xsd-frontend/traversal/elements.hxx
new file mode 100644
index 0000000..bd1dd70
--- /dev/null
+++ b/libxsd-frontend/xsd-frontend/traversal/elements.hxx
@@ -0,0 +1,411 @@
+// file      : xsd-frontend/traversal/elements.hxx
+// copyright : Copyright (c) 2005-2014 Code Synthesis Tools CC
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+#ifndef XSD_FRONTEND_TRAVERSAL_ELEMENTS_HXX
+#define XSD_FRONTEND_TRAVERSAL_ELEMENTS_HXX
+
+#include <cutl/compiler/traversal.hxx>
+
+#include <xsd-frontend/types.hxx>
+#include <xsd-frontend/semantic-graph/elements.hxx>
+
+namespace XSDFrontend
+{
+  namespace Traversal
+  {
+    using namespace cutl;
+
+    typedef compiler::dispatcher<SemanticGraph::Node> NodeDispatcher;
+    typedef compiler::dispatcher<SemanticGraph::Edge> EdgeDispatcher;
+
+    //
+    //
+    struct NodeBase: NodeDispatcher, EdgeDispatcher
+    {
+      void
+      edge_traverser (EdgeDispatcher& d)
+      {
+        EdgeDispatcher::traverser (d);
+      }
+
+      EdgeDispatcher&
+      edge_traverser ()
+      {
+        return *this;
+      }
+
+      using NodeDispatcher::dispatch;
+      using EdgeDispatcher::dispatch;
+
+      using EdgeDispatcher::iterate_and_dispatch;
+    };
+
+    struct EdgeBase: EdgeDispatcher, NodeDispatcher
+    {
+      void
+      node_traverser (NodeDispatcher& d)
+      {
+        NodeDispatcher::traverser (d);
+      }
+
+      NodeDispatcher&
+      node_traverser ()
+      {
+        return *this;
+      }
+
+      using EdgeDispatcher::dispatch;
+      using NodeDispatcher::dispatch;
+
+      using NodeDispatcher::iterate_and_dispatch;
+    };
+
+    inline EdgeBase&
+    operator>> (NodeBase& n, EdgeBase& e)
+    {
+      n.edge_traverser (e);
+      return e;
+    }
+
+    inline NodeBase&
+    operator>> (EdgeBase& e, NodeBase& n)
+    {
+      e.node_traverser (n);
+      return n;
+    }
+
+    //
+    //
+    template <typename T>
+    struct Node: compiler::traverser_impl<T, SemanticGraph::Node>,
+                 virtual NodeBase
+    {
+      typedef T Type;
+    };
+
+    template <typename T>
+    struct Edge: compiler::traverser_impl<T, SemanticGraph::Edge>,
+                 virtual EdgeBase
+    {
+      typedef T Type;
+    };
+
+    //
+    // Edges
+    //
+
+    //
+    //
+    struct Names : Edge<SemanticGraph::Names>
+    {
+      Names ()
+      {
+      }
+
+      Names (NodeBase& n)
+      {
+        node_traverser (n);
+      }
+
+      virtual void
+      traverse (Type& e)
+      {
+        dispatch (e.named ());
+      }
+    };
+
+
+    //
+    //
+    struct Belongs : Edge<SemanticGraph::Belongs>
+    {
+      Belongs ()
+      {
+      }
+
+      Belongs (NodeBase& n)
+      {
+        node_traverser (n);
+      }
+
+      virtual void
+      traverse (Type& e)
+      {
+        dispatch (e.type ());
+      }
+    };
+
+    //
+    // Nodes
+    //
+
+    //
+    //
+    struct Nameable : Node<SemanticGraph::Nameable>
+    {
+    };
+
+
+    //
+    //
+    template <typename T>
+    struct ScopeTemplate : Node<T>
+    {
+    public:
+      virtual void
+      traverse (T& s)
+      {
+        names (s);
+      }
+
+      template<typename X>
+      void
+      names (T& s,
+             EdgeDispatcher& d,
+             void (X::*pre_) (T&) = (void (ScopeTemplate<T>::*)(T&)) (0),
+             void (X::*post_) (T&) = (void (ScopeTemplate<T>::*)(T&)) (0),
+             void (X::*none_) (T&) = (void (ScopeTemplate<T>::*)(T&)) (0),
+             void (X::*next_) (T&) = (void (ScopeTemplate<T>::*)(T&)) (0))
+      {
+        X* this_ (dynamic_cast<X*> (this));
+
+        typename T::NamesIterator b (s.names_begin ()), e (s.names_end ());
+
+        if (b != e)
+        {
+          if (pre_)
+            (this_->*pre_) (s);
+
+          //iterate_and_dispatch (b, e, d, *this_, next_, s);
+
+          for (; b != s.names_end ();)
+          {
+            d.dispatch (*b);
+
+            if (++b != s.names_end () && next_ != 0)
+              (this_->*next_) (s);
+          }
+
+          if (post_)
+            (this_->*post_) (s);
+        }
+        else
+        {
+          if (none_)
+            (this_->*none_) (s);
+        }
+      }
+
+      virtual void
+      names (T& s, EdgeDispatcher& d)
+      {
+        names<ScopeTemplate<T> > (s, d);
+      }
+
+      virtual void
+      names (T& s)
+      {
+        names (s,
+               *this,
+               &ScopeTemplate<T>::names_pre,
+               &ScopeTemplate<T>::names_post,
+               &ScopeTemplate<T>::names_none,
+               &ScopeTemplate<T>::names_next);
+      }
+
+      virtual void
+      names_pre (T&)
+      {
+      }
+
+      virtual void
+      names_next (T&)
+      {
+      }
+
+      virtual void
+      names_post (T&)
+      {
+      }
+
+      virtual void
+      names_none (T&)
+      {
+      }
+    };
+
+
+    //
+    //
+    typedef
+    ScopeTemplate<SemanticGraph::Scope>
+    Scope;
+
+
+    //
+    //
+    struct Type : Node<SemanticGraph::Type>
+    {
+      virtual void
+      traverse (SemanticGraph::Type&) = 0;
+    };
+
+
+    //
+    //
+    struct Instance : Node<SemanticGraph::Instance>
+    {
+      virtual void
+      traverse (Type&);
+
+      virtual void
+      pre (Type&);
+
+      virtual void
+      belongs (Type&, EdgeDispatcher&);
+
+      virtual void
+      belongs (Type&);
+
+      virtual void
+      post (Type&);
+    };
+
+
+    //
+    //
+    struct Member : Node<SemanticGraph::Member>
+    {
+      virtual void
+      traverse (Type&);
+
+      virtual void
+      pre (Type&);
+
+      virtual void
+      belongs (Type&, EdgeDispatcher&);
+
+      virtual void
+      belongs (Type&);
+
+      virtual void
+      post (Type&);
+    };
+
+
+    //
+    //
+    struct Inherits : Edge<SemanticGraph::Inherits>
+    {
+      Inherits ()
+      {
+      }
+
+      Inherits (NodeBase& n)
+      {
+        node_traverser (n);
+      }
+
+      virtual void
+      traverse (Type& e)
+      {
+        dispatch (e.base ());
+      }
+    };
+
+
+    //
+    //
+    struct Extends : Edge<SemanticGraph::Extends>
+    {
+      Extends ()
+      {
+      }
+
+      Extends (NodeBase& n)
+      {
+        node_traverser (n);
+      }
+
+      virtual void
+      traverse (Type& e)
+      {
+        dispatch (e.base ());
+      }
+    };
+
+
+    //
+    //
+    struct Restricts : Edge<SemanticGraph::Restricts>
+    {
+      Restricts ()
+      {
+      }
+
+      Restricts (NodeBase& n)
+      {
+        node_traverser (n);
+      }
+
+      virtual void
+      traverse (Type& e)
+      {
+        dispatch (e.base ());
+      }
+    };
+
+
+    //
+    //
+    struct Argumented : Edge<SemanticGraph::Arguments>
+    {
+      Argumented ()
+      {
+      }
+
+      Argumented (NodeBase& n)
+      {
+        node_traverser (n);
+      }
+
+      virtual void
+      traverse (Type& a)
+      {
+        dispatch (a.type ());
+      }
+    };
+
+
+    /*
+    //
+    //
+    struct Contains : Edge<SemanticGraph::Contains>
+    {
+      virtual void
+      traverse (Type& e)
+      {
+        dispatch (e.element ());
+      }
+    };
+    */
+
+    //
+    //
+    typedef
+    Node<SemanticGraph::AnyType>
+    AnyType;
+
+
+    //
+    //
+    typedef
+    Node<SemanticGraph::AnySimpleType>
+    AnySimpleType;
+  }
+}
+
+#include <xsd-frontend/traversal/elements.txx>
+
+#endif  // XSD_FRONTEND_TRAVERSAL_ELEMENTS_HXX