Attachment #1378 for bug #1383

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





namespace ns3 {

#ifdef USE_FREE_LIST

struct PacketTagList::TagData *PacketTagList::g_free = 0;
uint32_t PacketTagList::g_nfree = 0;

struct PacketTagList::TagData *
PacketTagList::AllocData (void) const
{
  NS_LOG_FUNCTION (g_nfree);
  struct PacketTagList::TagData *retval;
  if (g_free != 0) 
    {
      retval = g_free;
      g_free = g_free->m_next;
      g_nfree--;
    } 
  else 
    {
      retval = new struct PacketTagList::TagData ();
    }
  return retval;
}

void
PacketTagList::Add (Ptr<const Tag> tag)
{
  NS_LOG_FUNCTION (g_nfree << data);
  if (g_nfree > 1000) 
    {
      delete data;
      return;
    }
  g_nfree++;
  data->next = g_free;
  data->tid = TypeId ();
  g_free = data;
}
#else
struct PacketTagList::TagData *
PacketTagList::AllocData (void) const
{
  NS_LOG_FUNCTION (this << tag->GetInstanceTypeId ());
  struct PacketTagList::TagData *retval;
  retval = new struct PacketTagList::TagData ();
  return retval;
}

  NS_ASSERT_MSG (Peek (tag->GetInstanceTypeId ()) == 0,
                 "Only one tag type per packet is allowed");

  push_back (tag);
  delete data;
}
#endif

Ptr<const Tag>
PacketTagList::Remove (TypeId tagType)
{
  NS_LOG_FUNCTION (this << tagType);
  
  for (iterator tag = begin (); tag != end (); tag++)
  for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
    {
      if (cur->tid == tid) 
        {
          found = true;
          tag.Deserialize (TagBuffer (cur->data, cur->data+PACKET_TAG_MAX_SIZE));
        }
    }
  if (!found) 
    {
      if ((*tag)->GetInstanceTypeId () == tagType)
    }
  struct TagData *start = 0;
  struct TagData **prevNext = &start;
  for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
    {
      if (cur->tid == tid) 
        {
          Ptr<const Tag> retval = *tag;
          erase (tag);
          return retval;
           * avoid copying each TagData located after the target id
           * and just link the already-copied list to the next tag.
           */
          continue;
        }
      struct TagData *copy = AllocData ();
      copy->tid = cur->tid;
      copy->count = 1;
      copy->next = 0;
      memcpy (copy->data, cur->data, PACKET_TAG_MAX_SIZE);
      *prevNext = copy;
      prevNext = &copy->next;
    }
  *prevNext = 0;
  RemoveAll ();
  m_next = start;
  return true;
}

  return 0;
PacketTagList::Add (const Tag &tag) const
{
  NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ());
  // ensure this id was not yet added
  for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
    {
      NS_ASSERT (cur->tid != tag.GetInstanceTypeId ());
    }
  struct TagData *head = AllocData ();
  head->count = 1;
  head->next = 0;
  head->tid = tag.GetInstanceTypeId ();
  head->next = m_next;
  NS_ASSERT (tag.GetSerializedSize () <= PACKET_TAG_MAX_SIZE);
  tag.Serialize (TagBuffer (head->data, head->data+tag.GetSerializedSize ()));

  const_cast<PacketTagList *> (this)->m_next = head;
}

Ptr<const Tag>
PacketTagList::Peek (TypeId tagType) const
{
  NS_LOG_FUNCTION (this << tagType);
  for (const_iterator tag = begin (); tag != end (); tag++)
  for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
    {
      if ((*tag)->GetInstanceTypeId () == tagType)
        return *tag;
          /* found tag */
          tag.Deserialize (TagBuffer (cur->data, cur->data+PACKET_TAG_MAX_SIZE));
          return true;
        }
    }
  /* no tag found */
  return false;
}

  return 0;
PacketTagList::Head (void) const
{
  return m_next;
}


// bool
// PacketTagList::Remove (Tag &tag)
// {
//   NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ());

//   return false;
  
