/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2005,2006 INRIA

 * All rights reserved.

 *

 * 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 BUFFER_H

#define BUFFER_H

#include <stdint.h>

#include <vector>

namespace ns3 {

/**

 * \brief automatically resized byte buffer

 *

 * This represents a buffer of bytes. Its size is

 * automatically adjusted to hold any data prepended

 * or appended by the user. Its implementation is optimized

 * to ensure that the number of buffer resizes is minimized,

 * by creating new Buffers of the maximum size ever used.

 * The correct maximum size is learned at runtime during use by 

 * recording the maximum size of each packet.

 */

class Buffer {

public:

  /**

   * \brief iterator in a Buffer instance

   */

  class Iterator {

  public:

      inline Iterator ();

      /**

       * go forward by one byte

       */

      inline void Next (void);

      /**

       * go backward by one byte

       */

      inline void Prev (void);

      /**

       * \param delta number of bytes to go forward

       */

      inline void Next (uint32_t delta);

      /**

       * \param delta number of bytes to go backward

       */

      inline void Prev (uint32_t delta);

      /**

       * \param o the second iterator

       * \return number of bytes included between the two iterators

       *

       * This method works only if the two iterators point

       * to the same underlying buffer. Debug builds ensure

       * this with an assert.

       */

      inline int32_t GetDistanceFrom (Iterator const &o) const;

      /**

       * \return true if this iterator points to the end of the byte array.

       *     false otherwise.

       */

      inline bool IsEnd (void) const;

      /**

       * \return true if this iterator points to the start of the byte array.

       *     false otherwise.

       */

      inline bool IsStart (void) const;

      /**

       * \param data data to write in buffer

       *

       * Write the data in buffer and avance the iterator position

       * by one byte.

       */

      inline void WriteU8 (uint8_t  data);

      /**

       * \param data data to write in buffer

       * \param len number of times data must be written in buffer

       *

       * Write the data in buffer len times and avance the iterator position

       * by len byte.

       */

      inline void WriteU8 (uint8_t data, uint32_t len);

      /**

       * \param data data to write in buffer

       *

       * Write the data in buffer and avance the iterator position

       * by two bytes. The format of the data written in the byte

       * buffer is non-portable. We only ensure that readU16 will

       * return exactly what we wrote with writeU16 if the program

       * is run on the same machine.

       */

      inline void WriteU16 (uint16_t data);

      /**

       * \param data data to write in buffer

       *

       * Write the data in buffer and avance the iterator position

       * by four bytes. The format of the data written in the byte

       * buffer is non-portable. We only ensure that readU32 will

       * return exactly what we wrote with writeU32 if the program

       * is run on the same machine.

       */

      inline void WriteU32 (uint32_t data);

      /**

       * \param data data to write in buffer

       *

       * Write the data in buffer and avance the iterator position

       * by eight bytes. The format of the data written in the byte

       * buffer is non-portable. We only ensure that readU64 will

       * return exactly what we wrote with writeU64 if the program

       * is run on the same machine.

       */

      inline void WriteU64 (uint64_t data);

      /**

       * \param data data to write in buffer

       *

       * Write the data in buffer and avance the iterator position

       * by two bytes. The data is written in network order and the

       * input data is expected to be in host order.

       */

      inline void WriteHtonU16 (uint16_t data);

      /**

       * \param data data to write in buffer

       *

       * Write the data in buffer and avance the iterator position

       * by four bytes. The data is written in network order and the

       * input data is expected to be in host order.

       */

      inline void WriteHtonU32 (uint32_t data);

      /**

       * \param data data to write in buffer

       *

       * Write the data in buffer and avance the iterator position

       * by eight bytes. The data is written in network order and the

       * input data is expected to be in host order.

       */

      inline void WriteHtonU64 (uint64_t data);

      /**

       * \param buffer a byte buffer to copy in the internal buffer.

       * \param size number of bytes to copy.

       *

       * Write the data in buffer and avance the iterator position

       * by size bytes.

       */

      /**

       * \param start the start of the data to copy

       * \param end the end of the data to copy

       *

       * Write the data delimited by start and end in internal buffer 

       * and avance the iterator position by the number of bytes

       * copied.

       * The input interators _must_ not point to the same Buffer as

       * we do to avoid overlapping copies. This is enforced 

       * in debug builds by asserts.

       */

