unison/src/common/trace-context-element.h

#ifndef TRACE_CONTEXT_ELEMENT_H
#define TRACE_CONTEXT_ELEMENT_H

#include <string>
#include <vector>

#define NS_TRACE_CONTEXT_ELEMENT_ENSURE_REGISTERED(x)          \
namespace {						       \
static class thisisaveryverylongclassname ##x		       \
  {							       \
  public:						       \
    thisisaveryverylongclassname ##x ()			       \
      { uint32_t uid; uid = x::GetUid ();}		       \
  } g_thisisanotherveryveryverylongname ##x ;		       \
}

namespace ns3 {

/**
 * \brief an item stored in a TraceContext
 *
 * To store trace context information in a TraceContext instance,
 * users must subclass this base class and store subclass instances
 * in a TraceContext with TraceContext::Add.
 *
 * Each subclass should define and implement:
 *   - a public default constructor: it is used by the internals
 *     of the implementation of TraceContext.
 *   - a public destructor: it is also used by the internals of
 *     the implementation of TraceContext.
 *   - a public static method named GetUid which returns a 16 bit 
 *     integer. The integer returned from this method should be
 *     allocated with the protected AllocatedUid method.
 *   - a public Print method: this method is used by the 
 *     TraceContext::Print method to print the content of each
 *     of the trace context element stored in the trace context.
 *     This method takes a c++ output stream and argument and is
 *     expected to write an ascii string describing its content
 *     in this output stream.
 *
 * A typical subclass should look like this:
 * \code
 * class MyContext : public TraceContextElement
 * {
 * public:
 *   // the _required_ public API
 *   static uint16_t GetUid (void);
 *   MyContext ();
 *   ~MyContext ();
 *   void Print (std::ostream &os) const;
 *
 *   // the user-specific API to manipulate the context.
 *   void SetData (uint8_t data);
 *   uint8_t GetData (void) const;
 * private:
 *   uint8_t m_myContextData;
 * };
 *
 * uint16_t 
 * MyContext::GetUid (void)
 * {
 *   static uint16_t uid = AllocateUid<MyContext> ("MyContext");
 *   return uid;
 * }
 * MyContext::MyContext ()
 * {}
 * MyContext::~MyContext ()
 * {}
 * void 
 * MyContext::Print (std::ostream &os) const
 * {
 *   os << "mycontext=" << (uint32_t) m_myContextData;
 * }
 * void 
 * MyContext::SetData (uint8_t data)
 * {
 *   m_myContextData = data;
 * }
 * uint8_t 
 * MyContext::GetData (void) const
 * {
 *   return m_myContextData;
 * }
 * \endcode
 */
class TraceContextElement
{
protected:
  /**
   * \param name a string which uniquely identifies the type
   *        of the subclass which is calling this method.
   * \returns a unique 32 bit integer associated to the
   *          input string.
   *
   * Subclasses are expected to call this method from their
   * public static GetUid method.
   */
  template <typename T>
  static uint16_t AllocateUid (std::string name);
};

} // namespace ns3

namespace ns3 {

/**
 * \brief a registry of TraceContextElement subclasses
 * \internal
 */
class ElementRegistry
{
public:
  template <typename T>
  static uint16_t AllocateUid (std::string name);

  static uint32_t GetSize (uint16_t uid);
  static void Print (uint16_t uid, uint8_t *instance, std::ostream &os);
  static void Destroy (uint16_t uid, uint8_t *instance);
private:
  typedef void (*PrintCb) (uint8_t *instance, std::ostream &os);
  typedef void (*DestroyCb) (uint8_t *instance);
  struct Info {
    uint32_t size;
    std::string uidString;
    PrintCb print;
    DestroyCb destroy;
  };
  typedef std::vector<struct Info> InfoVector;
  static InfoVector *GetInfoVector (void);
  template <typename T>
  static void DoPrint (uint8_t *instance, std::ostream &os);
  template <typename T>
  static void DoDestroy (uint8_t *instance);  
};

template <typename T>
void 
ElementRegistry::DoPrint (uint8_t *instance, std::ostream &os)
{
  static T obj;
  // make sure we are aligned.
  memcpy ((void*)&obj, instance, sizeof (T));
  obj.Print (os);
}
template <typename T>
void 
ElementRegistry::DoDestroy (uint8_t *instance)
{
  static T obj;
  // make sure we are aligned.
  memcpy ((void*)&obj, instance, sizeof (T));
  obj.~T ();
}

template <typename T>
uint16_t 
ElementRegistry::AllocateUid (std::string name)
{
  InfoVector *vec = GetInfoVector ();
  uint16_t uid = 1;
  for (InfoVector::iterator i = vec->begin (); i != vec->end (); i++)
    {
      if (i->uidString == name)
	{
	  return uid;
	}
      uid++;
    }
  struct Info info;
  info.size = sizeof (T);
  info.uidString = name;
  info.print = &ElementRegistry::DoPrint<T>;
  info.destroy = &ElementRegistry::DoDestroy<T>;
  vec->push_back (info);
  return vec->size ();
}



template <typename T>
uint16_t 
TraceContextElement::AllocateUid (std::string name)
{
  return ElementRegistry::AllocateUid<T> (name);
}

} // namespace ns3

#endif /* TRACE_CONTEXT_ELEMENT_H */