//   // TypeId tid = tag.GetInstanceTypeId ();
//   // bool found = false;
//   // for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
//   //   {
//   //     if (cur->tid == tid) 
//   //       {
//   //         found = true;
//   //         tag.Deserialize (TagBuffer (cur->data, cur->data+PACKET_TAG_MAX_SIZE));
//   //       }
//   //   }
//   // if (!found) 
//   //   {
//   //     return false;
//   //   }
//   // struct TagData *start = 0;
//   // struct TagData **prevNext = &start;
//   // for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
//   //   {
//   //     if (cur->tid == tid) 
//   //       {
//   //         /**
//   //          * XXX
//   //          * Note: I believe that we could optimize this to
//   //          * avoid copying each TagData located after the target id
//   //          * and just link the already-copied list to the next tag.
//   //          */
//   //         continue;
//   //       }
//   //     struct TagData *copy = AllocData ();
//   //     copy->tid = cur->tid;
//   //     copy->count = 1;
//   //     copy->next = 0;
//   //     memcpy (copy->data, cur->data, PACKET_TAG_MAX_SIZE);
//   //     *prevNext = copy;
//   //     prevNext = &copy->next;
//   //   }
//   // *prevNext = 0;
//   // RemoveAll ();
//   // m_next = start;
//   // return true;
// }

// void 
// PacketTagList::Add (const Tag &tag) const
// {
//   NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ());
//   // ensure this id was not yet added

//   // for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
//   //   {
//   //     NS_ASSERT (cur->tid != tag.GetInstanceTypeId ());
//   //   }

//   // struct TagData *head = AllocData ();
//   // head->count = 1;
//   // head->next = 0;
//   // head->tid = tag.GetInstanceTypeId ();
//   // head->next = m_next;
//   // NS_ASSERT (tag.GetSerializedSize () <= PACKET_TAG_MAX_SIZE);
//   // tag.Serialize (TagBuffer (head->data, head->data+tag.GetSerializedSize ()));

//   // const_cast<PacketTagList *> (this)->m_next = head;

//   // m_tags.
// }

// bool
// PacketTagList::Peek (Tag &tag) const
// {
//   NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ());
//   // TypeId tid = tag.GetInstanceTypeId ();
//   // for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
//   //   {
//   //     if (cur->tid == tid) 
//   //       {
//   //         /* found tag */
//   //         tag.Deserialize (TagBuffer (cur->data, cur->data+PACKET_TAG_MAX_SIZE));
//   //         return true;
//   //       }
//   //   }
  
//   /* no tag found */
//   return false;
// }

// // const struct PacketTagList::TagData *
// // PacketTagList::Head (void) const
// // {
// //   return m_next;
// // }

} // namespace ns3





#define PACKET_TAG_LIST_H

#include <stdint.h>
#include <list>
#include "ns3/type-id.h"

namespace ns3 {

 * The maximum size (in bytes) of a Tag is stored
 * in this constant.
 */
// #define PACKET_TAG_MAX_SIZE 20

class PacketTagList : public std::list<Ptr<const Tag> >
{
public:
  // struct TagData {
  //   std::vector<uint8_t> data;
  //   TypeId tid;
  //   uint32_t count;
  // };
  };

  // inline PacketTagList ();
  // inline PacketTagList (PacketTagList const &o);
  // inline PacketTagList &operator = (PacketTagList const &o);
  // inline ~PacketTagList ();

  void
  Add (Ptr<const Tag> tag);
  bool Peek (Tag &tag) const;
  inline void RemoveAll (void);

  Ptr<const Tag>
  Remove (TypeId tagType);

  Ptr<const Tag>
  Peek (TypeId tagType) const;
  bool Remove (TypeId tid);
  struct PacketTagList::TagData *AllocData (void) const;
  void FreeData (struct TagData *data) const;

  static struct PacketTagList::TagData *g_free;
  static uint32_t g_nfree;

  struct TagData *m_next;
};

} // namespace ns3


namespace ns3 {

// PacketTagList::PacketTagList ()
// {
// }

// PacketTagList::PacketTagList (PacketTagList const &o)
//   : m_tags (o.m_tags)
// {
// }

// PacketTagList &
// PacketTagList::operator = (PacketTagList const &o)
// {
//   // self assignment
//   if (&o == this)
//     {
//       return *this;
//     }
//   // RemoveAll (); // ???
//   m_tags = o.m_tags;
//   return *this;
// }

// PacketTagList::~PacketTagList ()
// {
//   RemoveAll ();
// }

// void
// PacketTagList::RemoveAll (void)
// {
//   m_tags.clear ();
// }
{
  RemoveAll ();
}

void
PacketTagList::RemoveAll (void)
{
  struct TagData *prev = 0;
  for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
    {
      cur->count--;
      if (cur->count > 0) 
        {
          break;
        }
      if (prev != 0) 
        {
          FreeData (prev);
        }
      prev = cur;
    }
  if (prev != 0) 
    {
      FreeData (prev);
    }
  m_next = 0;
}

} // namespace ns3





}


