Attachment #103 for bug #127

View | Details | Raw Unified | Return to bug 127
Collapse All | Expand All

(-)a/src/core/callback-trace-source.h (-2 / +15 lines)

Lines 23-34	Link Here

#define CALLBACK_TRACE_H

#define CALLBACK_TRACE_H

#include <list>

#include <list>

#include <typeinfo>

#include "callback.h"

#include "callback.h"

#include "fatal-error.h"

#include "fatal-error.h"

#include "trace-context.h"

#include "trace-context.h"

#include "trace-source.h"

#include "trace-source.h"

namespace ns3 {

namespace ns3 {

class CallbackTraceSourceBase : public TraceSource

public:

  virtual const std::type_info& GetCallbackType () const = 0;

};

/**

/**

 * \brief log arbitrary number of parameters to a matching ns3::Callback

 * \brief log arbitrary number of parameters to a matching ns3::Callback

Lines 39-50 namespace ns3 {	Link Here

*/

*/

template<typename T1 = empty, typename T2 = empty,

template<typename T1 = empty, typename T2 = empty,

         typename T3 = empty, typename T4 = empty>

         typename T3 = empty, typename T4 = empty>

class CallbackTraceSource : public TraceSource {

class CallbackTraceSource : public CallbackTraceSourceBase {

public:

public:

  typedef Callback<void,TraceContext const &,T1,T2,T3,T4> CallbackType;

  CallbackTraceSource ();

  CallbackTraceSource ();

  virtual void AddCallback (CallbackBase const & callback, TraceContext const & context);

  virtual void AddCallback (CallbackBase const & callback, TraceContext const & context);

  virtual void RemoveCallback (CallbackBase const & callback);

  virtual void RemoveCallback (CallbackBase const & callback);

  virtual void ConnectPrinter (std::ostream &os, const TraceContext &context);

  virtual void ConnectPrinter (std::ostream &os, const TraceContext &context);

  virtual const std::type_info& GetCallbackType () const {

    return typeid (CallbackType);

  void operator() (void) const;

  void operator() (void) const;

  void operator() (T1 a1) const;

  void operator() (T1 a1) const;

  void operator() (T1 a1, T2 a2) const;

  void operator() (T1 a1, T2 a2) const;

Lines 52-58 public:	Link Here

  void operator() (T1 a1, T2 a2, T3 a3, T4 a4) const;

  void operator() (T1 a1, T2 a2, T3 a3, T4 a4) const;

private:

private:

  typedef std::list<Callback<void,TraceContext const &,T1,T2,T3,T4> > CallbackList;

  typedef std::list<CallbackType> CallbackList;

  TraceContext m_context;

  TraceContext m_context;

  CallbackList m_callbackList;

  CallbackList m_callbackList;

};

};




      path.append (this->name);
      TraceContext ctx = context;
      ctx.Union (this->context);
      collection->AddUnique (path, ctx, this->doc, GetCallbackType ());
    }
    virtual void TraceAll (std::ostream &os, const TraceContext &context)
    {

    }
    TraceSource *trace;
    TraceDoc doc;

    const std::type_info* GetCallbackType ()
    {
      const CallbackTraceSourceBase *callbackSource =
        dynamic_cast<const CallbackTraceSourceBase *> (trace);
      if (callbackSource == NULL)
        {
          return NULL;
        }
      else
        {
          return &callbackSource->GetCallbackType ();
        }
    }
  } *item = new SourceResolveItem ();
  item->name = name;
  item->context = context;

