src/core/composite-trace-resolver.cc
changeset 1345 eb06ae6eb180
parent 1338 253557415994
child 1352 34176d861b6e
equal deleted inserted replaced
1344:2e0770120285 1345:eb06ae6eb180
    62   item->maker = createResolver;
    62   item->maker = createResolver;
    63   AddItem (item);
    63   AddItem (item);
    64 }
    64 }
    65 
    65 
    66 void 
    66 void 
       
    67 CompositeTraceResolver::Add (std::string name,
       
    68                              FVTraceSourceBase &trace)
       
    69 {
       
    70   DoAddFV (name, trace, TraceContext ());
       
    71 }
       
    72 
       
    73 
       
    74 void 
       
    75 CompositeTraceResolver::DoAddFV (std::string name,
       
    76                                FVTraceSourceBase &trace, 
       
    77                                const TraceContext &context)
       
    78 {
       
    79   class FVCompositeItem : public CompositeItem
       
    80   {
       
    81   public:
       
    82     virtual void Connect (std::string subpath, const CallbackBase &cb, const TraceContext &context)
       
    83     {if (subpath == "") {trace->AddCallback (cb, context);}}
       
    84     virtual void Disconnect (std::string subpath, const CallbackBase &cb)
       
    85     {if (subpath == "") {trace->RemoveCallback (cb);}}
       
    86 
       
    87     FVTraceSourceBase *trace;
       
    88   } *item = new FVCompositeItem ();
       
    89   item->name = name;
       
    90   item->context = context;
       
    91   item->trace = &trace;
       
    92   AddItem (item);
       
    93 }
       
    94 
       
    95 void 
       
    96 CompositeTraceResolver::Add (std::string name,
       
    97                              UVTraceSourceBase &trace)
       
    98 {
       
    99   DoAddUV (name, trace, TraceContext ());
       
   100 }
       
   101 
       
   102 
       
   103 void 
       
   104 CompositeTraceResolver::DoAddUV (std::string name,
       
   105                                  UVTraceSourceBase &trace,
       
   106                                  const TraceContext &context)
       
   107 {
       
   108   class UVCompositeItem : public CompositeItem
       
   109   {
       
   110   public:
       
   111     virtual void Connect (std::string subpath, const CallbackBase &cb, const TraceContext &context)
       
   112     {if (subpath == "") {trace->AddCallback (cb, context);}}
       
   113     virtual void Disconnect (std::string subpath, const CallbackBase &cb)
       
   114     {if (subpath == "") {trace->RemoveCallback (cb);}}
       
   115 
       
   116     UVTraceSourceBase *trace;
       
   117   } *item = new UVCompositeItem ();
       
   118   item->name = name;
       
   119   item->context = context;
       
   120   item->trace = &trace;
       
   121   AddItem (item);
       
   122 }
       
   123 
       
   124 void
       
   125 CompositeTraceResolver::Add (std::string name,
       
   126                              SVTraceSourceBase &trace)
       
   127 {
       
   128   DoAddSV (name, trace, TraceContext ());
       
   129 }
       
   130 void
       
   131 CompositeTraceResolver::DoAddSV (std::string name,
       
   132                                  SVTraceSourceBase &trace, 
       
   133                                  const TraceContext &context)
       
   134 {
       
   135   class SVCompositeItem : public CompositeItem
       
   136   {
       
   137   public:
       
   138     virtual void Connect (std::string subpath, const CallbackBase &cb, const TraceContext &context)
       
   139     {if (subpath == "") {trace->AddCallback (cb, context);}}
       
   140     virtual void Disconnect (std::string subpath, const CallbackBase &cb)
       
   141     {if (subpath == "") {trace->RemoveCallback (cb);}}
       
   142 
       
   143     SVTraceSourceBase *trace;
       
   144   } *item = new SVCompositeItem ();
       
   145   item->name = name;
       
   146   item->context = context;
       
   147   item->trace = &trace;
       
   148   AddItem (item);
       
   149 }
       
   150 
       
   151 void 
       
   152 CompositeTraceResolver::DoAddCallback (std::string name,
       
   153                                        CallbackTraceSourceBase &trace, 
       
   154                                        const TraceContext &context)
       
   155 {
       
   156   class CallbackCompositeItem : public CompositeItem
       
   157   {
       
   158   public:
       
   159     virtual void Connect (std::string subpath, const CallbackBase &cb, const TraceContext &context)
       
   160     {if (subpath == "") {trace->AddCallback (cb, context);}}
       
   161     virtual void Disconnect (std::string subpath, const CallbackBase &cb)
       
   162     {if (subpath == "") {trace->RemoveCallback (cb);}}
       
   163 
       
   164     CallbackTraceSourceBase *trace;
       
   165   } *item = new CallbackCompositeItem ();
       
   166   item->name = name;
       
   167   item->context = context;
       
   168   item->trace = &trace;
       
   169   AddItem (item);
       
   170 }
       
   171 
       
   172 
       
   173 
       
   174 
       
   175 void 
    67 CompositeTraceResolver::AddChild (std::string name, Ptr<Object> child)
   176 CompositeTraceResolver::AddChild (std::string name, Ptr<Object> child)
    68 {
   177 {
    69   DoAddChild (name, child, TraceContext ());
   178   DoAddChild (name, child, TraceContext ());
    70 }
   179 }
    71 void 
   180 void 
   227 class TraceSourceTest : public TraceContextElement
   336 class TraceSourceTest : public TraceContextElement
   228 {
   337 {
   229 public:
   338 public:
   230   enum Sources {
   339   enum Sources {
   231     DOUBLEA,
   340     DOUBLEA,
   232     DOUBLEB
   341     DOUBLEB,
       
   342     UINT16_T
   233   };
   343   };
   234   static uint16_t GetUid (void) 
   344   static uint16_t GetUid (void) 
   235   {static uint16_t uid = AllocateUid<TraceSourceTest> ("TraceSourceTest"); return uid;}
   345   {static uint16_t uid = AllocateUid<TraceSourceTest> ("TraceSourceTest"); return uid;}
   236   void Print (std::ostream &os)
   346   void Print (std::ostream &os)
   237   {os << "tracesource=";
   347   {os << "tracesource=";
   238     if (m_sources == DOUBLEA) {os << "doubleA";}
   348     if (m_sources == DOUBLEA) {os << "doubleA";}
   239     else if (m_sources == DOUBLEB) {os << "doubleB";}}
   349     else if (m_sources == DOUBLEB) {os << "doubleB";}
       
   350     else if (m_sources == UINT16_T) {os << "uint16_t";}
       
   351   }
   240   TraceSourceTest () : m_sources (TraceSourceTest::DOUBLEA) {}
   352   TraceSourceTest () : m_sources (TraceSourceTest::DOUBLEA) {}
   241   TraceSourceTest (enum Sources sources) :m_sources (sources) {}
   353   TraceSourceTest (enum Sources sources) :m_sources (sources) {}
   242   bool IsDoubleA (void) {return m_sources == TraceSourceTest::DOUBLEA;}
   354   bool IsDoubleA (void) const {return m_sources == TraceSourceTest::DOUBLEA;}
   243   bool IsDoubleB (void) {return m_sources == TraceSourceTest::DOUBLEB;}
   355   bool IsDoubleB (void) const {return m_sources == TraceSourceTest::DOUBLEB;}
       
   356   bool IsUint16 (void) const {return m_sources == TraceSourceTest::UINT16_T;}
   244 private:
   357 private:
   245   enum TraceSourceTest::Sources m_sources;
   358   enum TraceSourceTest::Sources m_sources;
   246 };
   359 };
   247 
   360 
   248 class SubTraceSourceTest : public TraceContextElement
   361 class SubTraceSourceTest : public TraceContextElement
   460   if (m_gotInt)
   573   if (m_gotInt)
   461     {
   574     {
   462       ok = false;
   575       ok = false;
   463     }
   576     }
   464 
   577 
   465 
   578   SVTraceSource<uint16_t> source;
       
   579 
       
   580   resolver.Add ("uint16_t", source, TraceSourceTest (TraceSourceTest::UINT16_T));
   466   
   581   
   467 
   582 
   468   return ok;
   583   return ok;
   469 }
   584 }
   470 
   585