Mercurial Mercurial > lalith > ns-3-click-dev / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/common/composite-trace-resolver.cc
changeset 1325 f3be9eed2d90
parent 1235 dc52ea3507ff
child 1327 798c425d3b1f
equal deleted inserted replaced
1259:67584d6fc928 1325:f3be9eed2d90 
    20  */
 
    20  */
 
    21 #include "composite-trace-resolver.h"
 
    21 #include "composite-trace-resolver.h"
 
    22 
    22 
    23 namespace ns3 {
 
    23 namespace ns3 {
 
    24 
    24 
    25 CompositeTraceResolver::CompositeTraceResolver (TraceContext const &context)
 
    25 CompositeTraceResolver::CompositeTraceResolver ()
 
    26   : TraceResolver (context)
 
       
    27 {}
 
    26 {}
 
    28 
    27 
    29 CompositeTraceResolver::~CompositeTraceResolver ()
 
    28 CompositeTraceResolver::~CompositeTraceResolver ()
 
    30 {}
 
    29 {}
 
    31 
    30 
    32 void 
    31 void 
    33 CompositeTraceResolver::Add (std::string name, 
    32 CompositeTraceResolver::Add (std::string name, 
    34                              Callback<TraceResolver *,TraceContext const &> createResolver)
 
    33                              Callback<TraceResolver *> createResolver)
 
    35 {
 
    34 {
 
    36   TraceContext traceContext = GetContext ();
 
    35   DoAdd (name, createResolver, TraceContext ());
 
    37   DoAdd (name, createResolver, traceContext);
 
       
    38 }
 
    36 }
 
    39 
    37 
    40 void 
    38 void 
    41 CompositeTraceResolver::DoAdd (std::string name, 
    39 CompositeTraceResolver::DoAdd (std::string name, 
    42 			       Callback<TraceResolver *,TraceContext const &> createResolver,
 
    40 			       Callback<TraceResolver *> createResolver,
 
    43 			       TraceContext const &context)
 
    41 			       TraceContext const &context)
 
    44 {
 
    42 {
 
    45   struct CallbackTraceSourceItem item;
 
    43   struct CallbackTraceSourceItem item;
 
    46   item.name = name;
 
    44   item.name = name;
 
    47   item.createResolver = createResolver;
 
    45   item.createResolver = createResolver;
 
    55   if (id == "*")
 
    53   if (id == "*")
 
    56     {
 
    54     {
 
    57       TraceResolver::TraceResolverList list;
 
    55       TraceResolver::TraceResolverList list;
 
    58       for (TraceItems::const_iterator i = m_items.begin (); i != m_items.end (); i++)
 
    56       for (TraceItems::const_iterator i = m_items.begin (); i != m_items.end (); i++)
 
    59 	{
 
    57 	{
 
    60 	  list.push_back (i->createResolver (i->context));
 
    58 	  list.push_back (std::make_pair (i->createResolver (), i->context));
 
    61 	}
 
    59 	}
 
    62       return list;
 
    60       return list;
 
    63     }
 
    61     }
 
    64   std::string::size_type start, end;
 
    62   std::string::size_type start, end;
 
    65   start = id.find_first_of ("(", 0);
 
    63   start = id.find_first_of ("(", 0);
 
    69       for (TraceItems::const_iterator i = m_items.begin (); i != m_items.end (); i++)
 
    67       for (TraceItems::const_iterator i = m_items.begin (); i != m_items.end (); i++)
 
    70 	{
 
    68 	{
 
    71 	  if (i->name == id)
 
    69 	  if (i->name == id)
 
    72 	    {
 
    70 	    {
 
    73 	      TraceResolver::TraceResolverList list;
 
    71 	      TraceResolver::TraceResolverList list;
 
    74 	      list.push_back (i->createResolver (i->context));
 
    72 	      list.push_back (std::make_pair (i->createResolver (), i->context));
 
    75 	      return list;
 
    73 	      return list;
 
    76 	    }
 
    74 	    }
 
    77 	}
 
    75 	}
 
    78     }
 
    76     }
 
    79   std::list<std::string> names;
 
    77   std::list<std::string> names;
 
   100     {
 
    98     {
 
   101       for (TraceItems::const_iterator j = m_items.begin (); j != m_items.end (); j++)
 
    99       for (TraceItems::const_iterator j = m_items.begin (); j != m_items.end (); j++)
 
   102 	{
 
   100 	{
 
   103 	  if (j->name == *i)
 
   101 	  if (j->name == *i)
 
   104 	    {
 
   102 	    {
 
   105 	      list.push_back (j->createResolver (j->context));
 
   103 	      list.push_back (std::make_pair (j->createResolver (), j->context));
 
   106 	      break;
 
   104 	      break;
 
   107 	    }
 
   105 	    }
 
   108 	}
 
   106 	}
 
   109     }
 
   107     }
 
   110   return list;
 
   108   return list;
 
   166   virtual ~CompositeTraceResolverTest ();
 
   164   virtual ~CompositeTraceResolverTest ();
 
   167   virtual bool RunTests (void);
 
   165   virtual bool RunTests (void);
 
   168 private:
 
   166 private:
 
   169   void TraceDouble (TraceContext const &context, double v);
 
   167   void TraceDouble (TraceContext const &context, double v);
 
   170   void TraceInt (TraceContext const &context, int v);
 
   168   void TraceInt (TraceContext const &context, int v);
 
   171   TraceResolver *CreateSubResolver (TraceContext const &context);
 
   169   TraceResolver *CreateSubResolver ();
 
   172 
   170 
   173 
   171 
   174   bool m_gotDoubleA;
 
   172   bool m_gotDoubleA;
 
   175   bool m_gotDoubleB;
 
   173   bool m_gotDoubleB;
 
   176   CallbackTraceSource<int> m_traceInt;
 
   174   CallbackTraceSource<int> m_traceInt;
 
   207 {
 
   205 {
 
   208   m_gotInt = true;
 
   206   m_gotInt = true;
 
   209 }
 
   207 }
 
   210 
   208 
   211 TraceResolver *
 
   209 TraceResolver *
 
   212 CompositeTraceResolverTest::CreateSubResolver (TraceContext const &context)
 
   210 CompositeTraceResolverTest::CreateSubResolver (void)
 
   213 {
 
   211 {
 
   214   CompositeTraceResolver *subresolver = new CompositeTraceResolver (context);
 
   212   CompositeTraceResolver *subresolver = new CompositeTraceResolver ();
 
   215   subresolver->Add ("trace-int", m_traceInt, 
   213   subresolver->Add ("trace-int", m_traceInt, 
   216                     SubTraceSourceTest (SubTraceSourceTest::INT));
 
   214                     SubTraceSourceTest (SubTraceSourceTest::INT));
 
   217   return subresolver;
 
   215   return subresolver;
 
   218 }
 
   216 }
 
   219 bool 
   217 bool 
   223 
   221 
   224   CallbackTraceSource<double> traceDoubleA;
 
   222   CallbackTraceSource<double> traceDoubleA;
 
   225   CallbackTraceSource<double> traceDoubleB;
 
   223   CallbackTraceSource<double> traceDoubleB;
 
   226   TraceContext context;
 
   224   TraceContext context;
 
   227 
   225 
   228   CompositeTraceResolver resolver (context) ;
 
   226   CompositeTraceResolver resolver;
 
   229 
   227 
   230   resolver.Add ("trace-double-a", traceDoubleA, 
   228   resolver.Add ("trace-double-a", traceDoubleA, 
   231                 TraceSourceTest (TraceSourceTest::DOUBLEA));
 
   229                 TraceSourceTest (TraceSourceTest::DOUBLEA));
 
   232   resolver.Add ("trace-double-b", traceDoubleB, 
   230   resolver.Add ("trace-double-b", traceDoubleB, 
   233                 TraceSourceTest (TraceSourceTest::DOUBLEB));
 
   231                 TraceSourceTest (TraceSourceTest::DOUBLEB));
 
   234 
   232 
   235   resolver.Connect ("/*", MakeCallback (&CompositeTraceResolverTest::TraceDouble, this));
 
   233   resolver.Connect ("/*", MakeCallback (&CompositeTraceResolverTest::TraceDouble, this), TraceContext ());
 
   236 
   234 
   237   m_gotDoubleA = false;
 
   235   m_gotDoubleA = false;
 
   238   m_gotDoubleB = false;
 
   236   m_gotDoubleB = false;
 
   239   traceDoubleA (0);
 
   237   traceDoubleA (0);
 
   240   if (!m_gotDoubleA || m_gotDoubleB)
 
   238   if (!m_gotDoubleA || m_gotDoubleB)
 
   261     {
 
   259     {
 
   262       ok = false;
 
   260       ok = false;
 
   263     }
 
   261     }
 
   264 
   262 
   265   resolver.Connect ("/trace-double-a", 
   263   resolver.Connect ("/trace-double-a", 
   266 		    MakeCallback (&CompositeTraceResolverTest::TraceDouble, this));
 
   264 		    MakeCallback (&CompositeTraceResolverTest::TraceDouble, this), TraceContext ());
 
   267   m_gotDoubleA = false;
 
   265   m_gotDoubleA = false;
 
   268   m_gotDoubleB = false;
 
   266   m_gotDoubleB = false;
 
   269   traceDoubleA (0);
 
   267   traceDoubleA (0);
 
   270   traceDoubleB (0);
 
   268   traceDoubleB (0);
 
   271   if (!m_gotDoubleA || m_gotDoubleB)
 
   269   if (!m_gotDoubleA || m_gotDoubleB)
 
   274     }
 
   272     }
 
   275   resolver.Disconnect ("/trace-double-a", 
   273   resolver.Disconnect ("/trace-double-a", 
   276 		       MakeCallback (&CompositeTraceResolverTest::TraceDouble, this));
 
   274 		       MakeCallback (&CompositeTraceResolverTest::TraceDouble, this));
 
   277 
   275 
   278   resolver.Connect ("/(trace-double-a)", 
   276   resolver.Connect ("/(trace-double-a)", 
   279 		    MakeCallback (&CompositeTraceResolverTest::TraceDouble, this));
 
   277 		    MakeCallback (&CompositeTraceResolverTest::TraceDouble, this), TraceContext ());
 
   280   m_gotDoubleA = false;
 
   278   m_gotDoubleA = false;
 
   281   m_gotDoubleB = false;
 
   279   m_gotDoubleB = false;
 
   282   traceDoubleA (0);
 
   280   traceDoubleA (0);
 
   283   traceDoubleB (0);
 
   281   traceDoubleB (0);
 
   284   if (!m_gotDoubleA || m_gotDoubleB)
 
   282   if (!m_gotDoubleA || m_gotDoubleB)
 
   287     }
 
   285     }
 
   288   resolver.Disconnect ("/trace-double-a", 
   286   resolver.Disconnect ("/trace-double-a", 
   289 		       MakeCallback (&CompositeTraceResolverTest::TraceDouble, this));
 
   287 		       MakeCallback (&CompositeTraceResolverTest::TraceDouble, this));
 
   290 
   288 
   291   resolver.Connect ("/(trace-double-a|trace-double-b)", 
   289   resolver.Connect ("/(trace-double-a|trace-double-b)", 
   292 		    MakeCallback (&CompositeTraceResolverTest::TraceDouble, this));
 
   290 		    MakeCallback (&CompositeTraceResolverTest::TraceDouble, this), TraceContext ());
 
   293   m_gotDoubleA = false;
 
   291   m_gotDoubleA = false;
 
   294   m_gotDoubleB = false;
 
   292   m_gotDoubleB = false;
 
   295   traceDoubleA (0);
 
   293   traceDoubleA (0);
 
   296   traceDoubleB (0);
 
   294   traceDoubleB (0);
 
   297   if (!m_gotDoubleA || !m_gotDoubleB)
 
   295   if (!m_gotDoubleA || !m_gotDoubleB)
 
   324   resolver.Add ("subresolver", 
   322   resolver.Add ("subresolver", 
   325 		MakeCallback (&CompositeTraceResolverTest::CreateSubResolver, this),
 
   323 		MakeCallback (&CompositeTraceResolverTest::CreateSubResolver, this),
 
   326 		TraceSourceTest (TraceSourceTest::SUBRESOLVER));
 
   324 		TraceSourceTest (TraceSourceTest::SUBRESOLVER));
 
   327 
   325 
   328   resolver.Connect ("/subresolver/trace-int", 
   326   resolver.Connect ("/subresolver/trace-int", 
   329 		    MakeCallback (&CompositeTraceResolverTest::TraceInt, this));
 
   327 		    MakeCallback (&CompositeTraceResolverTest::TraceInt, this), TraceContext ());
 
   330   m_gotInt = false;
 
   328   m_gotInt = false;
 
   331   m_traceInt (1);
 
   329   m_traceInt (1);
 
   332   if (!m_gotInt)
 
   330   if (!m_gotInt)
 
   333     {
 
   331     {
 
   334       ok = false;
 
   332       ok = false;
 
   342     {
 
   340     {
 
   343       ok = false;
 
   341       ok = false;
 
   344     }
 
   342     }
 
   345 
   343 
   346   resolver.Connect ("/*/trace-int", 
   344   resolver.Connect ("/*/trace-int", 
   347 		    MakeCallback (&CompositeTraceResolverTest::TraceInt, this));
 
   345 		    MakeCallback (&CompositeTraceResolverTest::TraceInt, this), TraceContext ());
 
   348   m_gotInt = false;
 
   346   m_gotInt = false;
 
   349   m_traceInt (1);
 
   347   m_traceInt (1);
 
   350   if (!m_gotInt)
 
   348   if (!m_gotInt)
 
   351     {
 
   349     {
 
   352       ok = false;
 
   350       ok = false;
lalith/ns-3-click-dev