Attachment #13 for bug #15

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






void 
TagRegistry::Record (std::string uuid, PrettyPrinter prettyPrinter, Destructor destructor)
{
  NS_ASSERT (!m_sorted);
  struct TagInfoItem item;
  item.uuid = uuid;
  item.printer = prettyPrinter;
  item.destructor = destructor;
  m_registry.push_back (item);
}
bool 
TagRegistry::CompareItem (const struct TagInfoItem &a, const struct TagInfoItem &b)
{
  return a.uuid < b.uuid;
}
uint32_t 
TagRegistry::LookupUid (std::string uuid)
{
  if (!m_sorted) 
    {
      std::sort (m_registry.begin (), m_registry.end (), &TagRegistry::CompareItem);
      m_sorted = true;
    }
  NS_ASSERT (m_sorted);
  uint32_t uid = 1;
  for (TagsDataCI i = m_registry.begin (); i != m_registry.end (); i++) 
    {
      if (i->uuid == uuid) 
        {
          return uid;
        }

  NS_ASSERT (uid > 0);
  uint32_t index = uid - 1;
  NS_ASSERT (m_registry.size () > index);
  PrettyPrinter prettyPrinter = m_registry[index].printer;
  if (prettyPrinter != 0) 
    {
      prettyPrinter (buf, os);
    }
}
void 
TagRegistry::Destruct (uint32_t uid, uint8_t buf[Tags::SIZE])
{
  NS_ASSERT (uid > 0);
  uint32_t index = uid - 1;
  NS_ASSERT (m_registry.size () > index);
  Destructor destructor = m_registry[index].destructor;
  NS_ASSERT (destructor != 0);
  destructor (buf);
}



#ifdef USE_FREE_LIST

  uint8_t z;
};

class MySmartTag 
{
public:
  MySmartTag ()
  {
    std::cout << "construct" << std::endl;
  }
  MySmartTag (const MySmartTag &o)
  {
    std::cout << "copy" << std::endl;
  }
  ~MySmartTag ()
  {
    std::cout << "destruct" << std::endl;
  }
  MySmartTag &operator = (const MySmartTag &o)
  {
    std::cout << "assign" << std::endl;
    return *this;
  }
  static void PrettyPrinterCb (const MySmartTag *a, std::ostream &os)
  {}
};

static void 
myTagAPrettyPrinterCb (struct myTagA const*a, std::ostream &os)
{

static TagRegistration<struct myTagC> gMyTagCRegistration ("C", &myTagCPrettyPrinterCb);
static TagRegistration<struct myTagZ> g_myTagZRegistration ("ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ", 
                                                            &myTagZPrettyPrinterCb);
static TagRegistration<MySmartTag> g_myTagSmartRegistration ("SmartTag", &MySmartTag::PrettyPrinterCb);


TagsTest::TagsTest ()

      ok = false;
    }
  struct myTagB oB;
  oB.b = 1;
  other.Peek (oB);
  if (oB.b != 0xff) 
    {

  other = tags;
  Tags another = other;
  struct myTagC c;
  memset (c.c, 0x66, 16);
  another.Add (c);
  c.c[0] = 0;
  another.Peek (c);


  struct myTagZ tagZ;
  Tags testLastTag;
  tagZ.z = 0;
  testLastTag.Add (tagZ);
  g_z = false;
  testLastTag.PrettyPrint (std::cout);

      ok = false;
    }

  MySmartTag smartTag;
  {
    Tags tmp;
    tmp.Add (smartTag);
    tmp.Peek (smartTag);
    tmp.Remove (smartTag);
  }

  return ok;
}





  };
private:
  struct TagData {
      uint8_t m_data[Tags::SIZE];
      struct TagData *m_next;
      uint32_t m_id;
      uint32_t m_count;
      uint8_t m_data[Tags::SIZE];
  };

  bool Remove (uint32_t id);

  TagRegistration<T> (std::string uuid, void(*fn) (T const*, std::ostream &));
private:
  static void PrettyPrinterCb (uint8_t *buf, std::ostream &os);
  static void DestructorCb (uint8_t *buf);
  static void(*m_prettyPrinter) (T const*, std::ostream &);
};


class TagRegistry {
public:
  typedef void (*PrettyPrinter) (uint8_t [Tags::SIZE], std::ostream &);
  typedef void (*Destructor) (uint8_t [Tags::SIZE]);
  static void Record (std::string uuid, PrettyPrinter prettyPrinter, Destructor destructor);
  /**
   * returns a numeric integer which uniquely identifies the input string.
   * that integer cannot be zero which is a reserved value.
   */
  static uint32_t LookupUid (std::string uuid);
  static void PrettyPrint (uint32_t uid, uint8_t buf[Tags::SIZE], std::ostream &os);
  static void Destruct (uint32_t uid, uint8_t buf[Tags::SIZE]);
private:
  struct TagInfoItem
  {
    std::string uuid;
    PrettyPrinter printer;
    Destructor destructor;
  };
  typedef std::vector<struct TagInfoItem> TagsData;
  typedef std::vector<struct TagInfoItem>::const_iterator TagsDataCI;
  static bool CompareItem (const struct TagInfoItem &a, const struct TagInfoItem &b);
  static bool m_sorted;
  static TagsData m_registry;
};

{
  NS_ASSERT (sizeof (T) <= Tags::SIZE);
  m_prettyPrinter  = prettyPrinter;
  TagRegistry::Record (uuid, &TagRegistration<T>::PrettyPrinterCb, &TagRegistration<T>::DestructorCb);
  TypeUid<T>::Record (uuid);
}
template <typename T>

  T *tag = reinterpret_cast<T *> (buf);
  (*m_prettyPrinter) (tag, os);
}
template <typename T>
void
TagRegistration<T>::DestructorCb (uint8_t *buf)
{
  T *tag = reinterpret_cast<T *> (buf);
  tag->~T ();
}
template <typename T>
void (*TagRegistration<T>::m_prettyPrinter) (T const*, std::ostream &) = 0;


Tags::Add (T const&tag)
{
  NS_ASSERT (sizeof (T) <= Tags::SIZE);
  uint8_t const*buf = reinterpret_cast<uint8_t const*> (&tag);
  // ensure this id was not yet added
  for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next) 
    {

  newStart->m_count = 1;
  newStart->m_next = 0;
  newStart->m_id = TypeUid<T>::GetUid ();
  void *buf = &newStart->m_data;
  new (buf) T (tag);
  newStart->m_next = m_next;
  m_next = newStart;
}

Tags::Peek (T &tag) const
{
  NS_ASSERT (sizeof (T) <= Tags::SIZE);
  uint8_t *buf = reinterpret_cast<uint8_t *> (&tag);
  for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next) 
    {
      if (cur->m_id == TypeUid<T>::GetUid ()) 
        {
          /* found tag */
          T *data = reinterpret_cast<T *> (&cur->m_data);
          tag = T (*data);
          return true;
        }
    }

        }
      if (prev != 0) 
        {
          TagRegistry::Destruct (prev->m_id, prev->m_data);
          FreeData (prev);
        }
      prev = cur;
    }
  if (prev != 0) 
    {
      TagRegistry::Destruct (prev->m_id, prev->m_data);
      FreeData (prev);
    }
  m_next = 0;

Return to bug 15