branching/taggingDS-main

1 files changed, 1078 insertions, 0 deletions

diff --git a/modules/CIAO/CCF/CCF/IDL2/SemanticGraph/Elements.hpp b/modules/CIAO/CCF/CCF/IDL2/SemanticGraph/Elements.hpp
new file mode 100644
index 00000000000..1f0c850f25e
--- /dev/null
+++ b/modules/CIAO/CCF/CCF/IDL2/SemanticGraph/Elements.hpp
@@ -0,0 +1,1078 @@
+// file      : CCF/IDL2/SemanticGraph/Elements.hpp
+// author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
+// cvs-id    : $Id$
+
+#ifndef CCF_IDL2_SEMANTIC_GRAPH_ELEMENTS_HPP
+#define CCF_IDL2_SEMANTIC_GRAPH_ELEMENTS_HPP
+
+#include <set>
+#include <vector>
+#include <iosfwd>
+
+#include "Graph.hpp"
+
+#include "CCF/CompilerElements/FileSystem.hpp"
+#include "CCF/CompilerElements/Introspection.hpp"
+#include "CCF/CompilerElements/Context.hpp"
+
+#include "CCF/IDL2/SemanticGraph/Name.hpp"
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace SemanticGraph
+    {
+      //
+      //
+      typedef fs::path Path;
+
+      //
+      //
+      //
+
+      class Node;
+      class Edge;
+
+
+      // Node & Edge
+      //
+      //
+      class Edge : public virtual Introspection::Object
+      {
+      public:
+        CompilerElements::Context const&
+        context () const
+        {
+          return context_;
+        }
+
+        CompilerElements::Context&
+        context ()
+        {
+          return context_;
+        }
+
+      public:
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        virtual
+        ~Edge ();
+
+        Edge ();
+
+      private:
+        CompilerElements::Context context_;
+      };
+
+      inline bool
+      operator== (Edge const& x, Edge const& y)
+      {
+        return &x == &y;
+      }
+
+      class Node : public virtual Introspection::Object
+      {
+      public:
+        CompilerElements::Context const&
+        context () const
+        {
+          return context_;
+        }
+
+        CompilerElements::Context&
+        context ()
+        {
+          return context_;
+        }
+
+      public:
+        Path const&
+        file () const
+        {
+          return file_;
+        }
+
+        unsigned long
+        line () const
+        {
+          return line_;
+        }
+
+      public:
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        virtual
+        ~Node () = 0;
+
+        Node (Path const& path, unsigned long line);
+
+        Node (); // For virtual inheritance only.
+
+        // This is a bunch of experimantal sink functions that allow
+        // extensions in the form of one-way edges (see Executor stuff
+        // in CIDL for example).
+        //
+        void
+        add_edge_left (Edge&)
+        {
+        }
+
+        void
+        add_edge_right (Edge&)
+        {
+        }
+
+      private:
+        Path file_;
+        unsigned long line_;
+        CompilerElements::Context context_;
+      };
+
+      inline bool
+      operator== (Node const& x, Node const& y)
+      {
+        return &x == &y;
+      }
+
+
+      //
+      //
+      //
+      class Scope;
+      class Nameable;
+
+      class Names : public virtual Edge
+      {
+      public:
+        SimpleName
+        name () const
+        {
+          return name_;
+        }
+
+        Scope&
+        scope () const
+        {
+          return *scope_;
+        }
+
+        Nameable&
+        named () const
+        {
+          return *named_;
+        }
+
+      public:
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Names (SimpleName const& name)
+            : name_ (name)
+        {
+          type_info (static_type_info ());
+        }
+
+        void
+        set_left_node (Scope& n)
+        {
+          scope_ = &n;
+        }
+
+        void
+        set_right_node (Nameable& n)
+        {
+          named_ = &n;
+        }
+
+      private:
+        Scope* scope_;
+        Nameable* named_;
+        SimpleName name_;
+      };
+
+      class Defines : public virtual Names
+      {
+      public:
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Defines (SimpleName const& name)
+            : Names (name)
+        {
+          type_info (static_type_info ());
+        }
+      };
+
+
+      class Mentions : public virtual Names
+      {
+      public:
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Mentions (SimpleName const& name)
+            : Names (name)
+        {
+          type_info (static_type_info ());
+        }
+      };
+
+
+      class Aliases : public virtual Names
+      {
+      public:
+        SimpleName
+        synonym () const
+        {
+          return name ();
+        }
+
+        /*
+
+        Let me know if you need this function.
+
+        ScopedName
+        eponym () const
+        {
+        }
+        */
+
+      public:
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Aliases (SimpleName const& synonym)
+            : Names (synonym)
+
+        {
+          type_info (static_type_info ());
+        }
+      };
+
+
+      class Nameable : public virtual Node
+      {
+        typedef
+        std::vector<Names*>
+        Named_;
+
+      public:
+        virtual SimpleName
+        name () const;
+
+        virtual ScopedName
+        scoped_name () const;
+
+        bool
+        defined () const
+        {
+          return defined_;
+        }
+
+        typedef
+        Named_::const_iterator
+        NamedIterator;
+
+        NamedIterator
+        named_begin () const
+        {
+          return named_.begin ();
+        }
+
+        NamedIterator
+        named_end () const
+        {
+          return named_.end ();
+        }
+
+      public:
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Nameable () // For virtual inheritance only.
+        {
+          type_info (static_type_info ());
+        }
+
+        virtual
+        ~Nameable () = 0;
+
+        void
+        add_edge_right (Defines& e)
+        {
+          defined_ = true;
+          named_.push_back (&e);
+        }
+
+        void
+        add_edge_right (Names& e)
+        {
+          named_.push_back (&e);
+        }
+
+      private:
+        Named_ named_;
+        bool defined_;
+      };
+
+      typedef
+      std::set<Nameable*>
+      Nameables;
+
+      class Scope;
+
+      class Extends : public virtual Edge
+      {
+      public:
+        Scope& extender () const
+        {
+          return *extender_;
+        }
+
+        Scope& extendee () const
+        {
+          return *extendee_;
+        }
+
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Extends ()
+        {
+          type_info (static_type_info ());
+        }
+
+        void
+        set_left_node (Scope& s)
+        {
+          extender_ = &s;
+        }
+
+        void
+        set_right_node (Scope& s)
+        {
+          extendee_ = &s;
+        }
+
+      private:
+        Scope* extender_;
+        Scope* extendee_;
+      };
+
+      class Scope : public virtual Nameable
+      {
+      private:
+        typedef
+        std::vector<Extends*>
+        Extends_;
+
+        typedef
+        std::vector<Names*>
+        Names_;
+
+        typedef
+        std::map<SimpleName, Names_>
+        NamesMap_;
+
+      public:
+        //
+        //
+        typedef
+        Extends_::const_iterator
+        ExtendsIterator;
+
+        ExtendsIterator
+        extends_begin () const
+        {
+          return extends_.begin ();
+        }
+
+        ExtendsIterator
+        extends_end () const
+        {
+          return extends_.end ();
+        }
+
+
+        //
+        //
+        typedef
+        Names_::const_iterator
+        NamesIterator;
+
+        typedef
+        std::pair <NamesIterator, NamesIterator>
+        NamesIteratorPair;
+
+        NamesIterator
+        names_begin () const
+        {
+          return names_.begin ();
+        }
+
+        NamesIterator
+        names_end () const
+        {
+          return names_.end ();
+        }
+
+        NamesIteratorPair
+        find (SimpleName const& name) const
+        {
+          NamesMap_::const_iterator i (names_map_.find (name));
+          if (i == names_map_.end ())
+          {
+            return NamesIteratorPair (names_.end (), names_.end ());
+          }
+          else
+          {
+            return NamesIteratorPair (i->second.begin (), i->second.end ());
+          }
+        }
+
+        Nameables
+        lookup (Name const& name) const;
+
+        void
+        lookup (Name const& name, Nameables& result) const;
+
+      public:
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Scope () // For virtual inheritance only.
+        {
+          type_info (static_type_info ());
+        }
+
+        virtual
+        ~Scope () = 0;
+
+        void
+        add_edge_left (Names& e);
+
+        void
+        add_edge_left (Extends& e)
+        {
+          extends_.push_back (&e);
+        }
+
+        void
+        add_edge_right (Extends&)
+        {
+        }
+
+        using Nameable::add_edge_right;
+
+      private:
+        Extends_ extends_;
+
+        Names_ names_;
+        NamesMap_ names_map_;
+      };
+
+
+
+      //
+      //
+      //
+      class Belongs;
+      class ArgumentsWithType;
+
+      //@@ I can make an alias Classifies for Belongs?
+      //
+
+      class Type : public virtual Nameable
+      {
+      public:
+        virtual bool
+        complete () const = 0;
+
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Type () // For virtual inheritance only.
+        {
+          type_info (static_type_info ());
+        }
+
+        virtual
+        ~Type () = 0;
+
+        using Nameable::add_edge_right;
+
+        void
+        add_edge_right (Belongs& e)
+        {
+          slassifies_.push_back (&e);
+        }
+
+        void
+        add_edge_left (ArgumentsWithType&)
+        {
+        }
+
+        using Node::add_edge_right;
+        using Node::add_edge_left;
+
+      private:
+        typedef
+        std::vector<Belongs*>
+        Classifies_;
+
+        Classifies_ slassifies_;
+      };
+
+
+      class Instance : public virtual Node
+      {
+      public:
+        Belongs&
+        belongs () const
+        {
+          return *belongs_;
+        }
+
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Instance () // For virtual inheritance only.
+        {
+          type_info (static_type_info ());
+        }
+
+        virtual
+        ~Instance () = 0;
+
+        void
+        add_edge_left (Belongs& e)
+        {
+          belongs_ = &e;
+        }
+
+      private:
+        Belongs* belongs_;
+      };
+
+
+      class Belongs : public virtual Edge
+      {
+      public:
+        Instance&
+        instance () const
+        {
+          return *instance_;
+        }
+
+        Type&
+        type () const
+        {
+          return *type_;
+        }
+
+
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Belongs ()
+        {
+          type_info (static_type_info ());
+        }
+
+        void
+        set_left_node (Instance& n)
+        {
+          instance_ = &n;
+        }
+
+        void
+        set_right_node (Type& n)
+        {
+          type_ = &n;
+        }
+
+      private:
+        Instance* instance_;
+        Type* type_;
+      };
+
+
+      //
+      //
+      class Arguments;
+      class ArgumentsWithType;
+      class ArgumentsWithValue;
+
+      class Specialization: public virtual Type
+      {
+        typedef
+        std::vector<Arguments*>
+        Arguments_;
+
+      public:
+        typedef
+        Arguments_::const_iterator
+        ArgumentsIterator;
+
+        ArgumentsIterator
+        arguments_begin () const
+        {
+          return arguments_.begin ();
+        }
+
+        ArgumentsIterator
+        arguments_end () const
+        {
+          return arguments_.end ();
+        }
+
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Specialization () // For virtual inheritance only.
+        {
+          type_info (static_type_info ());
+        }
+
+        virtual
+        ~Specialization () = 0;
+
+        void
+        add_edge_right (ArgumentsWithType& e);
+
+        void
+        add_edge_right (ArgumentsWithValue& e);
+
+      private:
+        Arguments_ arguments_;
+      };
+
+
+      class Arguments: public virtual Edge
+      {
+      public:
+        Specialization&
+        specialization () const
+        {
+          return *specialization_;
+        }
+
+        Node&
+        argument () const
+        {
+          return *argument_;
+        }
+
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Arguments ()
+        {
+          type_info (static_type_info ());
+        }
+
+        void
+        set_left_node (Node& n)
+        {
+          argument_ = &n;
+        }
+
+        void
+        set_right_node (Specialization& n)
+        {
+          specialization_ = &n;
+        }
+
+      private:
+        Specialization* specialization_;
+        Node* argument_;
+      };
+
+      class ArgumentsWithType: public virtual Arguments
+      {
+      public:
+        Type&
+        type () const
+        {
+          return dynamic_cast<Type&> (argument ());
+        }
+
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        ArgumentsWithType ()
+        {
+          type_info (static_type_info ());
+        }
+
+        void
+        set_left_node (Type& n)
+        {
+          Arguments::set_left_node (n);
+        }
+      };
+
+      class Expression;
+
+      class ArgumentsWithValue: public virtual Arguments
+      {
+      public:
+        Expression&
+        value () const;
+
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        ArgumentsWithValue ()
+        {
+          type_info (static_type_info ());
+        }
+
+        void
+        set_left_node (Expression& n);
+      };
+
+      //
+      //
+      //
+      class IsA : public virtual Edge
+      {
+      public:
+        virtual Type&
+        subject () const
+        {
+          return *subject_;
+        }
+
+        virtual Type&
+        object () const
+        {
+          return *object_;
+        }
+
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        IsA ()
+        {
+          type_info (static_type_info ());
+        }
+
+        void
+        set_left_node (Type& n)
+        {
+          subject_ = &n;
+        }
+
+        void
+        set_right_node (Type& n)
+        {
+          object_ = &n;
+        }
+
+      private:
+        Type* subject_;
+        Type* object_;
+      };
+
+
+      //
+      //
+      //
+      class Inherits : public virtual IsA
+      {
+      public:
+        virtual Type&
+        inheritor () const
+        {
+          return subject ();
+        }
+
+        virtual Type&
+        inheritee () const
+        {
+          return object ();
+        }
+
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Inherits ()
+        {
+          type_info (static_type_info ());
+        }
+      };
+
+
+      //
+      //
+
+      class Expression;
+      class Const;
+
+      class Initializes: public virtual Edge
+      {
+      public:
+        Expression&
+        expression () const
+        {
+          return *expression_;
+        }
+
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Initializes ()
+        {
+          type_info (static_type_info ());
+        }
+
+        void
+        set_left_node (Expression& e)
+        {
+          expression_ = &e;
+        }
+
+        void
+        set_right_node (Const&)
+        {
+        }
+
+      private:
+        Expression* expression_;
+      };
+
+
+      class Expression: public virtual Node
+      {
+      public:
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Expression () // For virtual inheritance only.
+        {
+          type_info (static_type_info ());
+        }
+
+        virtual
+        ~Expression () = 0;
+
+        void
+        add_edge_left (Initializes&)
+        {
+        }
+
+        void
+        add_edge_left (ArgumentsWithValue&)
+        {
+        }
+      };
+
+
+      class Const: public virtual Instance,
+                   public virtual Nameable,
+                   public virtual Expression
+      {
+      public:
+        Initializes&
+        initialized () const
+        {
+          return *initialized_;
+        }
+
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Const () // For virtual inheritance only.
+        {
+          type_info (static_type_info ());
+        }
+
+        virtual
+        ~Const () = 0;
+
+        using Instance::add_edge_left;
+        using Expression::add_edge_left;
+
+        void
+        add_edge_right (Initializes& i)
+        {
+          initialized_ = &i;
+        }
+
+        using Nameable::add_edge_right;
+
+      private:
+        Initializes* initialized_;
+      };
+
+
+      //
+      //
+      //
+
+      class Container;
+
+      class Contains : public virtual Edge
+      {
+      public:
+        Node&
+        element () const
+        {
+          return *element_;
+        }
+
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Contains ()
+        {
+          type_info (static_type_info ());
+        }
+
+        void
+        set_left_node (Container& n)
+        {
+          container_ = &n;
+        }
+
+        void
+        set_right_node (Node& n)
+        {
+          element_ = &n;
+        }
+
+      private:
+        Container* container_;
+        Node* element_;
+      };
+
+
+      class Container : public virtual Node
+      {
+        typedef
+        std::vector<Contains*>
+        Contains_;
+
+      public:
+        typedef
+        Contains_::const_iterator
+        ContainsIterator;
+
+        ContainsIterator
+        contains_begin () const
+        {
+          return contains_.begin ();
+        }
+
+        ContainsIterator
+        contains_end () const
+        {
+          return contains_.end ();
+        }
+
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      protected:
+        friend class Graph<Node, Edge>;
+
+        Container () // For virtual inheritance only.
+        {
+          type_info (static_type_info ());
+        }
+
+        virtual
+        ~Container () = 0;
+
+        void
+        add_edge_left (Contains& e)
+        {
+          contains_.push_back (&e);
+        }
+
+      private:
+        Contains_ contains_;
+      };
+    }
+  }
+}
+
+// ADL won't find it because Path is a typedef. Note that this
+// function prints in native format.
+//
+std::ostream&
+operator<< (std::ostream& os, CCF::IDL2::SemanticGraph::Path const& path);
+
+#include "CCF/IDL2/SemanticGraph/Elements.tpp"
+
+#endif  // CCF_IDL2_SEMANTIC_GRAPH_ELEMENTS_HPP