bool 
CompositeTraceResolverTest::RunTests (void)
{
  bool result = true;

  CallbackTraceSource<double> traceDoubleA;
  CallbackTraceSource<double> traceDoubleB;


  resolver.Connect ("/*", MakeCallback (&CompositeTraceResolverTest::TraceDouble, this), TraceContext ());

  {
    TraceResolver::SourceCollection collection;
    resolver.CollectSources ("/*", context, &collection);

    int numSources = 0;
    for (TraceResolver::SourceCollection::Iterator source = collection.Begin ();
         source != collection.End (); source++)
      {
        NS_TEST_ASSERT (source->callbackType != NULL);
        if (source->callbackType != NULL)
          {
            numSources++;
            NS_TEST_ASSERT (*source->callbackType == typeid (Callback<void, TraceContext const &, double>));
          }
      }
    NS_TEST_ASSERT (numSources > 0);
  }

  m_gotDoubleA = false;
  m_gotDoubleB = false;
  traceDoubleA (0);
  if (!m_gotDoubleA || m_gotDoubleB)
    {
      result = false;
    }
  m_gotDoubleA = false;
  traceDoubleA (0);
  traceDoubleB (0);
  if (!m_gotDoubleA || !m_gotDoubleB)
    {
      result = false;
    }
  m_gotDoubleA = false;
  m_gotDoubleB = false;

  traceDoubleB (0);
  if (m_gotDoubleA || m_gotDoubleB)
    {
      result = false;
    }

  resolver.Connect ("/trace-double-a", 

  traceDoubleB (0);
  if (!m_gotDoubleA || m_gotDoubleB)
    {
      result = false;
    }
  resolver.Disconnect ("/trace-double-a", 
		       MakeCallback (&CompositeTraceResolverTest::TraceDouble, this));

  traceDoubleB (0);
  if (!m_gotDoubleA || m_gotDoubleB)
    {
      result = false;
    }
  resolver.Disconnect ("/trace-double-a", 
		       MakeCallback (&CompositeTraceResolverTest::TraceDouble, this));

  traceDoubleB (0);
  if (!m_gotDoubleA || !m_gotDoubleB)
    {
      result = false;
    }
  resolver.Disconnect ("/trace-double-a", 
		       MakeCallback (&CompositeTraceResolverTest::TraceDouble, this));

  traceDoubleB (0);
  if (m_gotDoubleA || !m_gotDoubleB)
    {
      result = false;
    }



  traceDoubleB (0);
  if (m_gotDoubleA || m_gotDoubleB)
    {
      result = false;
    }

  resolver.Add ("subresolver", 

  m_traceInt (1);
  if (!m_gotInt)
    {
      result = false;
    }

  resolver.Disconnect ("/subresolver/trace-int", 

  m_traceInt (1);
  if (m_gotInt)
    {
      result = false;
    }

  resolver.Connect ("/*/trace-int", 

  m_traceInt (1);
  if (!m_gotInt)
    {
      result = false;
    }

  resolver.Disconnect ("/subresolver/trace-int", 

  m_traceInt (1);
  if (m_gotInt)
    {
      result = false;
    }

  SVTraceSource<uint16_t> source;

  resolver.AddSource ("uint16_t", TraceDoc ("test source"), source, TraceSourceTest (TraceSourceTest::UINT16_T));
  

  return result;
}

static CompositeTraceResolverTest g_compositeTraceResolverTest;

(-)a/src/core/trace-resolver.cc (-1 / +3 lines)

Lines 78-84 void	Link Here

void

void

TraceResolver::SourceCollection::AddUnique (std::string path,

TraceResolver::SourceCollection::AddUnique (std::string path,

                                            const TraceContext &context,

                                            const TraceContext &context,

                                            const TraceDoc &doc)

                                            const TraceDoc &doc,

                                            const std::type_info *callbackType)

  for (SourceVector::const_iterator i = m_sources.begin (); i != m_sources.end (); i++)

  for (SourceVector::const_iterator i = m_sources.begin (); i != m_sources.end (); i++)

Lines 92-97 TraceResolver::SourceCollection::AddUniq	Link Here

  source.path = path;

  source.path = path;

  source.context = context;

  source.context = context;

  source.doc = doc;

  source.doc = doc;

  source.callbackType = callbackType;

  m_sources.push_back (source);

  m_sources.push_back (source);

TraceResolver::SourceCollection::Iterator

TraceResolver::SourceCollection::Iterator





#include <string>
#include <list>
#include <typeinfo>
#include "trace-context.h"
#include "trace-doc.h"


       * Document the signature of this trace source
       */
      TraceDoc doc;
      /**
       * Type info of the Callback, or NULL if it's not a callback source
       */
      const std::type_info *callbackType;
    };
    typedef std::vector<struct Source>::const_iterator Iterator;
    void AddUnique (std::string path, 
                    const TraceContext &context,
                    const TraceDoc &doc,
                    const std::type_info *callbackType);

    /**
     * \returns an iterator which points to the first element of the set of

Return to bug 127