diff options
Diffstat (limited to 'modules/CIAO/CCF/CCF/IDL3/Traversal')
| -rw-r--r-- | modules/CIAO/CCF/CCF/IDL3/Traversal/Component.cpp | 128 | ||||
| -rw-r--r-- | modules/CIAO/CCF/CCF/IDL3/Traversal/Component.hpp | 319 | ||||
| -rw-r--r-- | modules/CIAO/CCF/CCF/IDL3/Traversal/Component.tpp | 195 | ||||
| -rw-r--r-- | modules/CIAO/CCF/CCF/IDL3/Traversal/Elements.hpp | 21 | ||||
| -rw-r--r-- | modules/CIAO/CCF/CCF/IDL3/Traversal/EventType.hpp | 90 | ||||
| -rw-r--r-- | modules/CIAO/CCF/CCF/IDL3/Traversal/EventType.tpp | 151 | ||||
| -rw-r--r-- | modules/CIAO/CCF/CCF/IDL3/Traversal/Home.cpp | 381 | ||||
| -rw-r--r-- | modules/CIAO/CCF/CCF/IDL3/Traversal/Home.hpp | 219 |
8 files changed, 1504 insertions, 0 deletions
diff --git a/modules/CIAO/CCF/CCF/IDL3/Traversal/Component.cpp b/modules/CIAO/CCF/CCF/IDL3/Traversal/Component.cpp new file mode 100644 index 00000000000..1519650415c --- /dev/null +++ b/modules/CIAO/CCF/CCF/IDL3/Traversal/Component.cpp @@ -0,0 +1,128 @@ +// file : CCF/IDL3/Traversal/Component.cpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#include "CCF/IDL3/SemanticGraph/EventType.hpp" + +#include "CCF/IDL3/Traversal/Component.hpp" + +namespace CCF +{ + namespace IDL3 + { + namespace Traversal + { + // Component + // + // + void Component:: + traverse (Type& c) + { + pre (c); + name (c); + inherits (c); + supports (c); + names (c); + post (c); + } + + void Component:: + pre (Type&) + { + } + + void Component:: + name (Type&) + { + } + + void Component:: + inherits (Type& c, EdgeDispatcherBase& d) + { + if (SemanticGraph::Inherits* inh = c.inherits ()) + { + d.traverse (*inh); + } + } + + void Component:: + inherits (Type& c) + { + if (SemanticGraph::Inherits* inh = c.inherits ()) + { + inherits_pre (c); + edge_traverser ().traverse (*inh); + inherits_post (c); + } + else + { + inherits_none (c); + } + } + + void Component:: + inherits_pre (Type&) + { + } + + void Component:: + inherits_post (Type&) + { + } + + void Component:: + inherits_none (Type&) + { + } + + void Component:: + supports (Type& c, EdgeDispatcherBase& d) + { + iterate_and_traverse (c.supports_begin (), c.supports_end (), d); + } + + void Component:: + supports (Type& c) + { + Type::SupportsIterator b (c.supports_begin ()), e (c.supports_end ()); + + if (b != e) + { + supports_pre (c); + iterate_and_traverse ( + b, e, edge_traverser (), *this, &Component::comma, c); + supports_post (c); + } + else + { + supports_none (c); + } + } + + void Component:: + supports_pre (Type&) + { + } + + void Component:: + supports_post (Type&) + { + } + + void Component:: + supports_none (Type&) + { + } + + void Component:: + post (Type&) + { + } + + void Component:: + comma (Type&) + { + } + } + } +} diff --git a/modules/CIAO/CCF/CCF/IDL3/Traversal/Component.hpp b/modules/CIAO/CCF/CCF/IDL3/Traversal/Component.hpp new file mode 100644 index 00000000000..ebc0f79c704 --- /dev/null +++ b/modules/CIAO/CCF/CCF/IDL3/Traversal/Component.hpp @@ -0,0 +1,319 @@ +// file : CCF/IDL3/Traversal/Component.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef CCF_IDL3_TRAVERSAL_COMPONENT_HPP +#define CCF_IDL3_TRAVERSAL_COMPONENT_HPP + +#include "CCF/IDL3/SemanticGraph/Component.hpp" +#include "CCF/IDL3/Traversal/Elements.hpp" + +namespace CCF +{ + namespace IDL3 + { + namespace Traversal + { + template <typename T> + struct PortTemplate : Node<T> + { + /* GCC#13590/DR#39 + using Node<T>::edge_traverser; + */ + + virtual void + traverse (T&); + }; + + template <typename T> + struct PortAccessorTemplate : Node<T> + { + /* GCC#13590/DR#39 + using Node<T>::edge_traverser; + */ + + virtual void + traverse (T&); + + virtual void + pre (T&); + + virtual void + returns (T&, EdgeDispatcherBase&); + + virtual void + returns (T&); + + virtual void + name (T&); + + virtual void + receives (T&, EdgeDispatcherBase&); + + virtual void + receives (T&); + + virtual void + receives_pre (T&); + + virtual void + receives_post (T&); + + virtual void + raises (T&, EdgeDispatcherBase&); + + virtual void + raises (T&); + + virtual void + raises_pre (T&); + + virtual void + raises_post (T&); + + virtual void + post (T&); + }; + + template <typename T> + struct PortGetTemplate : PortAccessorTemplate<T> + { + /* GCC#13590/DR#39 + using Node<T>::edge_traverser; + */ + + virtual void + returns (T&); + }; + + template <typename T> + struct PortSetTemplate : PortAccessorTemplate<T> + { + /* GCC#13590/DR#39 + using Node<T>::edge_traverser; + */ + + virtual void + receives (T&); + }; + + template <typename T> + struct PortDataTemplate : Node<T> + { + /* GCC#13590/DR#39 + using Node<T>::edge_traverser; + */ + + virtual void + traverse (T&); + + virtual void + pre (T&); + + virtual void + belongs (T&, EdgeDispatcherBase&); + + virtual void + belongs (T&); + + virtual void + name (T&); + + virtual void + post (T&); + }; + + // + // + // + typedef + PortTemplate<SemanticGraph::Provider> + Provider; + + typedef + PortGetTemplate<SemanticGraph::Provider> + ProviderGet; + + typedef + PortSetTemplate<SemanticGraph::Provider> + ProviderSet; + + typedef + PortDataTemplate<SemanticGraph::Provider> + ProviderData; + + // + // + // + typedef + PortTemplate<SemanticGraph::User> + User; + + typedef + PortGetTemplate<SemanticGraph::User> + UserGet; + + typedef + PortSetTemplate<SemanticGraph::User> + UserSet; + + typedef + PortDataTemplate<SemanticGraph::User> + UserData; + + + // + // + // + typedef + PortTemplate<SemanticGraph::MultiUser> + MultiUser; + + typedef + PortGetTemplate<SemanticGraph::MultiUser> + MultiUserGet; + + typedef + PortSetTemplate<SemanticGraph::MultiUser> + MultiUserSet; + + typedef + PortDataTemplate<SemanticGraph::MultiUser> + MultiUserData; + + + // + // + // + typedef + PortTemplate<SemanticGraph::SingleUser> + SingleUser; + + typedef + PortGetTemplate<SemanticGraph::SingleUser> + SingleUserGet; + + typedef + PortSetTemplate<SemanticGraph::SingleUser> + SingleUserSet; + + typedef + PortDataTemplate<SemanticGraph::SingleUser> + SingleUserData; + + + // + // + // + typedef + PortTemplate<SemanticGraph::Publisher> + Publisher; + + typedef + PortGetTemplate<SemanticGraph::Publisher> + PublisherGet; + + typedef + PortSetTemplate<SemanticGraph::Publisher> + PublisherSet; + + typedef + PortDataTemplate<SemanticGraph::Publisher> + PublisherData; + + // + // + // + typedef + PortTemplate<SemanticGraph::Emitter> + Emitter; + + typedef + PortGetTemplate<SemanticGraph::Emitter> + EmitterGet; + + typedef + PortSetTemplate<SemanticGraph::Emitter> + EmitterSet; + + typedef + PortDataTemplate<SemanticGraph::Emitter> + EmitterData; + + + // + // + // + typedef + PortTemplate<SemanticGraph::Consumer> + Consumer; + + typedef + PortGetTemplate<SemanticGraph::Consumer> + ConsumerGet; + + typedef + PortSetTemplate<SemanticGraph::Consumer> + ConsumerSet; + + typedef + PortDataTemplate<SemanticGraph::Consumer> + ConsumerData; + + // + // + // + struct Component : ScopeTemplate<SemanticGraph::Component> + { + virtual void + traverse (Type&); + + virtual void + pre (Type&); + + virtual void + name (Type&); + + virtual void + inherits (Type&, EdgeDispatcherBase&); + + virtual void + inherits (Type&); + + virtual void + inherits_pre (Type&); + + virtual void + inherits_post (Type&); + + virtual void + inherits_none (Type&); + + virtual void + supports (Type&, EdgeDispatcherBase&); + + virtual void + supports (Type&); + + virtual void + supports_pre (Type&); + + virtual void + supports_post (Type&); + + virtual void + supports_none (Type&); + + virtual void + post (Type&); + + virtual void + comma (Type&); + }; + } + } +} + +#include "CCF/IDL3/Traversal/Component.tpp" + +#endif // CCF_IDL3_TRAVERSAL_COMPONENT_HPP diff --git a/modules/CIAO/CCF/CCF/IDL3/Traversal/Component.tpp b/modules/CIAO/CCF/CCF/IDL3/Traversal/Component.tpp new file mode 100644 index 00000000000..fc74e4c717b --- /dev/null +++ b/modules/CIAO/CCF/CCF/IDL3/Traversal/Component.tpp @@ -0,0 +1,195 @@ +// file : CCF/IDL3/Traversal/Component.tpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace CCF +{ + namespace IDL3 + { + namespace Traversal + { + // + // + // + template <typename T> + void PortTemplate<T>:: + traverse (T& p) + { + this->edge_traverser ().traverse (p.belongs ()); + } + + + // PortAccessorTemplate + // + // + template <typename T> + void PortAccessorTemplate<T>:: + traverse (T& p) + { + pre (p); + returns (p); + name (p); + receives (p); + raises (p); + post (p); + } + + template <typename T> + void PortAccessorTemplate<T>:: + pre (T&) + { + } + + template <typename T> + void PortAccessorTemplate<T>:: + returns (T& p, EdgeDispatcherBase& d) + { + d.traverse (p.belongs ()); + } + + template <typename T> + void PortAccessorTemplate<T>:: + returns (T&) + { + } + + template <typename T> + void PortAccessorTemplate<T>:: + name (T&) + { + } + + template <typename T> + void PortAccessorTemplate<T>:: + receives (T& p, EdgeDispatcherBase& d) + { + // @@ Still thinking about the way of making + // fake parameter. + // + d.traverse (p.belongs ()); + } + + template <typename T> + void PortAccessorTemplate<T>:: + receives (T& p) + { + receives_pre (p); + receives_post (p); + + } + + template <typename T> + void PortAccessorTemplate<T>:: + receives_pre (T&) + { + } + + template <typename T> + void PortAccessorTemplate<T>:: + receives_post (T&) + { + } + + template <typename T> + void PortAccessorTemplate<T>:: + raises (T&, EdgeDispatcherBase&) + { + } + + template <typename T> + void PortAccessorTemplate<T>:: + raises (T& p) + { + raises_pre (p); + raises_post (p); + } + + template <typename T> + void PortAccessorTemplate<T>:: + raises_pre (T&) + { + } + + template <typename T> + void PortAccessorTemplate<T>:: + raises_post (T&) + { + } + + template <typename T> + void PortAccessorTemplate<T>:: + post (T&) + { + } + + // PortGetTemplate + // + // + template <typename T> + void PortGetTemplate<T>:: + returns (T& p) + { + PortAccessorTemplate<T>::returns (p, this->edge_traverser ()); + } + + + // PortSetTemplate + // + // + template <typename T> + void PortSetTemplate<T>:: + receives (T& p) + { + receives_pre (p); + PortAccessorTemplate<T>::receives (p, this->edge_traverser ()); + receives_post (p); + } + + + // PortDataTemplate + // + // + template <typename T> + void PortDataTemplate<T>:: + traverse (T& p) + { + pre (p); + belongs (p); + name (p); + post (p); + } + + template <typename T> + void PortDataTemplate<T>:: + pre (T&) + { + } + + template <typename T> + void PortDataTemplate<T>:: + belongs (T& p, EdgeDispatcherBase& d) + { + d.traverse (p.belongs ()); + } + + template <typename T> + void PortDataTemplate<T>:: + belongs (T& p) + { + belongs (p, this->edge_traverser ()); + } + + template <typename T> + void PortDataTemplate<T>:: + name (T&) + { + } + + template <typename T> + void PortDataTemplate<T>:: + post (T&) + { + } + } + } +} diff --git a/modules/CIAO/CCF/CCF/IDL3/Traversal/Elements.hpp b/modules/CIAO/CCF/CCF/IDL3/Traversal/Elements.hpp new file mode 100644 index 00000000000..b92c5cf70fd --- /dev/null +++ b/modules/CIAO/CCF/CCF/IDL3/Traversal/Elements.hpp @@ -0,0 +1,21 @@ +// file : CCF/IDL3/Traversal/Elements.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef CCF_IDL3_TRAVERSAL_ELEMENTS_HPP +#define CCF_IDL3_TRAVERSAL_ELEMENTS_HPP + +#include "CCF/IDL2/Traversal/Elements.hpp" + +namespace CCF +{ + namespace IDL3 + { + namespace Traversal + { + using namespace IDL2::Traversal; + } + } +} + +#endif // CCF_IDL3_TRAVERSAL_ELEMENTS_HPP diff --git a/modules/CIAO/CCF/CCF/IDL3/Traversal/EventType.hpp b/modules/CIAO/CCF/CCF/IDL3/Traversal/EventType.hpp new file mode 100644 index 00000000000..941dfad76e6 --- /dev/null +++ b/modules/CIAO/CCF/CCF/IDL3/Traversal/EventType.hpp @@ -0,0 +1,90 @@ +// file : CCF/IDL3/Traversal/EventType.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef CCF_IDL3_TRAVERSAL_EVENT_TYPE_HPP +#define CCF_IDL3_TRAVERSAL_EVENT_TYPE_HPP + +#include "CCF/IDL3/SemanticGraph/EventType.hpp" + +#include "CCF/IDL2/Traversal/Operation.hpp" +#include "CCF/IDL3/Traversal/Elements.hpp" + +namespace CCF +{ + namespace IDL3 + { + namespace Traversal + { + template <typename T> + struct EventTypeTemplate : ScopeTemplate<T> + { + virtual void + traverse (T&); + + virtual void + pre (T&); + + virtual void + name (T&); + + virtual void + inherits (T&, EdgeDispatcherBase&); + + virtual void + inherits (T&); + + virtual void + inherits_pre (T&); + + virtual void + inherits_post (T&); + + virtual void + inherits_none (T&); + + virtual void + supports (T&, EdgeDispatcherBase&); + + virtual void + supports (T&); + + virtual void + supports_pre (T&); + + virtual void + supports_post (T&); + + virtual void + supports_none (T&); + + virtual void + post (T&); + + virtual void + comma (T&); + }; + + + typedef + EventTypeTemplate<SemanticGraph::EventType> + EventType; + + typedef + EventTypeTemplate<SemanticGraph::AbstractEventType> + AbstractEventType; + + typedef + EventTypeTemplate<SemanticGraph::ConcreteEventType> + ConcreteEventType; + + typedef + OperationTemplate<SemanticGraph::EventTypeFactory> + EventTypeFactory; + } + } +} + +#include "CCF/IDL3/Traversal/EventType.tpp" + +#endif // CCF_IDL3_TRAVERSAL_EVENT_TYPE_HPP diff --git a/modules/CIAO/CCF/CCF/IDL3/Traversal/EventType.tpp b/modules/CIAO/CCF/CCF/IDL3/Traversal/EventType.tpp new file mode 100644 index 00000000000..92c985c6176 --- /dev/null +++ b/modules/CIAO/CCF/CCF/IDL3/Traversal/EventType.tpp @@ -0,0 +1,151 @@ +// file : CCF/IDL3/Traversal/EventType.tpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +namespace CCF +{ + namespace IDL3 + { + namespace Traversal + { + template <typename T> + void EventTypeTemplate<T>:: + traverse (T& et) + { + pre (et); + name (et); + inherits (et); + supports (et); + names (et); + post (et); + } + + template <typename T> + void EventTypeTemplate<T>:: + pre (T&) + { + } + + template <typename T> + void EventTypeTemplate<T>:: + name (T&) + { + } + + template <typename T> + void EventTypeTemplate<T>:: + inherits (T& et, EdgeDispatcherBase& d) + { + iterate_and_traverse (et.inherits_begin (), + et.inherits_end (), + d); + + } + + template <typename T> + void EventTypeTemplate<T>:: + inherits (T& et) + { + typename T::InheritsIterator + b (et.inherits_begin ()), e (et.inherits_end ()); + + if (b != e) + { + inherits_pre (et); + iterate_and_traverse (b, + e, + this->edge_traverser (), + *this, + &EventTypeTemplate::comma, + et); + inherits_post (et); + } + else + { + inherits_none (et); + } + } + + template <typename T> + void EventTypeTemplate<T>:: + inherits_pre (T&) + { + } + + template <typename T> + void EventTypeTemplate<T>:: + inherits_post (T&) + { + } + + template <typename T> + void EventTypeTemplate<T>:: + inherits_none (T&) + { + } + + template <typename T> + void EventTypeTemplate<T>:: + supports (T& et, EdgeDispatcherBase& d) + { + iterate_and_traverse (et.supports_begin (), + et.supports_end (), + d); + } + + template <typename T> + void EventTypeTemplate<T>:: + supports (T& et) + { + typename T::SupportsIterator + b (et.supports_begin ()), e (et.supports_end ()); + + if (b != e) + { + supports_pre (et); + iterate_and_traverse (b, + e, + this->edge_traverser (), + *this, + &EventTypeTemplate::comma, + et); + supports_post (et); + } + else + { + supports_none (et); + } + } + + template <typename T> + void EventTypeTemplate<T>:: + supports_pre (T&) + { + } + + template <typename T> + void EventTypeTemplate<T>:: + supports_post (T&) + { + } + + template <typename T> + void EventTypeTemplate<T>:: + supports_none (T&) + { + } + + template <typename T> + void EventTypeTemplate<T>:: + post (T&) + { + } + + template <typename T> + void EventTypeTemplate<T>:: + comma (T&) + { + } + } + } +} diff --git a/modules/CIAO/CCF/CCF/IDL3/Traversal/Home.cpp b/modules/CIAO/CCF/CCF/IDL3/Traversal/Home.cpp new file mode 100644 index 00000000000..a6132394dc0 --- /dev/null +++ b/modules/CIAO/CCF/CCF/IDL3/Traversal/Home.cpp @@ -0,0 +1,381 @@ +// file : CCF/IDL3/Traversal/Home.cpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#include "CCF/IDL3/Traversal/Home.hpp" + +namespace CCF +{ + namespace IDL3 + { + namespace Traversal + { + // Home + // + // + void Home:: + traverse (Type& h) + { + pre (h); + name (h); + inherits (h); + supports (h); + manages (h); + names (h); + post (h); + } + + void Home:: + pre (Type&) + { + } + + void Home:: + name (Type&) + { + } + + void Home:: + inherits (Type& h, EdgeDispatcherBase& d) + { + if (SemanticGraph::Inherits* inh = h.inherits ()) + { + d.traverse (*inh); + } + } + + void Home:: + inherits (Type& h) + { + if (SemanticGraph::Inherits* inh = h.inherits ()) + { + inherits_pre (h); + edge_traverser ().traverse (*inh); + inherits_post (h); + } + else + { + inherits_none (h); + } + } + + void Home:: + inherits_pre (Type&) + { + } + + void Home:: + inherits_post (Type&) + { + } + + void Home:: + inherits_none (Type&) + { + } + + void Home:: + supports (Type& h, EdgeDispatcherBase& d) + { + iterate_and_traverse (h.supports_begin (), h.supports_end (), d); + } + + void Home:: + supports (Type& h) + { + Type::SupportsIterator b (h.supports_begin ()), e (h.supports_end ()); + + if (b != e) + { + supports_pre (h); + iterate_and_traverse ( + b, e, edge_traverser (), *this, &Home::comma, h); + supports_post (h); + } + else + { + supports_none (h); + } + } + + void Home:: + supports_pre (Type&) + { + } + + void Home:: + supports_post (Type&) + { + } + + void Home:: + supports_none (Type&) + { + } + + void Home:: + manages (Type& h, EdgeDispatcherBase& d) + { + d.traverse (h.manages ()); + } + + void Home:: + manages (Type& h) + { + manages_pre (h); + manages (h, edge_traverser ()); + manages_post (h); + } + + void Home:: + manages_pre (Type&) + { + } + + void Home:: + manages_post (Type&) + { + } + + void Home:: + post (Type&) + { + } + + void Home:: + comma (Type&) + { + } + +/* + // HomeFactory + // + // + void HomeFactory:: + traverse (Type& hf) + { + pre (hf); + returns (hf); + name (hf); + receives (hf); + raises (hf); + post (hf); + } + + void HomeFactory:: + pre (Type&) + { + } + + void HomeFactory:: + returns (Type& hf, EdgeDispatcherBase& d) + { + d.traverse (hf.returns ()); + } + + void HomeFactory:: + returns (Type& hf) + { + returns (hf, edge_traverser ()); + } + + void HomeFactory:: + name (Type&) + { + } + + void HomeFactory:: + receives (Type& hf, EdgeDispatcherBase& d) + { + iterate_and_traverse (hf.receives_begin (), hf.receives_end (), d); + } + + void HomeFactory:: + receives (Type& hf) + { + receives_pre (hf); + iterate_and_traverse (hf.receives_begin (), + hf.receives_end (), + edge_traverser (), + *this, + &HomeFactory::comma, + hf); + receives_post (hf); + } + + void HomeFactory:: + receives_pre (Type&) + { + } + + void HomeFactory:: + receives_post (Type&) + { + } + + void HomeFactory:: + raises (Type& hf, EdgeDispatcherBase& d) + { + iterate_and_traverse (hf.raises_begin (), hf.raises_end (), d); + } + + void HomeFactory:: + raises (Type& hf) + { + Type::RaisesIterator b (hf.raises_begin ()), e (hf.raises_end ()); + + if (b != e) + { + raises_pre (hf); + iterate_and_traverse ( + b, e, edge_traverser (), *this, &HomeFactory::comma, hf); + raises_post (hf); + } + else + { + raises_none (hf); + } + } + + void HomeFactory:: + raises_pre (Type&) + { + } + + void HomeFactory:: + raises_post (Type&) + { + } + + void HomeFactory:: + raises_none (Type&) + { + } + + void HomeFactory:: + post (Type&) + { + } + + void HomeFactory:: + comma (Type&) + { + } + + // HomeFinder + // + // + void HomeFinder:: + traverse (Type& hf) + { + pre (hf); + returns (hf); + name (hf); + receives (hf); + raises (hf); + post (hf); + } + + void HomeFinder:: + pre (Type&) + { + } + + void HomeFinder:: + returns (Type& hf, EdgeDispatcherBase& d) + { + d.traverse (hf.returns ()); + } + + void HomeFinder:: + returns (Type& hf) + { + returns (hf, edge_traverser ()); + } + + void HomeFinder:: + name (Type&) + { + } + + void HomeFinder:: + receives (Type& hf, EdgeDispatcherBase& d) + { + iterate_and_traverse (hf.receives_begin (), hf.receives_end (), d); + } + + void HomeFinder:: + receives (Type& hf) + { + receives_pre (hf); + iterate_and_traverse (hf.receives_begin (), + hf.receives_end (), + edge_traverser (), + *this, + &HomeFinder::comma, + hf); + receives_post (hf); + } + + void HomeFinder:: + receives_pre (Type&) + { + } + + void HomeFinder:: + receives_post (Type&) + { + } + + void HomeFinder:: + raises (Type& hf, EdgeDispatcherBase& d) + { + iterate_and_traverse (hf.raises_begin (), hf.raises_end (), d); + } + + void HomeFinder:: + raises (Type& hf) + { + Type::RaisesIterator b (hf.raises_begin ()), e (hf.raises_end ()); + + if (b != e) + { + raises_pre (hf); + iterate_and_traverse ( + b, e, edge_traverser (), *this, &HomeFinder::comma, hf); + raises_post (hf); + } + else + { + raises_none (hf); + } + } + + void HomeFinder:: + raises_pre (Type&) + { + } + + void HomeFinder:: + raises_post (Type&) + { + } + + void HomeFinder:: + raises_none (Type&) + { + } + + void HomeFinder:: + post (Type&) + { + } + + void HomeFinder:: + comma (Type&) + { + } +*/ + } + } +} diff --git a/modules/CIAO/CCF/CCF/IDL3/Traversal/Home.hpp b/modules/CIAO/CCF/CCF/IDL3/Traversal/Home.hpp new file mode 100644 index 00000000000..076bbab68c3 --- /dev/null +++ b/modules/CIAO/CCF/CCF/IDL3/Traversal/Home.hpp @@ -0,0 +1,219 @@ +// file : CCF/IDL3/Traversal/Home.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef CCF_IDL3_TRAVERSAL_HOME_HPP +#define CCF_IDL3_TRAVERSAL_HOME_HPP + +#include "CCF/IDL3/SemanticGraph/Home.hpp" + +#include "CCF/IDL2/Traversal/Operation.hpp" +#include "CCF/IDL3/Traversal/Elements.hpp" + +namespace CCF +{ + namespace IDL3 + { + namespace Traversal + { + + // + // + // + struct Manages : Edge<SemanticGraph::Manages> + { + virtual void + traverse (Type& e) + { + node_traverser ().traverse (e.managee ()); + } + }; + + // + // + // + struct Home : ScopeTemplate<SemanticGraph::Home> + { + virtual void + traverse (Type&); + + virtual void + pre (Type&); + + virtual void + name (Type&); + + virtual void + inherits (Type&, EdgeDispatcherBase&); + + virtual void + inherits (Type&); + + virtual void + inherits_pre (Type&); + + virtual void + inherits_post (Type&); + + virtual void + inherits_none (Type&); + + virtual void + supports (Type&, EdgeDispatcherBase&); + + virtual void + supports (Type&); + + virtual void + supports_pre (Type&); + + virtual void + supports_post (Type&); + + virtual void + supports_none (Type&); + + virtual void + manages (Type&, EdgeDispatcherBase&); + + virtual void + manages (Type&); + + virtual void + manages_pre (Type&); + + virtual void + manages_post (Type&); + + virtual void + post (Type&); + + virtual void + comma (Type&); + }; + + + // + // + // + /* + struct HomeFactory : Node<SemanticGraph::HomeFactory> + { + virtual void + traverse (Type&); + + virtual void + pre (Type&); + + virtual void + returns (Type&, EdgeDispatcherBase&); + + virtual void + returns (Type&); + + virtual void + name (Type&); + + virtual void + receives (Type&, EdgeDispatcherBase&); + + virtual void + receives (Type&); + + virtual void + receives_pre (Type&); + + virtual void + receives_post (Type&); + + virtual void + raises (Type&, EdgeDispatcherBase&); + + virtual void + raises (Type&); + + virtual void + raises_pre (Type&); + + virtual void + raises_post (Type&); + + virtual void + raises_none (Type&); + + virtual void + post (Type&); + + virtual void + comma (Type&); + }; + */ + + typedef + OperationTemplate<SemanticGraph::HomeFactory> + HomeFactory; + + // + // + // + /* + struct HomeFinder : Node<SemanticGraph::HomeFinder> + { + virtual void + traverse (Type&); + + virtual void + pre (Type&); + + virtual void + returns (Type&, EdgeDispatcherBase&); + + virtual void + returns (Type&); + + virtual void + name (Type&); + + virtual void + receives (Type&, EdgeDispatcherBase&); + + virtual void + receives (Type&); + + virtual void + receives_pre (Type&); + + virtual void + receives_post (Type&); + + virtual void + raises (Type&, EdgeDispatcherBase&); + + virtual void + raises (Type&); + + virtual void + raises_pre (Type&); + + virtual void + raises_post (Type&); + + virtual void + raises_none (Type&); + + virtual void + post (Type&); + + virtual void + comma (Type&); + }; + */ + + typedef + OperationTemplate<SemanticGraph::HomeFinder> + HomeFinder; + } + } +} + +#endif // CCF_IDL3_TRAVERSAL_HOME_HPP |