ACE/ace/XML_Utils/XSCRT/Traversal.hpp

   1 // file      : XSCRT/Traversal.hpp
   2 // author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
   3 #ifndef XSCRT_TRAVERSAL_HPP
   4 #define XSCRT_TRAVERSAL_HPP
   5
   6 #include <map>
   7 #include <set>
   8 #include <vector>
   9
  10 #include "ace/XML_Utils/XSCRT/ExtendedTypeInfo.hpp"
  11
  12 namespace XSCRT
  13 {
  14   namespace Traversal
  15   {
  16     template<typename B>
  17     class TraverserBase
  18     {
  19     protected:
  20       virtual ~TraverserBase () = default;
  21
  22       //@@ VC6
  23     public:
  24       virtual void trampoline (B& n) = 0;
  25
  26       virtual void trampoline (B const& n) = 0;
  27     };
  28
  29     template <typename B>
  30     class DispatcherBase
  31     {
  32     public:
  33       virtual ~DispatcherBase () = default;
  34
  35       virtual void dispatch (B& n);
  36
  37       virtual void dispatch (B const& n);
  38
  39       void
  40       map (TypeId id, TraverserBase<B>& t)
  41       {
  42         //@@ VC6
  43         Traversers& traversers = traversal_map_[id];
  44         traversers.push_back (&t);
  45       }
  46
  47     public:
  48       typedef std::vector<TraverserBase<B>*> Traversers;
  49       typedef std::map<TypeId, Traversers> TraversalMap;
  50       typedef typename TraversalMap::const_iterator Iterator;
  51
  52       Iterator
  53       begin () const
  54       {
  55         return traversal_map_.begin ();
  56       }
  57
  58       Iterator
  59       end () const
  60       {
  61         return traversal_map_.end ();
  62       }
  63
  64     private:
  65       struct TypeInfoComparator
  66       {
  67         bool
  68         operator () (ExtendedTypeInfo const& x,
  69                      ExtendedTypeInfo const& y) const
  70         {
  71           return x.type_id () < y.type_id ();
  72         }
  73       };
  74
  75       typedef std::map<ExtendedTypeInfo, unsigned long, TypeInfoComparator> LevelMap;
  76       typedef std::set<ExtendedTypeInfo, TypeInfoComparator> TypeInfoSet;
  77
  78       static unsigned long
  79       compute_levels (ExtendedTypeInfo const& ti,
  80                       unsigned long cur,
  81                       LevelMap& map);
  82
  83       static void
  84       flatten_tree (ExtendedTypeInfo const& ti, TypeInfoSet& set);
  85
  86     private:
  87       TraversalMap traversal_map_;
  88     };
  89
  90     template <typename B>
  91     class Dispatcher : public virtual DispatcherBase<B>
  92     {
  93     public:
  94       Dispatcher ()
  95           : merge_ (true)
  96       {
  97       }
  98
  99       void
 100       traverser (DispatcherBase<B>& d)
 101       {
 102         for (typename DispatcherBase<B>::Iterator
 103                i (d.begin ()), end (d.end ());
 104              i != end; ++i)
 105         {
 106           for (typename DispatcherBase<B>::Traversers::const_iterator
 107                  t (i->second.begin ()), end (i->second.end ());
 108                t != end; ++t)
 109           {
 110             dispatcher_.map (i->first, **t);
 111           }
 112         }
 113       }
 114
 115     public:
 116       virtual void
 117       dispatch (B& n)
 118       {
 119         merge ();
 120         dispatcher_.dispatch (n);
 121       }
 122
 123       virtual void
 124       dispatch (B const& n)
 125       {
 126         merge ();
 127         dispatcher_.dispatch (n);
 128       }
 129
 130       using DispatcherBase<B>::begin;
 131       using DispatcherBase<B>::end;
 132
 133     private:
 134       void
 135       merge ()
 136       {
 137         if (merge_)
 138         {
 139           for (typename DispatcherBase<B>::Iterator
 140                  i (begin ()), e (end ()); i != e; ++i)
 141           {
 142             for (typename DispatcherBase<B>::Traversers::const_iterator
 143                    t (i->second.begin ()), e (i->second.end ()); t != e; ++t)
 144             {
 145               dispatcher_.map (i->first, **t);
 146             }
 147           }
 148
 149           merge_ = false;
 150         }
 151       }
 152
 153     protected:
 154       template <typename X, typename A, typename I>
 155       void
 156       iterate_and_dispatch (I begin, I end, X& x, void (X::*next)(A&), A& a)
 157       {
 158         for (; begin != end;)
 159         {
 160           dispatch (*begin);
 161
 162           if (++begin != end) (x.*next) (a);
 163         }
 164       }
 165
 166     private:
 167       bool merge_;
 168       DispatcherBase<B> dispatcher_;
 169     };
 170
 171     template <typename T, typename B>
 172     struct Traverser : TraverserBase<B>, virtual Dispatcher<B>
 173     {
 174       typedef T Type;
 175
 176       Traverser ()
 177       {
 178         DispatcherBase<B>::map (typeid (Type), *this);
 179       }
 180
 181       virtual void
 182       traverse (Type&)
 183       {
 184         abort ();
 185       }
 186
 187       virtual void
 188       traverse (Type const&)
 189       {
 190         abort ();
 191       }
 192
 193     protected:
 194       virtual void
 195       trampoline (B& n)
 196       {
 197         traverse (dynamic_cast<Type&> (n));
 198       }
 199
 200       virtual void
 201       trampoline (B const& n)
 202       {
 203         traverse (dynamic_cast<Type const&> (n));
 204       }
 205     };
 206   }
 207 }
 208
 209 #include <ace/XML_Utils/XSCRT/Traversal.tpp>
 210
 211 #endif  // XSCRT_TRAVERSAL_HPP