diff options
Diffstat (limited to 'modules/CIAO/CCF/Example/ComponentDeploymentDescriptor/Traversal.hpp')
| -rw-r--r-- | modules/CIAO/CCF/Example/ComponentDeploymentDescriptor/Traversal.hpp | 386 |
1 files changed, 386 insertions, 0 deletions
diff --git a/modules/CIAO/CCF/Example/ComponentDeploymentDescriptor/Traversal.hpp b/modules/CIAO/CCF/Example/ComponentDeploymentDescriptor/Traversal.hpp new file mode 100644 index 00000000000..2b6697abae9 --- /dev/null +++ b/modules/CIAO/CCF/Example/ComponentDeploymentDescriptor/Traversal.hpp @@ -0,0 +1,386 @@ +// file : CCF/Example/ComponentDeploymentDescriptor/Traversal.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef CDD_TRAVERSAL_HPP +#define CDD_TRAVERSAL_HPP + +#include <map> +#include <vector> + +#include "CCF/CompilerElements/Introspection.hpp" + +#include "SyntaxTree.hpp" + +namespace CDD +{ + namespace Traversal + { + // + // + // + class TraverserInterface + { + protected: + virtual + ~TraverserInterface () + { + } + + virtual void + traverse (SyntaxTree::NodePtr const& n) = 0; + + friend class Dispatcher; + }; + + + // + // + // + class Dispatcher + { + public: + virtual + ~Dispatcher () + { + } + + virtual void + dispatch (SyntaxTree::NodePtr const& n); + + protected: + + class Ambiguous {}; + + void + map (Introspection::TypeId id, + TraverserInterface* t, + bool suppress_ambiguity = false) + throw (Ambiguous) + { + if (!traversal_map_.insert (std::make_pair (id, t)).second) + { + if (suppress_ambiguity) + { + traversal_map_[id].suppressed = true; + } + else + { + throw Ambiguous (); + } + } + } + + private: + + struct TraverserDescriptor + { + TraverserDescriptor (TraverserInterface* t = 0) + : traverser (t), + suppressed (false) + { + } + + TraverserInterface* traverser; + bool suppressed; + }; + + typedef + std::map<Introspection::TypeId, TraverserDescriptor> + TraversalMap; + + public: + typedef + TraversalMap::const_iterator + Iterator; + + Iterator + begin () const + { + return traversal_map_.begin (); + } + + Iterator + end () const + { + return traversal_map_.end (); + } + + private: + TraversalMap traversal_map_; + }; + + + // + // + // + class Discriminator : public virtual Dispatcher + { + public: + virtual void + add (Dispatcher* d) throw (Ambiguous) + { + for (Iterator i = d->begin (); i != d->end (); i++) + { + map (i->first, i->second.traverser, true); + } + } + }; + + + // + // + // + class Traverser : public TraverserInterface, + public virtual Dispatcher + { + public: + virtual void + add_delegate (Dispatcher* d) + { + delegates_.push_back (d); + } + + protected: + virtual bool + delegate (SyntaxTree::NodePtr const& n) const + { + if (delegates_.empty ()) return false; + + for (DispatcherList::const_iterator i = delegates_.begin (); + i != delegates_.end (); + i++) + { + (*i)->dispatch (n); + } + + return true; + } + + protected: + typedef + std::vector<Dispatcher*> + DispatcherList; + + DispatcherList delegates_; + }; + + + // + // + // + struct PortInstance : Traverser + { + typedef + SyntaxTree::PortInstancePtr + NodePtr; + + PortInstance () + { + map (typeid (SyntaxTree::PortInstance), this); + } + + virtual void + traverse (SyntaxTree::NodePtr const& n) + { + traverse (n->dynamic_type<SyntaxTree::PortInstance> ()); + } + + virtual void + traverse (NodePtr const& n) + { + delegate (n); + } + }; + + + // + // + // + struct ComponentInstance : Traverser + { + public: + + virtual void + add_port_delegate (Dispatcher* d) + { + port_delegates_.push_back (d); + } + + public: + typedef + SyntaxTree::ComponentInstancePtr + NodePtr; + + ComponentInstance () + { + map (typeid (SyntaxTree::ComponentInstance), this); + } + + virtual void + traverse (SyntaxTree::NodePtr const& n) + { + traverse (n->dynamic_type<SyntaxTree::ComponentInstance> ()); + } + + virtual void + traverse (NodePtr const& n) + { + if (!delegate (n)) + { + pre (n); + ports (n); + post (n); + } + } + + virtual void + pre (NodePtr const&) + { + } + + virtual void + ports (NodePtr const& n) + { + delegate_port (n); + } + + virtual void + post (NodePtr const&) + { + } + + protected: + virtual void + delegate_port (NodePtr const& s) + { + for (SyntaxTree::ComponentInstance::Iterator n = s->begin (); + n != s->end (); + n++) + { + dispatch (*n); + + for (DispatcherList::const_iterator i = port_delegates_.begin (); + i != port_delegates_.end (); + i++) + { + (*i)->dispatch (*n); + } + } + } + + protected: + DispatcherList port_delegates_; + }; + + + // + // + // + struct Connection : Traverser + { + typedef + SyntaxTree::ConnectionPtr + NodePtr; + + Connection () + { + map (typeid (SyntaxTree::Connection), this); + } + + virtual void + traverse (SyntaxTree::NodePtr const& n) + { + traverse (n->dynamic_type<SyntaxTree::Connection> ()); + } + + virtual void + traverse (NodePtr const& n) + { + delegate (n); + } + }; + + + // + // + // + struct Descriptor : Traverser + { + public: + + virtual void + add_node_delegate (Dispatcher* d) + { + node_delegates_.push_back (d); + } + + public: + typedef + SyntaxTree::DescriptorPtr + NodePtr; + + Descriptor () + { + map (typeid (SyntaxTree::Descriptor), this); + } + + virtual void + traverse (SyntaxTree::NodePtr const& n) + { + traverse (n->dynamic_type<SyntaxTree::Descriptor> ()); + } + + virtual void + traverse (NodePtr const& n) + { + if (!delegate (n)) + { + pre (n); + ports (n); + post (n); + } + } + + virtual void + pre (NodePtr const&) + { + } + + virtual void + ports (NodePtr const& n) + { + delegate_node (n); + } + + virtual void + post (NodePtr const&) + { + } + + protected: + virtual void + delegate_node (NodePtr const& s) + { + for (SyntaxTree::Descriptor::Iterator n = s->begin (); + n != s->end (); + n++) + { + dispatch (*n); + + for (DispatcherList::const_iterator i = node_delegates_.begin (); + i != node_delegates_.end (); + i++) + { + (*i)->dispatch (*n); + } + } + } + + protected: + DispatcherList node_delegates_; + }; + } +} + +#endif // CDD_TRAVERSAL_HPP |