// PacketTagIterator::PacketTagIterator (const struct PacketTagList::TagData *head)
//   : m_current (head)
// {
// }
// bool
// PacketTagIterator::HasNext (void) const
// {
//   return m_current != 0;
// }
// PacketTagIterator::Item
// PacketTagIterator::Next (void)
// {
//   NS_ASSERT (HasNext ());
//   const struct PacketTagList::TagData *prev = m_current;
//   m_current = m_current->next;
//   return PacketTagIterator::Item (prev);
// }

// PacketTagIterator::Item::Item (const struct PacketTagList::TagData *data)
//   : m_data (data)
// {
// }
// TypeId
// PacketTagIterator::Item::GetTypeId (void) const
// {
//   return m_data->tid;
// }
// void
// PacketTagIterator::Item::GetTag (Tag &tag) const
// {
//   NS_ASSERT (tag.GetInstanceTypeId () == m_data->tid);
//   tag.Deserialize (TagBuffer ((uint8_t*)m_data->data, (uint8_t*)m_data->data+PACKET_TAG_MAX_SIZE));
// }


Ptr<Packet> 

  return false;
}

// void 
// Packet::AddPacketTag (const Tag &tag) const
// {
//   NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ().GetName () << tag.GetSerializedSize ());
//   m_packetTagList.Add (tag);
// }
// bool 
// Packet::RemovePacketTag (Tag &tag)
// {
//   NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ().GetName () << tag.GetSerializedSize ());
//   bool found = m_packetTagList.Remove (tag);
//   return found;
// }
// bool 
// Packet::PeekPacketTag (Tag &tag) const
// {
//   bool found = m_packetTagList.Peek (tag);
//   return found;
// }

void
Packet::AddPacketTag (Ptr<const Tag> tag)
{
  NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ().GetName () << tag.GetSerializedSize ());
  m_packetTagList.Add (tag);
}

Ptr<const Tag>
Packet::RemovePacketTag (TypeId tagType)
{
  return m_packetTagList.Remove (tagType);
  bool found = m_packetTagList.Remove (tag);
  return found;
}

Ptr<const Tag>
Packet::PeekPacketTag (TypeId tagType) const
{
  return m_packetTagList.Peek (tagType);
  return found;
}

void 
Packet::RemoveAllPacketTags (void)
{
  NS_LOG_FUNCTION (this);
  m_packetTagList.clear ();
}

void 
Packet::PrintPacketTags (std::ostream &os) const
{
  for (PacketTagList::const_iterator tag = m_packetTagList.begin ();
       tag != m_packetTagList.end ();
       tag++)
    {
      if (tag != m_packetTagList.begin ())
      NS_ASSERT (item.GetTypeId ().HasConstructor ());
      Callback<ObjectBase *> constructor = item.GetTypeId ().GetConstructor ();
      NS_ASSERT (!constructor.IsNull ());
      ObjectBase *instance = constructor ();
      Tag *tag = dynamic_cast<Tag *> (instance);
      NS_ASSERT (tag != 0);
      item.GetTag (*tag);
      tag->Print (os);
      delete tag;
      if (i.HasNext ())
        {
          os << " ";
        }
    }
}

      (*tag)->Print (os);
    }
  // PacketTagIterator i = GetPacketTagIterator ();
  // while (i.HasNext ())
  //   {
  //     PacketTagIterator::Item item = i.Next ();
  //     NS_ASSERT (item.GetTypeId ().HasConstructor ());
  //     Callback<ObjectBase *> constructor = item.GetTypeId ().GetConstructor ();
  //     NS_ASSERT (!constructor.IsNull ());
  //     ObjectBase *instance = constructor ();
  //     Tag *tag = dynamic_cast<Tag *> (instance);
  //     NS_ASSERT (tag != 0);
  //     item.GetTag (*tag);
  //     tag->Print (os);
  //     delete tag;
  //     if (i.HasNext ())
  //       {
  //         os << " ";
  //       }
  //   }
}

// PacketTagIterator 
// Packet::GetPacketTagIterator (void) const
// {
//   return PacketTagIterator (m_packetTagList.Head ());
// }