      inline void Write (Iterator start, Iterator end);

      /**

       * \return the byte read in the buffer.

       *

       * Read data and advance the Iterator by the number of bytes

       * read.

       */

      inline uint8_t  ReadU8 (void);

      /**

       * \return the two bytes read in the buffer.

       *

       * Read data and advance the Iterator by the number of bytes

       * read.

       * The data is read in the format written by writeU16.

       */

      inline uint16_t ReadU16 (void);

      /**

       * \return the four bytes read in the buffer.

       *

       * Read data and advance the Iterator by the number of bytes

       * read.

       * The data is read in the format written by writeU32.

       */

      inline uint32_t ReadU32 (void);

      /**

       * \return the eight bytes read in the buffer.

       *

       * Read data and advance the Iterator by the number of bytes

       * read.

       * The data is read in the format written by writeU64.

       */

      inline uint64_t ReadU64 (void);

      /**

       * \return the two bytes read in the buffer.

       *

       * Read data and advance the Iterator by the number of bytes

       * read.

       * The data is read in network format and return in host format.

       */

      inline uint16_t ReadNtohU16 (void);

      /**

       * \return the four bytes read in the buffer.

       *

       * Read data and advance the Iterator by the number of bytes

       * read.

       * The data is read in network format and return in host format.

       */

      inline uint32_t ReadNtohU32 (void);

      /**

       * \return the eight bytes read in the buffer.

       *

       * Read data and advance the Iterator by the number of bytes

       * read.

       * The data is read in network format and return in host format.

       */

      inline uint64_t ReadNtohU64 (void);

      /**

       * \param buffer buffer to copy data into

       * \param size number of bytes to copy

       *

       * Copy size bytes of data from the internal buffer to the

       * input buffer and avance the Iterator by the number of

       * bytes read.

       */

      inline void Read (uint8_t *buffer, uint16_t size);

  private:

      friend class Buffer;

      inline Iterator (Buffer const*buffer, uint32_t m_current);

      inline uint32_t GetIndex (uint32_t n);

      uint32_t m_zeroStart;

      uint32_t m_zeroEnd;

      uint32_t m_dataEnd;

      uint32_t m_current;

      uint8_t *m_data;

  };

  /**

   * \return the number of bytes stored in this buffer.

   */

  inline uint32_t GetSize (void) const;

  /**

   * \return a pointer to the start of the internal 

   * byte buffer.

   *

   * The returned pointer points to an area of

   * memory which is ns3::Buffer::GetSize () bytes big.

   * Please, try to never ever use this method. It is really

   * evil and is present only for a few specific uses.

   */

  uint8_t const*PeekData (void) const;

  /**

   * \param start size to reserve

   *

   * Add bytes at the start of the Buffer. The

   * content of these bytes is undefined but debugging

   * builds initialize them to 0x33.

   * Any call to this method invalidates any Iterator

   * pointing to this Buffer.

   */

  void AddAtStart (uint32_t start);

  /**

   * \param end size to reserve

   *

   * Add bytes at the end of the Buffer. The

   * content of these bytes is undefined but debugging

   * builds initialize them to 0x33.

   * Any call to this method invalidates any Iterator

   * pointing to this Buffer.

   */

  void AddAtEnd (uint32_t end);

  /**

   * \param start size to remove

   *

   * Remove bytes at the start of the Buffer.

   * Any call to this method invalidates any Iterator

   * pointing to this Buffer.

   */

  void RemoveAtStart (uint32_t start);

  /**

   * \param end size to remove

   *

   * Remove bytes at the end of the Buffer.

   * Any call to this method invalidates any Iterator

   * pointing to this Buffer.

   */

  void RemoveAtEnd (uint32_t end);

  /**

   * \param start offset from start of packet

   * \param length

   *

   * \return a fragment of size length starting at offset

   * start.

   */

  Buffer CreateFragment (uint32_t start, uint32_t length) const;

  /**

   * \return an Iterator which points to the

   * start of this Buffer.

   */

  inline Buffer::Iterator Begin (void) const;

  /**

   * \return an Iterator which points to the

   * end of this Buffer.

   */

  inline Buffer::Iterator End (void) const;

  void TransformIntoRealBuffer (void) const;

  inline Buffer (Buffer const &o);

  inline Buffer &operator = (Buffer const &o);

  inline Buffer ();

