From 2db3a828d67dea4c7f1c40408d3e09ee1df4a336 Mon Sep 17 00:00:00 2001
From: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
Date: Sun, 12 Aug 2007 16:26:25 +0200
Subject: [PATCH] rewrite the CompositeTraceResolver to use a simpler
 implementation, not based on callbacks

---
 src/core/composite-trace-resolver.cc | 116 +++++++++++++----
 src/core/composite-trace-resolver.h  | 184 +++++++++++++++++----------
 2 files changed, 208 insertions(+), 92 deletions(-)

diff --git a/src/core/composite-trace-resolver.cc b/src/core/composite-trace-resolver.cc
index 83d63c29b..72a768e91 100644
--- a/src/core/composite-trace-resolver.cc
+++ b/src/core/composite-trace-resolver.cc
@@ -29,25 +29,68 @@ CompositeTraceResolver::CompositeTraceResolver ()
 {}
 
 CompositeTraceResolver::~CompositeTraceResolver ()
-{}
+{
+  for (TraceItems::iterator i = m_items.begin (); i != m_items.end (); i++)
+    {
+      delete *i;
+    }
+  m_items.clear ();
+}
+
+void 
+CompositeTraceResolver::AddItem (CompositeItem *item)
+{
+  m_items.push_back (item);
+}
 
 void 
 CompositeTraceResolver::Add (std::string name, 
                              Callback<Ptr<TraceResolver> > createResolver)
 {
-  DoAdd (name, createResolver, TraceContext ());
+  class MakerCompositeItem : public CompositeItem
+  {
+  public:
+    virtual void Connect (std::string subpath, const CallbackBase &cb, const TraceContext &context)
+    {maker ()->Connect (subpath, cb, context);}
+    virtual void Disconnect (std::string subpath, const CallbackBase &cb)
+    {maker ()->Disconnect (subpath, cb);}
+
+    Callback<Ptr<TraceResolver> > maker;
+  } *item = new MakerCompositeItem ();
+  item->name = name;
+  item->context = TraceContext ();
+  item->maker = createResolver;
+  AddItem (item);
 }
 
 void 
-CompositeTraceResolver::DoAdd (std::string name, 
-			       Callback<Ptr<TraceResolver> > createResolver,
-			       TraceContext const &context)
+CompositeTraceResolver::AddChild (std::string name, Ptr<Object> child)
 {
-  struct CallbackTraceSourceItem item;
-  item.name = name;
-  item.createResolver = createResolver;
-  item.context = context;
-  m_items.push_back (item);
+  DoAddChild (name, child, TraceContext ());
+}
+void 
+CompositeTraceResolver::DoAddChild (std::string name, Ptr<Object> child, const TraceContext &context)
+{
+  class ChildCompositeItem : public CompositeItem
+  {
+  public:
+    virtual void Connect (std::string subpath, const CallbackBase &cb, const TraceContext &context)
+    {child->TraceConnect (subpath, cb, context);}
+    virtual void Disconnect (std::string subpath, const CallbackBase &cb)
+    {child->TraceDisconnect (subpath, cb);}
+
+    Ptr<Object> child;
+  } *item = new ChildCompositeItem ();
+  item->name = name;
+  item->context = context;
+  item->child = child;
+  AddItem (item);
+}
+
+void
+CompositeTraceResolver::SetParent (Ptr<TraceResolver> resolver)
+{
+  m_parent = resolver;
 }
 
 void 
@@ -57,10 +100,15 @@ CompositeTraceResolver::Connect (std::string path, CallbackBase const &cb, const
   DoRecursiveOperation (path, cb, context, CONNECT);
 }
 void 