std::ostream& operator<< (std::ostream& os, const Packet &packet)
{





/**
 * \ingroup packet
 * \brief Iterator over the set of 'packet' tags in a packet
 *
 * This is a java-style iterator.
 */
class PacketTagIterator
{
public:
  /**
   * Identifies a tag within a packet.
   */
  class Item 
  {
public:
    /**
     * \returns the ns3::TypeId associated to this tag.
     */
    TypeId GetTypeId (void) const;
    /**
     * \param tag the user tag to which the data should be copied.
     *
     * Read the requested tag and store it in the user-provided
     * tag instance. This method will crash if the type of the
     * tag provided by the user does not match the type of
     * the underlying tag.
     */
    void GetTag (Tag &tag) const;
private:
    friend class PacketTagIterator;
    Item (const struct PacketTagList::TagData *data);
    const struct PacketTagList::TagData *m_data;
  };
  /**
   * \returns true if calling Next is safe, false otherwise.
   */
  bool HasNext (void) const;
  /**
   * \returns the next item found and prepare for the next one.
   */
  Item Next (void);
private:
  friend class Packet;
  PacketTagIterator (const struct PacketTagList::TagData *head);
  const struct PacketTagList::TagData *m_current;
};

/**
 * \ingroup packet
 * \brief network packets
 *
 * Each network packet contains a byte buffer, a set of byte tags, a set of

  /**
   * \param tag the tag to store in this packet
   *
   * Add a tag to this packet.
   */
  void
  AddPacketTag (Ptr<const Tag> tag);

  /**
   * \param tag the tag to remove from this packet
   * \returns smart pointer to a constant Tag object if the requested tag is found, 
   *          0 otherwise.
   *
   * Remove a tag from this packet. 
   * modify the state of this packet, which is fairly
   * un-intuitive.
   */
  Ptr<const Tag>
  RemovePacketTag (TypeId tagType);

  /**
   * \param tag the tag to remove from this packet
   * \returns smart pointer to a constant Tag object if the requested tag is found, 
   *          0 otherwise.
   *
   * Templated version to remove a tag from this packet.
   * In addition to non-templated version, there is a DynamicCast to
   * the requested tag type
   */
  template<class T>
  Ptr<const T>
  RemovePacketTag ()
  {
    return DynamicCast<const T> (RemovePacketTag (T::GetTypeId ()));
  }
  
  /**
   * \param tag the tag to search in this packet
   * \returns true if the requested tag is found, false
   *          otherwise.
   *
   * Search a matching tag and return it if found
   * Tag::Deserialize if the tag is found.
   */
  Ptr<const Tag>
  PeekPacketTag (TypeId tagType) const;

  /**
   * \param tag the tag to search in this packet
   * \returns true if the requested tag is found, false
   *          otherwise.
   *
   * Templated version of search for a matching tag and returning it if found
   * In addition to non-templated version, there is a DynamicCast to
   * the requested tag type
   */
  template<class T>
  Ptr<const T>
  PeekPacketTag () const
  {
    return DynamicCast<const T> (PeekPacketTag (T::GetTypeId ()));
  }
  
  /**
   * Remove all packet tags.
   */

   * \returns an object which can be used to iterate over the list of
   *  packet tags.
   */
  // PacketTagIterator GetPacketTagIterator (void) const;

  /* Note: These functions support a temporary solution 
   * to a specific problem in this generic class, i.e. 

(-)a/src/network/model/tag.h (-3 / +9 lines)

Lines 20-26	Link Here

#ifndef TAG_H

#ifndef TAG_H

#define TAG_H

#define TAG_H

#include "ns3/object-base.h"

#include "ns3/object.h"

#include "tag-buffer.h"

#include "tag-buffer.h"

#include <stdint.h>

#include <stdint.h>

Lines 33-39 namespace ns3 {	Link Here

 * New kinds of tags can be created by subclassing this base class.

 * New kinds of tags can be created by subclassing this base class.

*/

*/

class Tag : public ObjectBase

class Tag : public Object

public:

public:

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

Lines 71-76 public:	Link Here

  virtual void Print (std::ostream &os) const = 0;

  virtual void Print (std::ostream &os) const = 0;

};

};

inline std::ostream &

operator << (std::ostream &os, const Tag &tag)

  tag.Print (os);

  return os;

} // namespace ns3

} // namespace ns3

#endif /* TAG_H */

#endif /* TAG_H */

Return to bug 1383