  inline Buffer (uint32_t dataSize);

  inline ~Buffer ();

private:

  struct BufferData {

      uint32_t m_count;

      uint32_t m_size;

      uint32_t m_initialStart;

      uint32_t m_dirtyStart;

      uint32_t m_dirtySize;

      uint8_t m_data[1];

  };

  typedef std::vector<struct Buffer::BufferData*> BufferDataList;

  inline uint8_t *GetStart (void) const;

  static void Recycle (struct Buffer::BufferData *data);

  static struct Buffer::BufferData *Create (void);

  static struct Buffer::BufferData *Allocate (uint32_t size, uint32_t start);

  static void Deallocate (struct Buffer::BufferData *data);

  static BufferDataList m_freeList;

  static uint32_t m_maxTotalAddStart;

  static uint32_t m_maxTotalAddEnd;

  struct BufferData *m_data;

  uint32_t m_zeroAreaSize;

  uint32_t m_start;

  uint32_t m_size;

};

}; // namespace ns3

/**************************************************

   Start of implementation of methods which 

   need to be inline for performance reasons.

 *************************************************/

#include "ns3/assert.h"

namespace ns3 {

Buffer::Buffer ()

  : m_data (Buffer::Create ()),

    m_zeroAreaSize (0),

    m_start (m_maxTotalAddStart),

    m_size (0)

{

  if (m_start > m_data->m_size) 

    {

      m_start = 0;

    }

  NS_ASSERT (m_start <= m_data->m_size);

}

Buffer::Buffer (uint32_t dataSize)

  : m_data (Buffer::Create ()),

    m_zeroAreaSize (dataSize),

    m_start (m_maxTotalAddStart),

    m_size (0)

{

  if (m_start > m_data->m_size) 

    {

      m_start = 0;

    }

  NS_ASSERT (m_start <= m_data->m_size);

}

Buffer::Buffer (Buffer const&o)

  : m_data (o.m_data),

    m_zeroAreaSize (o.m_zeroAreaSize),

    m_start (o.m_start),

    m_size (o.m_size)

{

  m_data->m_count++;

  NS_ASSERT (m_start <= m_data->m_size);

}

Buffer &

Buffer::operator = (Buffer const&o)

{

  if (m_data != o.m_data) 

    {

      // not assignment to self.

      m_data->m_count--;

      if (m_data->m_count == 0) 

        {

          Recycle (m_data);

        }

      m_data = o.m_data;

      m_data->m_count++;

    }

  m_zeroAreaSize = o.m_zeroAreaSize;

  m_start = o.m_start;

  m_size = o.m_size;

  NS_ASSERT (m_start <= m_data->m_size);

  return *this;

}

Buffer::~Buffer ()

{

  m_data->m_count--;

  if (m_data->m_count == 0) 

    {

      Recycle (m_data);

    }

}

uint8_t *

Buffer::GetStart (void) const

{

  return m_data->m_data + m_start;

}

uint32_t 

Buffer::GetSize (void) const

{

  return m_size + m_zeroAreaSize;

}

Buffer::Iterator 

Buffer::Begin (void) const

{

  return Buffer::Iterator (this, 0);

}

Buffer::Iterator 

Buffer::End (void) const

{

  return Buffer::Iterator (this, GetSize ());

}

Buffer::Iterator::Iterator ()

  : m_zeroStart (0),

    m_zeroEnd (0),

    m_dataEnd (0),

    m_current (0),

    m_data (0)

{}

Buffer::Iterator::Iterator (Buffer const*buffer, uint32_t current)

  : m_zeroStart (buffer->m_data->m_initialStart-buffer->m_start),

    m_zeroEnd (m_zeroStart+buffer->m_zeroAreaSize),

    m_dataEnd (buffer->GetSize ()),

    m_current (current),

    m_data (buffer->m_data->m_data+buffer->m_start)

{}

void 

Buffer::Iterator::Next (void)

{

  NS_ASSERT (m_current + 1 <= m_dataEnd);

  m_current++;

}

void 

Buffer::Iterator::Prev (void)

{

  NS_ASSERT (m_current >= 1);

  m_current--;

}

void 

Buffer::Iterator::Next (uint32_t delta)

{

  NS_ASSERT (m_current + delta <= m_dataEnd);

  m_current += delta;

}

void 

Buffer::Iterator::Prev (uint32_t delta)

{