-CompositeTraceResolver::DoRecursiveOperation (std::string path, CallbackBase const &cb, 
+CompositeTraceResolver::DoRecursiveOperation (std::string path, 
+                                              const CallbackBase  &cb, 
                                               const TraceContext &context,
                                               enum Operation op)
 {
+  if (path == "")
+    {
+      return;
+    }
   std::string id = GetElement (path);
   std::string subpath = GetSubpath (path);
 
@@ -70,6 +118,7 @@ CompositeTraceResolver::DoRecursiveOperation (std::string path, CallbackBase con
 	{
           OperationOne (subpath, i, cb, context, op);
         }
+      DoRecursiveOperationForParent (path, cb, context, op);
       return;
     }
   std::string::size_type start, end;
@@ -79,9 +128,10 @@ CompositeTraceResolver::DoRecursiveOperation (std::string path, CallbackBase con
     {
       for (TraceItems::const_iterator i = m_items.begin (); i != m_items.end (); i++)
 	{
-	  if (i->name == id)
+	  if ((*i)->name == id)
 	    {
               OperationOne (subpath, i, cb, context, op);
+              DoRecursiveOperationForParent (path, cb, context, op);
               return;
 	    }
 	}
@@ -109,13 +159,34 @@ CompositeTraceResolver::DoRecursiveOperation (std::string path, CallbackBase con
     {
       for (TraceItems::const_iterator j = m_items.begin (); j != m_items.end (); j++)
 	{
-	  if (j->name == *i)
+	  if ((*j)->name == *i)
 	    {
               OperationOne (subpath, j, cb, context, op);
 	      break;
 	    }
 	}
     }
+  DoRecursiveOperationForParent (path, cb, context, op);
+}
+
+void
+CompositeTraceResolver::DoRecursiveOperationForParent (std::string path, 
+                                                       const CallbackBase &cb, 
+                                                       const TraceContext &context, 
+                                                       enum Operation op)
+{
+  if (m_parent == 0)
+    {
+      return;
+    }
+  switch (op) {
+  case CONNECT:
+    m_parent->Connect (path, cb, context);
+    break;
+  case DISCONNECT:
+    m_parent->Disconnect (path, cb);
+    break;
+  }
 }
 
 void 
@@ -125,16 +196,15 @@ CompositeTraceResolver::OperationOne (std::string subpath,
                                       const TraceContext &context,
                                       enum Operation op)
 {
-  Ptr<TraceResolver> resolver = i->createResolver ();
   switch (op) {
   case CONNECT: {
-    NS_DEBUG ("connect to path="<<subpath<<" name="<<i->name);
+    NS_DEBUG ("connect to path="<<subpath<<" name="<<(*i)->name);
     TraceContext ctx = context;
-    ctx.Add (i->context);
-    resolver->Connect (subpath, cb, ctx);
+    ctx.Add ((*i)->context);
+    (*i)->Connect (subpath, cb, ctx);
     } break;
   case DISCONNECT:
-    resolver->Disconnect (subpath, cb);
+    (*i)->Disconnect (subpath, cb);
     break;
   }
 }
@@ -159,17 +229,14 @@ class TraceSourceTest : public TraceContextElement
 public:
   enum Sources {
     DOUBLEA,
-    DOUBLEB,
-    SUBRESOLVER,
+    DOUBLEB
   };
   static uint16_t GetUid (void) 
   {static uint16_t uid = AllocateUid<TraceSourceTest> ("TraceSourceTest"); return uid;}
   void Print (std::ostream &os)
   {os << "tracesource=";
     if (m_sources == DOUBLEA) {os << "doubleA";}
-    else if (m_sources == DOUBLEB) {os << "doubleB";}
-    else if (m_sources == SUBRESOLVER) {os << "subresolver";}
-  }
+    else if (m_sources == DOUBLEB) {os << "doubleB";}}
   TraceSourceTest () : m_sources (TraceSourceTest::DOUBLEA) {}
   TraceSourceTest (enum Sources sources) :m_sources (sources) {}
   bool IsDoubleA (void) {return m_sources == TraceSourceTest::DOUBLEA;}
@@ -357,8 +424,7 @@ CompositeTraceResolverTest::RunTests (void)
     }
 
   resolver.Add ("subresolver", 
-		MakeCallback (&CompositeTraceResolverTest::CreateSubResolver, this),
-		TraceSourceTest (TraceSourceTest::SUBRESOLVER));
+		MakeCallback (&CompositeTraceResolverTest::CreateSubResolver, this));
 
   resolver.Connect ("/subresolver/trace-int", 
 		    MakeCallback (&CompositeTraceResolverTest::TraceInt, this), TraceContext ());
diff --git a/src/core/composite-trace-resolver.h b/src/core/composite-trace-resolver.h
index d33c4cc5c..e8b09610c 100644
--- a/src/core/composite-trace-resolver.h
+++ b/src/core/composite-trace-resolver.h
@@ -21,6 +21,7 @@
 #ifndef COMPOSITE_TRACE_RESOLVER_H
 #define COMPOSITE_TRACE_RESOLVER_H
 
+#include <vector>
 #include "callback.h"
 #include "ptr.h"
 #include "trace-resolver.h"
@@ -28,7 +29,7 @@
 #include "uv-trace-source.h"
 #include "sv-trace-source.h"
 #include "fv-trace-source.h"
-#include "terminal-trace-resolver.h"
+#include "array-trace-resolver.h"
 
 namespace ns3 {
 
@@ -95,24 +96,6 @@ public:
   template <typename T>
   void Add (std::string name,
             FVTraceSource<T> &trace, T const &context);
-
-  /**
-   * \param name name of child trace resolver
-   * \param createResolver a trace resolver constructor
-   * \param context the context associated to this entry
-   *
-   * Add a child trace resolver to this resolver. This child
-   * trace resolver will match the name specified during
-   * namespace resolution. When this happens, the constructor
-   * will be invoked to create the child trace resolver and
-   * the associated TraceContext will be automatically extended
-   * to contain the input context.
-   */
-  template <typename T>
-  void Add (std::string name, 
-            Callback<Ptr<TraceResolver> > createResolver,
-            T const &context);
-
   /**
    * \param name name of child trace resolver
    * \param createResolver a trace resolver constructor
@@ -124,71 +107,63 @@ public:
    */
   void Add (std::string name, 
             Callback<Ptr<TraceResolver> > createResolver);
+
+  void AddChild (std::string name, Ptr<Object> child);
+
+  template <typename T>
+  void AddChild (std::string name, Ptr<Object> child, const T &contextElement);
+
+  template <typename ITERATOR, typename INDEX>
+  void AddArray (std::string name, 
+                 ITERATOR begin, ITERATOR end, INDEX index);
+
+
+  void SetParent (Ptr<TraceResolver> parent);
+
   virtual void Connect (std::string path, CallbackBase const &cb, const TraceContext &context);
   virtual void Disconnect (std::string path, CallbackBase const &cb);
 
 private:
-  struct CallbackTraceSourceItem
+  class CompositeItem 
   {
+  public:
+    virtual ~CompositeItem () {}
+    virtual void Connect (std::string subpath, const CallbackBase &cb, const TraceContext &context) = 0;
+    virtual void Disconnect (std::string subpath, const CallbackBase &cb) = 0;
+
     std::string name;
-    Callback<Ptr<TraceResolver> > createResolver;
     TraceContext context;
   };
-  typedef std::list<struct CallbackTraceSourceItem> TraceItems;
+  typedef std::vector<CompositeItem *> TraceItems;
   enum Operation {
     CONNECT,
     DISCONNECT
   };
 
-  template <typename SOURCE, typename CONTEXT>
-  void DoAddTraceSource (std::string name,
-                         SOURCE &traceSource, CONTEXT const &context);
-  template <typename SOURCE>
-  static Ptr<TraceResolver> CreateTerminalTraceResolver (SOURCE *trace);
-  void DoAdd (std::string name, 
-              Callback<Ptr<TraceResolver> > createResolver,
-              TraceContext const &context);
+  void AddItem (CompositeItem *item);
   void OperationOne (std::string subpath, 
                      TraceItems::const_iterator i,
                      const CallbackBase &cb,
                      const TraceContext &context,
                      enum Operation op);
-  void DoRecursiveOperation (std::string path, CallbackBase const &cb, 
+  void DoRecursiveOperation (std::string path, 
+                             const CallbackBase &cb, 
                              const TraceContext &context,
                              enum Operation op);
+  void DoRecursiveOperationForParent (std::string path, 
+                                      const CallbackBase &cb, 
+                                      const TraceContext &context, 
+                                      enum Operation op);
+  void DoAddChild (std::string name, Ptr<Object> child, const TraceContext &context);
 
-
-
-  TraceItems m_items;
+  CompositeTraceResolver::TraceItems m_items;
+  Ptr<TraceResolver> m_parent;
 };
 
 }//namespace ns3
 
 namespace ns3 {
 
-template <typename SOURCE, typename CONTEXT>
-void 
-CompositeTraceResolver::DoAddTraceSource (std::string name,
-                                          SOURCE &traceSource, CONTEXT const &context)
-{
-  Ptr<TraceResolver> (*create) (SOURCE *trace);
-  create = &CompositeTraceResolver::CreateTerminalTraceResolver<SOURCE>;
-  Callback<Ptr<TraceResolver> > createResolver = 
-    MakeBoundCallback (create, &traceSource);
-
-  TraceContext ctx;
-  ctx.Add (context);
-  DoAdd (name, createResolver, ctx);
-}
-
-template <typename SOURCE>
-Ptr<TraceResolver>
-CompositeTraceResolver::CreateTerminalTraceResolver (SOURCE *traceSource)
-{
-  return Create<TerminalTraceResolver<SOURCE> > (traceSource);
-}
-
-
 
 
 template <typename T1, typename T2,
@@ -199,40 +174,115 @@ CompositeTraceResolver::Add (std::string name,
                              CallbackTraceSource<T1,T2,T3,T4> &trace, 
                              T const &context)
 {
-  DoAddTraceSource (name, trace, context);
+  class CallbackCompositeItem : public CompositeItem
+  {
+  public:
+    virtual void Connect (std::string subpath, const CallbackBase &cb, const TraceContext &context)
+    {if (subpath == "") {trace->AddCallback (cb, context);}}
+    virtual void Disconnect (std::string subpath, const CallbackBase &cb)
+    {if (subpath == "") {trace->RemoveCallback (cb);}}
+
+    CallbackTraceSource<T1,T2,T3,T4> *trace;
+  } *item = new CallbackCompositeItem ();
+  item->name = name;
+  item->context.Add (context);
+  item->trace = &trace;
+  AddItem (item);
 }
 template <typename T>
 void 
 CompositeTraceResolver::Add (std::string name,
                              SVTraceSource<T> &trace, T const &context)
 {
-  DoAddTraceSource (name, trace, context);
+  class SVCompositeItem : public CompositeItem
+  {
+  public:
+    virtual void Connect (std::string subpath, const CallbackBase &cb, const TraceContext &context)
+    {if (subpath == "") {trace->AddCallback (cb, context);}}
+    virtual void Disconnect (std::string subpath, const CallbackBase &cb)
+    {if (subpath == "") {trace->RemoveCallback (cb);}}
+
+    SVTraceSource<T> *trace;
+  } *item = new SVCompositeItem ();
+  item->name = name;
+  item->context.Add (context);
+  item->trace = &trace;
+  AddItem (item);
 }
 template <typename T>
 void 
 CompositeTraceResolver::Add (std::string name,
                              UVTraceSource<T> &trace, T const &context)
 {
-  DoAddTraceSource (name, trace, context);
+  class UVCompositeItem : public CompositeItem
+  {
+  public:
+    virtual void Connect (std::string subpath, const CallbackBase &cb, const TraceContext &context)
+    {if (subpath == "") {trace->AddCallback (cb, context);}}
+    virtual void Disconnect (std::string subpath, const CallbackBase &cb)
+    {if (subpath == "") {trace->RemoveCallback (cb);}}
+
+    UVTraceSource<T> *trace;
+  } *item = new UVCompositeItem ();
+  item->name = name;
+  item->context.Add (context);
+  item->trace = &trace;
+  AddItem (item);
 }
 template <typename T>
 void 
 CompositeTraceResolver::Add (std::string name,
                              FVTraceSource<T> &trace, T const &context)
 {
-  DoAddTraceSource (name, trace, context);
+  class FVCompositeItem : public CompositeItem
+  {
+  public:
+    virtual void Connect (std::string subpath, const CallbackBase &cb, const TraceContext &context)
+    {if (subpath == "") {trace->AddCallback (cb, context);}}
+    virtual void Disconnect (std::string subpath, const CallbackBase &cb)
+    {if (subpath == "") {trace->RemoveCallback (cb);}}
+
+    FVTraceSource<T> *trace;
+  } *item = new FVCompositeItem ();
+  item->name = name;
+  item->context.Add (context);
+  item->trace = &trace;
+  AddItem (item);
 }
+
+template <typename ITERATOR, typename INDEX>
+void 
+CompositeTraceResolver::AddArray (std::string name, 
+                                  ITERATOR begin, ITERATOR end, INDEX index)
+{
+  class ArrayCompositeItem : public CompositeItem
+  {
+  public:
+    virtual void Connect (std::string subpath, const CallbackBase &cb, const TraceContext &context)
+    {array->Connect (subpath, cb, context);}
+    virtual void Disconnect (std::string subpath, const CallbackBase &cb)
+    {array->Disconnect (subpath, cb);}
+
+    Ptr<ArrayTraceResolver<INDEX> > array;
+  } *item = new ArrayCompositeItem ();
+  item->name = name;
+  item->context = TraceContext ();
+  item->array = Create<ArrayTraceResolver<INDEX> > ();
+  item->array->SetIterators (begin, end);
+  AddItem (item);
+}
+
 template <typename T>
 void 
-CompositeTraceResolver::Add (std::string name, 
-                             Callback<Ptr<TraceResolver> > createResolver,
-                             T const &context)
+CompositeTraceResolver::AddChild (std::string name, Ptr<Object> child, const T &contextElement)
 {
-  TraceContext ctx;
-  ctx.Add (context);
-  DoAdd (name, createResolver, ctx);
+  TraceContext context;
+  context.Add (contextElement);
+  DoAddChild (name, child, context);
 }
 
+
+
 }//namespace ns3
 
 #endif /* COMPOSITE_TRACE_RESOLVER_H */