F5/unison
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rewrite the CompositeTraceResolver to use a simpler implementation, not based on callbacks

Browse Source
This commit is contained in:
Mathieu Lacage
2007-08-12 16:26:25 +02:00
parent c62cf3c82d
commit 2db3a828d6
2 changed files with 208 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
src/core/composite-trace-resolver.cc
View File

@@ -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 ());

184
src/core/composite-trace-resolver.h
View File

@@ -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 */