packet.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2005,2006 INRIA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */
#ifndef PACKET_H
#define PACKET_H

#include <stdint.h>
#include "buffer.h"
#include "header.h"
#include "trailer.h"
#include "packet-metadata.h"
#include "tag.h"
#include "byte-tag-list.h"
#include "packet-tag-list.h"
#include "nix-vector.h"
#include "ns3/mac48-address.h"
#include "ns3/callback.h"
#include "ns3/assert.h"
#include "ns3/ptr.h"
#include "ns3/deprecated.h"

namespace ns3 {

// Forward declaration
class Address;
  
class ByteTagIterator
{
public:
  class Item
  {
public:
    TypeId GetTypeId (void) const;
    uint32_t GetStart (void) const;
    uint32_t GetEnd (void) const;
    void GetTag (Tag &tag) const;
private:
    friend class ByteTagIterator;
    Item (TypeId tid, uint32_t start, uint32_t end, TagBuffer buffer);

    TypeId m_tid;       
    uint32_t m_start;   
    uint32_t m_end;     
    TagBuffer m_buffer; 
  };
  bool HasNext (void) const;
  Item Next (void);
private:
  friend class Packet;
  ByteTagIterator (ByteTagList::Iterator i);
  ByteTagList::Iterator m_current; 
};

class PacketTagIterator
{
public:
  class Item 
  {
public:
    TypeId GetTypeId (void) const;
    void GetTag (Tag &tag) const;
private:
    friend class PacketTagIterator;
    Item (const struct PacketTagList::TagData *data);
    const struct PacketTagList::TagData *m_data; 
  };
  bool HasNext (void) const;
  Item Next (void);
private:
  friend class Packet;
  PacketTagIterator (const struct PacketTagList::TagData *head);
  const struct PacketTagList::TagData *m_current;  
};

class Packet : public SimpleRefCount<Packet>
{
public:

  Packet ();
  Packet (const Packet &o);
  Packet &operator = (const Packet &o);
  Packet (uint32_t size);
  Packet (uint8_t const*buffer, uint32_t size, bool magic);
  Packet (uint8_t const*buffer, uint32_t size);
  Ptr<Packet> CreateFragment (uint32_t start, uint32_t length) const;
  inline uint32_t GetSize (void) const;
  void AddHeader (const Header & header);
  uint32_t RemoveHeader (Header &header);
  uint32_t RemoveHeader (Header &header, uint32_t size);
  uint32_t PeekHeader (Header &header) const;
  uint32_t PeekHeader (Header &header, uint32_t size) const;
  void AddTrailer (const Trailer &trailer);
  uint32_t RemoveTrailer (Trailer &trailer);
  uint32_t PeekTrailer (Trailer &trailer);

  void AddAtEnd (Ptr<const Packet> packet);
  void AddPaddingAtEnd (uint32_t size);
  void RemoveAtEnd (uint32_t size);
  void RemoveAtStart (uint32_t size);

  uint32_t CopyData (uint8_t *buffer, uint32_t size) const;

  void CopyData (std::ostream *os, uint32_t size) const;

  Ptr<Packet> Copy (void) const;

  uint64_t GetUid (void) const;

  void Print (std::ostream &os) const;

  std::string ToString (void) const;

  PacketMetadata::ItemIterator BeginItem (void) const;

  static void EnablePrinting (void);
  static void EnableChecking (void);

  uint32_t GetSerializedSize (void) const;

  uint32_t Serialize (uint8_t* buffer, uint32_t maxSize) const;

  void AddByteTag (const Tag &tag) const;
  ByteTagIterator GetByteTagIterator (void) const;
  bool FindFirstMatchingByteTag (Tag &tag) const;

  void RemoveAllByteTags (void);

  void PrintByteTags (std::ostream &os) const;

  void AddPacketTag (const Tag &tag) const;
  bool RemovePacketTag (Tag &tag);
  bool ReplacePacketTag (Tag & tag);
  bool PeekPacketTag (Tag &tag) const;
  void RemoveAllPacketTags (void);

  void PrintPacketTags (std::ostream &os) const;

  PacketTagIterator GetPacketTagIterator (void) const;

  void SetNixVector (Ptr<NixVector> nixVector);
  Ptr<NixVector> GetNixVector (void) const; 

  typedef void (* TracedCallback) (Ptr<const Packet> packet);
  
  typedef void (* AddressTracedCallback)
    (Ptr<const Packet> packet, const Address &address);
  
  typedef void (* Mac48AddressTracedCallback)
    (Ptr<const Packet> packet, Mac48Address mac);
  
  typedef void (* SizeTracedCallback)
    (uint32_t oldSize, uint32_t newSize);

  typedef void (* SinrTracedCallback)
    (Ptr<const Packet> packet, double sinr);
    
  
private:
  Packet (const Buffer &buffer, const ByteTagList &byteTagList, 
          const PacketTagList &packetTagList, const PacketMetadata &metadata);

  uint32_t Deserialize (uint8_t const*buffer, uint32_t size);

  Buffer m_buffer;                
  ByteTagList m_byteTagList;      
  PacketTagList m_packetTagList;  
  PacketMetadata m_metadata;      

  /* Please see comments above about nix-vector */
  Ptr<NixVector> m_nixVector; 

  static uint32_t m_globalUid; 
};

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

} // namespace ns3

/****************************************************
 *  Implementation of inline methods for performance
 ****************************************************/

namespace ns3 {

uint32_t 
Packet::GetSize (void) const
{
  return m_buffer.GetSize ();
}

} // namespace ns3

#endif /* PACKET_H */