src/common/packet-metadata.cc
author Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
Sat, 04 Aug 2007 13:22:08 +0200
changeset 1141 a75fc1741700
parent 1134 5f5d33e01eb9
child 1143 7da9f7103447
permissions -rw-r--r--
rework the PacketPrinter API and implementation
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
     1
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
     2
/*
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
     3
 * Copyright (c) 2006,2007 INRIA
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
     4
 *
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
     5
 * This program is free software; you can redistribute it and/or modify
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
     6
 * it under the terms of the GNU General Public License version 2 as
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
     7
 * published by the Free Software Foundation;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
     8
 *
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
     9
 * This program is distributed in the hope that it will be useful,
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    12
 * GNU General Public License for more details.
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    13
 *
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    14
 * You should have received a copy of the GNU General Public License
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    15
 * along with this program; if not, write to the Free Software
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    16
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    17
 *
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    18
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    19
 */
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    20
#include <utility>
792
99423210502e implement ItemList construction
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 791
diff changeset
    21
#include <list>
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    22
#include "ns3/assert.h"
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    23
#include "ns3/fatal-error.h"
833
224bfad58818 a bunch of optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 830
diff changeset
    24
#include "ns3/debug.h"
882
777fcfabc1c8 rename packet-history.h to packet-metadata.h
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 876
diff changeset
    25
#include "packet-metadata.h"
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    26
#include "chunk.h"
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    27
#include "buffer.h"
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    28
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    29
NS_DEBUG_COMPONENT_DEFINE ("PacketMetadata");
833
224bfad58818 a bunch of optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 830
diff changeset
    30
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    31
namespace ns3 {
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    32
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    33
bool PacketMetadata::m_enable = false;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    34
uint32_t PacketMetadata::m_maxSize = 0;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    35
uint16_t PacketMetadata::m_chunkUid = 0;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    36
PacketMetadata::DataFreeList PacketMetadata::m_freeList;
876
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
    37
bool g_optOne = false;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    38
957
426b85bab45f fix bug 57
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 907
diff changeset
    39
PacketMetadata::DataFreeList::~DataFreeList ()
426b85bab45f fix bug 57
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 907
diff changeset
    40
{
426b85bab45f fix bug 57
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 907
diff changeset
    41
  for (iterator i = begin (); i != end (); i++)
426b85bab45f fix bug 57
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 907
diff changeset
    42
    {
426b85bab45f fix bug 57
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 907
diff changeset
    43
      PacketMetadata::Deallocate (*i);
426b85bab45f fix bug 57
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 907
diff changeset
    44
    }
426b85bab45f fix bug 57
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 907
diff changeset
    45
}
426b85bab45f fix bug 57
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 907
diff changeset
    46
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    47
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    48
PacketMetadata::Enable (void)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    49
{
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    50
  m_enable = true;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    51
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    52
876
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
    53
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    54
PacketMetadata::SetOptOne (bool optOne)
876
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
    55
{
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
    56
  g_optOne = optOne;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
    57
}
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
    58
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    59
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    60
PacketMetadata::ReserveCopy (uint32_t size)
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    61
{
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    62
  struct PacketMetadata::Data *newData = PacketMetadata::Create (m_used + size);
836
f9f5f66013cc fix addition of a trailer or a header
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 835
diff changeset
    63
  memcpy (newData->m_data, m_data->m_data, m_used);
f9f5f66013cc fix addition of a trailer or a header
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 835
diff changeset
    64
  newData->m_dirtyEnd = m_used;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    65
  m_data->m_count--;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    66
  if (m_data->m_count == 0) 
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    67
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    68
      PacketMetadata::Recycle (m_data);
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    69
    }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    70
  m_data = newData;
844
d17e2aca5a17 when doing a copy of a buffer, make sure to clear the prev and next fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 843
diff changeset
    71
  if (m_head != 0xffff)
d17e2aca5a17 when doing a copy of a buffer, make sure to clear the prev and next fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 843
diff changeset
    72
    {
d17e2aca5a17 when doing a copy of a buffer, make sure to clear the prev and next fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 843
diff changeset
    73
      uint8_t *start;
d17e2aca5a17 when doing a copy of a buffer, make sure to clear the prev and next fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 843
diff changeset
    74
      NS_ASSERT (m_tail != 0xffff);
d17e2aca5a17 when doing a copy of a buffer, make sure to clear the prev and next fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 843
diff changeset
    75
      // clear the next field of the tail
d17e2aca5a17 when doing a copy of a buffer, make sure to clear the prev and next fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 843
diff changeset
    76
      start = &m_data->m_data[m_tail];
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
    77
      Append16 (0xffff, start);
844
d17e2aca5a17 when doing a copy of a buffer, make sure to clear the prev and next fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 843
diff changeset
    78
      // clear the prev field of the head
d17e2aca5a17 when doing a copy of a buffer, make sure to clear the prev and next fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 843
diff changeset
    79
      start = &m_data->m_data[m_head] + 2;
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
    80
      Append16 (0xffff, start);
844
d17e2aca5a17 when doing a copy of a buffer, make sure to clear the prev and next fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 843
diff changeset
    81
    }
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    82
}
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    83
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    84
PacketMetadata::Reserve (uint32_t size)
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    85
{
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    86
  NS_ASSERT (m_data != 0);
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    87
  if (m_data->m_size >= m_used + size &&
870
e335d37541c3 try alternative implementation of AddSmall
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 869
diff changeset
    88
      (m_head == 0xffff ||
e335d37541c3 try alternative implementation of AddSmall
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 869
diff changeset
    89
       m_data->m_count == 1 ||
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    90
       m_data->m_dirtyEnd == m_used))
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    91
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    92
      /* enough room, not dirty. */
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    93
    }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    94
  else 
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    95
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    96
      /* (enough room and dirty) or (not enough room) */
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    97
      ReserveCopy (size);
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    98
    }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    99
}
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   100
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   101
uint32_t 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   102
PacketMetadata::GetUleb128Size (uint32_t value) const
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   103
{
869
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   104
  if (value < 0x80)
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   105
    {
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   106
      return 1;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   107
    }
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   108
  if (value < 0x4000)
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   109
    {
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   110
      return 2;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   111
    }
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   112
  if (value < 0x200000)
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   113
    {
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   114
      return 3;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   115
    }
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   116
  if (value < 0x10000000)
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   117
    {
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   118
      return 4;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   119
    }
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   120
  return 5;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   121
}
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   122
uint32_t
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   123
PacketMetadata::ReadUleb128 (const uint8_t **pBuffer) const
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   124
{
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   125
  const uint8_t *buffer = *pBuffer;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   126
  uint32_t result = 0;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   127
  uint8_t byte;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   128
  result = 0;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   129
  byte = buffer[0];
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   130
  result = (byte & (~0x80));
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   131
  if (!(byte & 0x80))
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   132
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   133
      *pBuffer = buffer + 1;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   134
      return result;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   135
    }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   136
  byte = buffer[1];
884
f3836277079e fix uleb128 reading bug
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 883
diff changeset
   137
  result |= (byte & (~0x80)) << 7;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   138
  if (!(byte & 0x80))
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   139
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   140
      *pBuffer = buffer + 2;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   141
      return result;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   142
    }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   143
  byte = buffer[2];
884
f3836277079e fix uleb128 reading bug
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 883
diff changeset
   144
  result |= (byte & (~0x80)) << 14;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   145
  if (!(byte & 0x80))
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   146
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   147
      *pBuffer = buffer + 3;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   148
      return result;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   149
    }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   150
  byte = buffer[3];
884
f3836277079e fix uleb128 reading bug
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 883
diff changeset
   151
  result |= (byte & (~0x80)) << 21;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   152
  if (!(byte & 0x80))
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   153
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   154
      *pBuffer = buffer + 4;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   155
      return result;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   156
    }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   157
  byte = buffer[4];
884
f3836277079e fix uleb128 reading bug
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 883
diff changeset
   158
  result |= (byte & (~0x80)) << 28;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   159
  if (!(byte & 0x80))
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   160
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   161
      *pBuffer = buffer + 5;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   162
      return result;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   163
    }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   164
  /* This means that the LEB128 number was not valid.
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   165
   * ie: the last (5th) byte did not have the high-order bit zeroed.
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   166
   */
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   167
  NS_ASSERT (false);
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   168
  return 0;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   169
}
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   170
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   171
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   172
PacketMetadata::Append16 (uint16_t value, uint8_t *buffer)
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   173
{
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   174
  buffer[0] = value & 0xff;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   175
  value >>= 8;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   176
  buffer[1] = value;
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   177
}
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   178
bool
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   179
PacketMetadata::TryToAppendFast (uint32_t value, uint8_t **pBuffer, uint8_t *end)
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   180
{
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   181
  uint8_t *start = *pBuffer;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   182
  if (value < 0x80 && start < end)
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   183
    {
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   184
      start[0] = value;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   185
      *pBuffer = start + 1;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   186
      return true;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   187
    }
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   188
  if (value < 0x4000 && start + 1 < end)
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   189
    {
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   190
      uint8_t byte = value & (~0x80);
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   191
      start[0] = 0x80 | byte;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   192
      value >>= 7;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   193
      start[1] = value;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   194
      *pBuffer = start + 2;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   195
      return true;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   196
    }
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   197
  return false;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   198
}
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   199
bool
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   200
PacketMetadata::TryToAppend16 (uint16_t value,  uint8_t **pBuffer, uint8_t *end)
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   201
{
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   202
  uint8_t *start = *pBuffer;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   203
  if (start + 1 < end)
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   204
    {
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   205
      start[0] = value & 0xff;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   206
      start[1] = value >> 8;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   207
      *pBuffer = start + 2;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   208
      return true;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   209
    }
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   210
  return false;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   211
}
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   212
bool
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   213
PacketMetadata::TryToAppend32 (uint32_t value,  uint8_t **pBuffer, uint8_t *end)
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   214
{
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   215
  uint8_t *start = *pBuffer;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   216
  if (start + 3 < end)
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   217
    {
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   218
      start[0] = value & 0xff;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   219
      start[1] = (value >> 8) & 0xff;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   220
      start[2] = (value >> 16) & 0xff;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   221
      start[3] = (value >> 24) & 0xff;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   222
      *pBuffer = start + 4;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   223
      return true;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   224
    }
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   225
  return false;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   226
}
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   227
bool
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   228
PacketMetadata::TryToAppend (uint32_t value, uint8_t **pBuffer, uint8_t *end)
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   229
{
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   230
  uint8_t *start = *pBuffer;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   231
  if (value < 0x80 && start < end)
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   232
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   233
      start[0] = value;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   234
      *pBuffer = start + 1;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   235
      return true;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   236
    }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   237
  if (value < 0x4000 && start + 1 < end)
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   238
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   239
      uint8_t byte = value & (~0x80);
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   240
      start[0] = 0x80 | byte;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   241
      value >>= 7;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   242
      start[1] = value;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   243
      *pBuffer = start + 2;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   244
      return true;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   245
    }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   246
  if (value < 0x200000 && start + 2 < end)
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   247
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   248
      uint8_t byte = value & (~0x80);
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   249
      start[0] = 0x80 | byte;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   250
      value >>= 7;
869
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   251
      byte = value & (~0x80);
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   252
      start[1] = 0x80 | byte;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   253
      value >>= 7;
869
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   254
      byte = value & (~0x80);
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   255
      start[2] = value;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   256
      *pBuffer = start + 3;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   257
      return true;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   258
    }
869
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   259
  if (value < 0x10000000 && start + 3 < end)
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   260
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   261
      uint8_t byte = value & (~0x80);
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   262
      start[0] = 0x80 | byte;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   263
      value >>= 7;
869
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   264
      byte = value & (~0x80);
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   265
      start[1] = 0x80 | byte;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   266
      value >>= 7;
869
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   267
      byte = value & (~0x80);
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   268
      start[2] = 0x80 | byte;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   269
      value >>= 7;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   270
      start[3] = value;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   271
      *pBuffer = start + 4;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   272
      return true;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   273
    }
869
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   274
  if (start + 4 < end)
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   275
    {
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   276
      uint8_t byte = value & (~0x80);
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   277
      start[0] = 0x80 | byte;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   278
      value >>= 7;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   279
      byte = value & (~0x80);
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   280
      start[1] = 0x80 | byte;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   281
      value >>= 7;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   282
      byte = value & (~0x80);
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   283
      start[2] = 0x80 | byte;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   284
      value >>= 7;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   285
      byte = value & (~0x80);
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   286
      start[3] = 0x80 | byte;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   287
      value >>= 7;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   288
      start[4] = value;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   289
      *pBuffer = start + 5;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   290
      return true;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   291
    }
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   292
  return false;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   293
}
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   294
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   295
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   296
PacketMetadata::AppendValueExtra (uint32_t value, uint8_t *buffer)
876
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   297
{
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   298
  if (value < 0x200000)
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   299
    {
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   300
      uint8_t byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   301
      buffer[0] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   302
      value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   303
      byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   304
      buffer[1] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   305
      value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   306
      byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   307
      buffer[2] = value;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   308
      return;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   309
    }
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   310
  if (value < 0x10000000)
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   311
    {
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   312
      uint8_t byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   313
      buffer[0] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   314
      value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   315
      byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   316
      buffer[1] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   317
      value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   318
      byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   319
      buffer[2] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   320
      value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   321
      buffer[3] = value;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   322
      return;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   323
    }
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   324
  {
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   325
    uint8_t byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   326
    buffer[0] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   327
    value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   328
    byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   329
    buffer[1] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   330
    value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   331
    byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   332
    buffer[2] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   333
    value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   334
    byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   335
    buffer[3] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   336
    value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   337
    buffer[4] = value;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   338
  }
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   339
}
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   340
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   341
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   342
PacketMetadata::AppendValue (uint32_t value, uint8_t *buffer)
876
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   343
{
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   344
  if (value < 0x80)
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   345
    {
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   346
      buffer[0] = value;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   347
      return;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   348
    }
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   349
  if (value < 0x4000)
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   350
    {
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   351
      uint8_t byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   352
      buffer[0] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   353
      value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   354
      buffer[1] = value;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   355
      return;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   356
    }
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   357
  AppendValueExtra (value, buffer);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   358
}
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   359
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   360
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   361
PacketMetadata::UpdateTail (uint16_t written)
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   362
{
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   363
  if (m_head == 0xffff)
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   364
    {
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   365
      NS_ASSERT (m_tail == 0xffff);
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   366
      m_head = m_used;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   367
      m_tail = m_used;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   368
    } 
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   369
  else
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   370
    {
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   371
      NS_ASSERT (m_tail != 0xffff);
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   372
      // overwrite the next field of the previous tail of the list.
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   373
      uint8_t *previousTail = &m_data->m_data[m_tail];
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   374
      Append16 (m_used, previousTail);
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   375
      // update the tail of the list to the new node.
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   376
      m_tail = m_used;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   377
    }
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   378
  NS_ASSERT (m_tail != 0xffff);
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   379
  NS_ASSERT (m_head != 0xffff);
906
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   380
  NS_ASSERT (written >= 8);
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   381
  m_used += written;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   382
  m_data->m_dirtyEnd = m_used;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   383
}
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   384
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   385
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   386
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   387
PacketMetadata::UpdateHead (uint16_t written)
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   388
{
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   389
  if (m_head == 0xffff)
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   390
    {
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   391
      NS_ASSERT (m_tail == 0xffff);
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   392
      m_head = m_used;
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   393
      m_tail = m_used;
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   394
    } 
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   395
  else
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   396
    {
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   397
      NS_ASSERT (m_head != 0xffff);
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   398
      // overwrite the prev field of the previous head of the list.
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   399
      uint8_t *previousHead = &m_data->m_data[m_head + 2];
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   400
      Append16 (m_used, previousHead);
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   401
      // update the head of list to the new node.
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   402
      m_head = m_used;
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   403
    }
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   404
  NS_ASSERT (m_tail != 0xffff);
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   405
  NS_ASSERT (m_head != 0xffff);
906
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   406
  NS_ASSERT (written >= 8);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   407
  m_used += written;
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   408
  m_data->m_dirtyEnd = m_used;
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   409
}
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   410
859
aa89ae478c3a remove Update call from within AddSmall and AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 858
diff changeset
   411
uint16_t
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   412
PacketMetadata::AddSmall (const struct PacketMetadata::SmallItem *item)
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   413
{
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   414
  NS_ASSERT (m_data != 0);
905
a18fd9def067 fix basic tests, add new test, add a bunch of asserts, add XXX comment
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 904
diff changeset
   415
  NS_ASSERT (m_used != item->prev && m_used != item->next);
876
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   416
  if (g_optOne)
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   417
    {
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   418
      uint32_t typeUidSize = GetUleb128Size (item->typeUid);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   419
      uint32_t sizeSize = GetUleb128Size (item->size);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   420
      uint32_t n = typeUidSize + sizeSize + 2 + 2 + 2;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   421
    restart:
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   422
      if (m_used + n <= m_data->m_size &&
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   423
      (m_head == 0xffff ||
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   424
       m_data->m_count == 1 ||
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   425
       m_used == m_data->m_dirtyEnd))
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   426
        {
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   427
          uint8_t *buffer = &m_data->m_data[m_used];
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   428
          Append16 (item->next, buffer);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   429
          buffer += 2;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   430
          Append16 (item->prev, buffer);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   431
          buffer += 2;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   432
          AppendValue (item->typeUid, buffer);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   433
          buffer += typeUidSize;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   434
          AppendValue (item->size, buffer);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   435
          buffer += sizeSize;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   436
          Append16 (item->chunkUid, buffer);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   437
        }
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   438
      else
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   439
        {
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   440
          ReserveCopy (n);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   441
          goto restart;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   442
        }
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   443
      return n;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   444
    }
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   445
 append:
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   446
  uint8_t *start = &m_data->m_data[m_used];
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   447
  uint8_t *end = &m_data->m_data[m_data->m_size];
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   448
  if (end - start >= 8 &&
858
280636166143 remove useless CanAdd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 857
diff changeset
   449
      (m_head == 0xffff ||
280636166143 remove useless CanAdd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 857
diff changeset
   450
       m_data->m_count == 1 ||
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   451
       m_used == m_data->m_dirtyEnd))
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   452
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   453
      uint8_t *buffer = start;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   454
862
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   455
      Append16 (item->next, buffer);
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   456
      buffer += 2;
862
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   457
      Append16 (item->prev, buffer);
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   458
      buffer += 2;
862
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   459
      if (TryToAppendFast (item->typeUid, &buffer, end) &&
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   460
          TryToAppendFast (item->size, &buffer, end) &&
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   461
          TryToAppend16 (item->chunkUid, &buffer, end))
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   462
        {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   463
          uintptr_t written = buffer - start;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   464
          NS_ASSERT (written <= 0xffff);
905
a18fd9def067 fix basic tests, add new test, add a bunch of asserts, add XXX comment
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 904
diff changeset
   465
          NS_ASSERT (written >= 8);
859
aa89ae478c3a remove Update call from within AddSmall and AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 858
diff changeset
   466
          return written;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   467
        }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   468
    }
862
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   469
  uint32_t n = GetUleb128Size (item->typeUid);
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   470
  n += GetUleb128Size (item->size);
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   471
  n += 2;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   472
  n += 2 + 2;
870
e335d37541c3 try alternative implementation of AddSmall
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 869
diff changeset
   473
  Reserve (n);
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   474
  goto append;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   475
}
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   476
859
aa89ae478c3a remove Update call from within AddSmall and AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 858
diff changeset
   477
uint16_t
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   478
PacketMetadata::AddBig (uint32_t next, uint32_t prev, 
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   479
                       const PacketMetadata::SmallItem *item, 
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   480
                       const PacketMetadata::ExtraItem *extraItem)
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   481
{
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   482
  NS_ASSERT (m_data != 0);
852
a1a3c9bdb7f4 fix a few bugs in ::RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 851
diff changeset
   483
  uint32_t typeUid = ((item->typeUid & 0x1) == 0x1)?item->typeUid:item->typeUid+1;
905
a18fd9def067 fix basic tests, add new test, add a bunch of asserts, add XXX comment
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 904
diff changeset
   484
  NS_ASSERT (m_used != prev && m_used != next);
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   485
 append:
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   486
  uint8_t *start = &m_data->m_data[m_used];
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   487
  uint8_t *end = &m_data->m_data[m_data->m_size];
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   488
  if (end - start >= 14 &&
858
280636166143 remove useless CanAdd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 857
diff changeset
   489
      (m_head == 0xffff ||
280636166143 remove useless CanAdd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 857
diff changeset
   490
       m_data->m_count == 1 ||
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   491
       m_used == m_data->m_dirtyEnd))
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   492
    {
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   493
      uint8_t *buffer = start;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   494
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   495
      Append16 (next, buffer);
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   496
      buffer += 2;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   497
      Append16 (prev, buffer);
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   498
      buffer += 2;
852
a1a3c9bdb7f4 fix a few bugs in ::RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 851
diff changeset
   499
      if (TryToAppend (typeUid, &buffer, end) &&
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   500
          TryToAppend (item->size, &buffer, end) &&
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   501
          TryToAppend16 (item->chunkUid, &buffer, end) &&
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   502
          TryToAppend (extraItem->fragmentStart, &buffer, end) &&
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   503
          TryToAppend (extraItem->fragmentEnd, &buffer, end) &&
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   504
          TryToAppend32 (extraItem->packetUid, &buffer, end))
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   505
        {
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   506
          uintptr_t written = buffer - start;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   507
          NS_ASSERT (written <= 0xffff);
905
a18fd9def067 fix basic tests, add new test, add a bunch of asserts, add XXX comment
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 904
diff changeset
   508
          NS_ASSERT (written >= 14);
859
aa89ae478c3a remove Update call from within AddSmall and AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 858
diff changeset
   509
          return written;
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   510
        }
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   511
    }
860
3095d7275585 add counters
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 859
diff changeset
   512
852
a1a3c9bdb7f4 fix a few bugs in ::RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 851
diff changeset
   513
  uint32_t n = GetUleb128Size (typeUid);
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   514
  n += GetUleb128Size (item->size);
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   515
  n += 2;
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   516
  n += GetUleb128Size (extraItem->fragmentStart);
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   517
  n += GetUleb128Size (extraItem->fragmentEnd);
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   518
  n += 4;
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   519
  n += 2 + 2;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   520
  ReserveCopy (n);
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   521
  goto append;
854
cbe6790bf9fa simplify calls to AddBig and AddSmall
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 853
diff changeset
   522
}
cbe6790bf9fa simplify calls to AddBig and AddSmall
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 853
diff changeset
   523
cbe6790bf9fa simplify calls to AddBig and AddSmall
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 853
diff changeset
   524
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   525
PacketMetadata::ReplaceTail (PacketMetadata::SmallItem *item, 
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   526
                            PacketMetadata::ExtraItem *extraItem,
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   527
                            uint32_t available)
854
cbe6790bf9fa simplify calls to AddBig and AddSmall
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 853
diff changeset
   528
{
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   529
  NS_ASSERT (m_data != 0);  
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   530
  if (available >= 14 &&
856
007981962639 make all tests pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 855
diff changeset
   531
      m_data->m_count == 1)
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   532
    {
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   533
      uint8_t *buffer = &m_data->m_data[m_tail];
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   534
      uint8_t *end = buffer + available;
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   535
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   536
      Append16 (item->next, buffer);
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   537
      buffer += 2;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   538
      Append16 (item->prev, buffer);
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   539
      buffer += 2;
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   540
      if (TryToAppend (item->typeUid, &buffer, end) &&
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   541
          TryToAppend (item->size, &buffer, end) &&
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   542
          TryToAppend16 (item->chunkUid, &buffer, end) &&
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   543
          TryToAppend (extraItem->fragmentStart, &buffer, end) &&
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   544
          TryToAppend (extraItem->fragmentEnd, &buffer, end) &&
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   545
          TryToAppend32 (extraItem->packetUid, &buffer, end))
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   546
        {
856
007981962639 make all tests pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 855
diff changeset
   547
          m_used = buffer - &m_data->m_data[0];
007981962639 make all tests pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 855
diff changeset
   548
          m_data->m_dirtyEnd = m_used;
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   549
          return;
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   550
        }
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   551
    }
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   552
  
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   553
  // create a copy of the packet.
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   554
  PacketMetadata h (m_packetUid, 0);
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   555
  uint16_t current = m_head;
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   556
  while (current != 0xffff && current != m_tail)
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   557
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   558
      struct PacketMetadata::SmallItem tmpItem;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   559
      PacketMetadata::ExtraItem tmpExtraItem;
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   560
      ReadItems (current, &tmpItem, &tmpExtraItem);
867
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   561
      uint16_t written = h.AddBig (0xffff, h.m_tail, 
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   562
                                   &tmpItem, &tmpExtraItem);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   563
      h.UpdateTail (written);
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   564
    }
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   565
  // append new tail.
867
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   566
  uint16_t written = h.AddBig (0xffff, h.m_tail, item, extraItem);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   567
  h.UpdateTail (written);
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   568
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   569
  *this = h;
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   570
}
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   571
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   572
uint32_t
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   573
PacketMetadata::ReadItems (uint16_t current, 
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   574
                          struct PacketMetadata::SmallItem *item,
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   575
                          struct PacketMetadata::ExtraItem *extraItem) const
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   576
{
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   577
  const uint8_t *buffer = &m_data->m_data[current];
865
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   578
  item->next = buffer[0];
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   579
  item->next |= (buffer[1]) << 8;
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   580
  item->prev = buffer[2];
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   581
  item->prev |= (buffer[3]) << 8;
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   582
  buffer += 4;
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   583
  item->typeUid = ReadUleb128 (&buffer);
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   584
  item->size = ReadUleb128 (&buffer);
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   585
  item->chunkUid = buffer[0];
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   586
  item->chunkUid |= (buffer[1]) << 8;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   587
  buffer += 2;
865
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   588
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   589
  bool isExtra = (item->typeUid & 0x1) == 0x1;
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   590
  if (isExtra)
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   591
    {
865
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   592
      extraItem->fragmentStart = ReadUleb128 (&buffer);
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   593
      extraItem->fragmentEnd = ReadUleb128 (&buffer);
873
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   594
      extraItem->packetUid = buffer[0];
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   595
      extraItem->packetUid |= buffer[1] << 8;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   596
      extraItem->packetUid |= buffer[2] << 16;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   597
      extraItem->packetUid |= buffer[3] << 24;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   598
      buffer += 4;
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   599
    }
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   600
  else
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   601
    {
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   602
      extraItem->fragmentStart = 0;
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   603
      extraItem->fragmentEnd = item->size;
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   604
      extraItem->packetUid = m_packetUid;
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   605
    }
848
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
   606
  NS_ASSERT (buffer <= &m_data->m_data[m_data->m_size]);
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   607
  return buffer - &m_data->m_data[current];
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   608
}
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   609
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   610
struct PacketMetadata::Data *
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   611
PacketMetadata::Create (uint32_t size)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   612
{
833
224bfad58818 a bunch of optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 830
diff changeset
   613
  NS_DEBUG ("create size="<<size<<", max="<<m_maxSize);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   614
  if (size > m_maxSize)
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   615
    {
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   616
      m_maxSize = size;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   617
    }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   618
  while (!m_freeList.empty ()) 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   619
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   620
      struct PacketMetadata::Data *data = m_freeList.back ();
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   621
      m_freeList.pop_back ();
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   622
      if (data->m_size >= size) 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   623
        {
833
224bfad58818 a bunch of optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 830
diff changeset
   624
          NS_DEBUG ("create found size="<<data->m_size);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   625
          data->m_count = 1;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   626
          return data;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   627
        }
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   628
      PacketMetadata::Deallocate (data);
833
224bfad58818 a bunch of optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 830
diff changeset
   629
      NS_DEBUG ("create dealloc size="<<data->m_size);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   630
    }
833
224bfad58818 a bunch of optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 830
diff changeset
   631
  NS_DEBUG ("create alloc size="<<m_maxSize);
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   632
  return PacketMetadata::Allocate (m_maxSize);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   633
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   634
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   635
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   636
PacketMetadata::Recycle (struct PacketMetadata::Data *data)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   637
{
833
224bfad58818 a bunch of optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 830
diff changeset
   638
  NS_DEBUG ("recycle size="<<data->m_size<<", list="<<m_freeList.size ());
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   639
  NS_ASSERT (data->m_count == 0);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   640
  if (m_freeList.size () > 1000 ||
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   641
      data->m_size < m_maxSize) 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   642
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   643
      PacketMetadata::Deallocate (data);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   644
    } 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   645
  else 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   646
    {
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   647
      m_freeList.push_back (data);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   648
    }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   649
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   650
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   651
struct PacketMetadata::Data *
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   652
PacketMetadata::Allocate (uint32_t n)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   653
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   654
  uint32_t size = sizeof (struct Data);
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   655
  if (n <= 10)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   656
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   657
      n = 10;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   658
    }
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   659
  size += n - 10;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   660
  uint8_t *buf = new uint8_t [size];
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   661
  struct PacketMetadata::Data *data = (struct PacketMetadata::Data *)buf;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   662
  data->m_size = n;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   663
  data->m_count = 1;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   664
  data->m_dirtyEnd = 0;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   665
  return data;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   666
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   667
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   668
PacketMetadata::Deallocate (struct PacketMetadata::Data *data)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   669
{
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   670
  uint8_t *buf = (uint8_t *)data;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   671
  delete [] buf;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   672
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   673
791
ff528910ba40 prepare for forward iteration of history.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 790
diff changeset
   674
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   675
PacketMetadata 
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   676
PacketMetadata::CreateFragment (uint32_t start, uint32_t end) const
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   677
{
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   678
  PacketMetadata fragment = *this;
790
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
   679
  fragment.RemoveAtStart (start);
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
   680
  fragment.RemoveAtEnd (end);
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
   681
  return fragment;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   682
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   683
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   684
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   685
PacketMetadata::DoAddHeader (uint32_t uid, uint32_t size)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   686
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   687
  if (!m_enable)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   688
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   689
      return;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   690
    }
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   691
  struct PacketMetadata::SmallItem item;
862
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   692
  item.next = m_head;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   693
  item.prev = 0xffff;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   694
  item.typeUid = uid;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   695
  item.size = size;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   696
  item.chunkUid = m_chunkUid;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   697
  m_chunkUid++;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   698
  uint16_t written = AddSmall (&item);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   699
  UpdateHead (written);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   700
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   701
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   702
PacketMetadata::DoRemoveHeader (uint32_t uid, uint32_t size)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   703
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   704
  if (!m_enable) 
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   705
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   706
      return;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   707
    }
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   708
  struct PacketMetadata::SmallItem item;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   709
  struct PacketMetadata::ExtraItem extraItem;
906
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   710
  uint32_t read = ReadItems (m_head, &item, &extraItem);
843
b6670a38f2e8 the mask to filter out the low bit is 0xfe, not 0xfd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 842
diff changeset
   711
  if ((item.typeUid & 0xfffffffe) != uid ||
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   712
      item.size != size)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   713
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   714
      NS_FATAL_ERROR ("Removing unexpected header.");
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   715
    }
866
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   716
  else if (item.typeUid != uid &&
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   717
           (extraItem.fragmentStart != 0 ||
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   718
            extraItem.fragmentEnd != size))
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   719
    {
866
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   720
      NS_FATAL_ERROR ("Removing incomplete header.");
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   721
    }
906
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   722
  if (m_head + read == m_used)
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   723
    {
840
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
   724
      m_used = m_head;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   725
    }
906
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   726
  if (item.next == 0xffff)
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   727
    {
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   728
      m_head = 0xffff;
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   729
      m_tail = 0xffff;
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   730
    }
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   731
  else
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   732
    {
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   733
      m_head = item.next;
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   734
    }
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   735
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   736
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   737
PacketMetadata::DoAddTrailer (uint32_t uid, uint32_t size)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   738
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   739
  if (!m_enable)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   740
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   741
      return;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   742
    }
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   743
  struct PacketMetadata::SmallItem item;
862
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   744
  item.next = 0xffff;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   745
  item.prev = m_tail;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   746
  item.typeUid = uid;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   747
  item.size = size;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   748
  item.chunkUid = m_chunkUid;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   749
  m_chunkUid++;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   750
  uint16_t written = AddSmall (&item);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   751
  UpdateTail (written);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   752
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   753
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   754
PacketMetadata::DoRemoveTrailer (uint32_t uid, uint32_t size)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   755
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   756
  if (!m_enable) 
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   757
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   758
      return;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   759
    }
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   760
  struct PacketMetadata::SmallItem item;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   761
  struct PacketMetadata::ExtraItem extraItem;
906
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   762
  uint32_t read = ReadItems (m_tail, &item, &extraItem);
843
b6670a38f2e8 the mask to filter out the low bit is 0xfe, not 0xfd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 842
diff changeset
   763
  if ((item.typeUid & 0xfffffffe) != uid ||
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   764
      item.size != size)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   765
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   766
      NS_FATAL_ERROR ("Removing unexpected trailer.");
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   767
    }
866
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   768
  else if (item.typeUid != uid &&
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   769
           (extraItem.fragmentStart != 0 ||
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   770
            extraItem.fragmentEnd != size))
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   771
    {
866
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   772
      NS_FATAL_ERROR ("Removing incomplete trailer.");
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   773
    }
906
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   774
  if (m_tail + read == m_used)
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   775
    {
840
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
   776
      m_used = m_tail;
906
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   777
    }  
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   778
  if (item.prev == 0xffff)
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   779
    {
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   780
      m_head = 0xffff;
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   781
      m_tail = 0xffff;
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   782
    }
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   783
  else
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   784
    {
459b7a591892 more asserts, add failing tests, fix them
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 905
diff changeset
   785
      m_tail = item.prev;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   786
    }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   787
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   788
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   789
PacketMetadata::AddAtEnd (PacketMetadata const&o)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   790
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   791
  if (!m_enable) 
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   792
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   793
      return;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   794
    }
872
cd19d2692521 unconditionally set m_data
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 870
diff changeset
   795
  if (m_tail == 0xffff)
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   796
    {
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   797
      *this = o;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   798
      return;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   799
    }
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   800
  NS_ASSERT (m_head != 0xffff && m_tail != 0xffff);
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   801
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   802
  uint16_t lastTail;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   803
  lastTail = m_tail;
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   804
  struct PacketMetadata::SmallItem lastItem;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   805
  PacketMetadata::ExtraItem lastExtraItem;
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   806
  uint32_t lastTailSize = ReadItems (m_tail, &lastItem, &lastExtraItem);
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   807
  if (m_tail + lastTailSize == m_used &&
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   808
      m_used == m_data->m_dirtyEnd)
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   809
    {
856
007981962639 make all tests pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 855
diff changeset
   810
      lastTailSize = m_data->m_size - m_tail;
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   811
    }
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   812
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   813
  uint16_t current = o.m_head;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   814
  while (current != 0xffff)
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   815
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   816
      struct PacketMetadata::SmallItem item;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   817
      PacketMetadata::ExtraItem extraItem;
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   818
      o.ReadItems (current, &item, &extraItem);
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   819
      if (extraItem.packetUid == lastExtraItem.packetUid &&
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   820
          item.typeUid == lastItem.typeUid &&
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   821
          item.chunkUid == lastItem.chunkUid &&
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   822
          item.size == lastItem.size &&
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   823
          extraItem.fragmentStart == lastExtraItem.fragmentEnd)
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   824
        {
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   825
          // replace previous tail.
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   826
          lastExtraItem.fragmentEnd = extraItem.fragmentEnd;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   827
          NS_ASSERT (m_tail == lastTail);
905
a18fd9def067 fix basic tests, add new test, add a bunch of asserts, add XXX comment
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 904
diff changeset
   828
          // XXX This call might be wrong. 
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   829
          ReplaceTail (&lastItem, &lastExtraItem, lastTailSize);
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   830
        }
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   831
      else
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   832
        {
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   833
          // append the extra items.
867
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   834
          uint16_t written = AddBig (0xffff, m_tail, &item, &extraItem);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   835
          UpdateTail (written);
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   836
        }
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   837
      if (current == o.m_tail)
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   838
        {
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   839
          break;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   840
        }
856
007981962639 make all tests pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 855
diff changeset
   841
      current = item.next;
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   842
    }
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   843
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   844
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   845
PacketMetadata::AddPaddingAtEnd (uint32_t end)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   846
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   847
  if (!m_enable)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   848
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   849
      return;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   850
    }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   851
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   852
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   853
PacketMetadata::RemoveAtStart (uint32_t start)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   854
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   855
  if (!m_enable) 
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   856
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   857
      return;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   858
    }
872
cd19d2692521 unconditionally set m_data
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 870
diff changeset
   859
  NS_ASSERT (m_data != 0);
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   860
  uint32_t leftToRemove = start;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   861
  uint16_t current = m_head;
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   862
  while (current != 0xffff && leftToRemove > 0)
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   863
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   864
      struct PacketMetadata::SmallItem item;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   865
      PacketMetadata::ExtraItem extraItem;
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   866
      ReadItems (current, &item, &extraItem);
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   867
      uint32_t itemRealSize = extraItem.fragmentEnd - extraItem.fragmentStart;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   868
      if (itemRealSize <= leftToRemove)
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   869
        {
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   870
          // remove from list.
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   871
          m_head = item.next;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   872
          leftToRemove -= itemRealSize;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   873
        }
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   874
      else
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   875
        {
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   876
          // fragment the list item.
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   877
          PacketMetadata fragment (m_packetUid, 0);
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   878
          extraItem.fragmentStart += leftToRemove;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   879
          leftToRemove = 0;
867
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   880
          uint16_t written = fragment.AddBig (0xffff, fragment.m_tail,
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   881
                                              &item, &extraItem);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   882
          fragment.UpdateTail (written);
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   883
          current = item.next;
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   884
          while (current != 0xffff)
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   885
            {
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   886
              ReadItems (current, &item, &extraItem);
867
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   887
              written = fragment.AddBig (0xffff, fragment.m_tail,
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   888
                                         &item, &extraItem);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   889
              fragment.UpdateTail (written);
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   890
              if (current == m_tail)
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   891
                {
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   892
                  break;
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   893
                }
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   894
              current = item.next;
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   895
            }
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   896
          *this = fragment;
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   897
        }
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   898
      NS_ASSERT (item.size >= extraItem.fragmentEnd - extraItem.fragmentStart &&
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   899
                 extraItem.fragmentStart <= extraItem.fragmentEnd);
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   900
      if (current == m_tail)
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   901
        {
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   902
          break;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   903
        }
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   904
      current = item.next;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   905
    }
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   906
  NS_ASSERT (leftToRemove == 0);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   907
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   908
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   909
PacketMetadata::RemoveAtEnd (uint32_t end)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   910
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   911
  if (!m_enable) 
792
99423210502e implement ItemList construction
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 791
diff changeset
   912
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   913
      return;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   914
    }
872
cd19d2692521 unconditionally set m_data
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 870
diff changeset
   915
  NS_ASSERT (m_data != 0);
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   916
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   917
  uint32_t leftToRemove = end;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   918
  uint16_t current = m_tail;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   919
  while (current != 0xffff && leftToRemove > 0)
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   920
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   921
      struct PacketMetadata::SmallItem item;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   922
      PacketMetadata::ExtraItem extraItem;
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   923
      ReadItems (current, &item, &extraItem);
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   924
      uint32_t itemRealSize = extraItem.fragmentEnd - extraItem.fragmentStart;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   925
      if (itemRealSize <= leftToRemove)
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   926
        {
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   927
          // remove from list.
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   928
          m_tail = item.prev;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   929
          leftToRemove -= itemRealSize;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   930
        }
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   931
      else
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   932
        {
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   933
          // fragment the list item.
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   934
          PacketMetadata fragment (m_packetUid, 0);
851
ce4de5a9dcd0 remove data from end of trailer, not start of header
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 850
diff changeset
   935
          NS_ASSERT (extraItem.fragmentEnd > leftToRemove);
ce4de5a9dcd0 remove data from end of trailer, not start of header
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 850
diff changeset
   936
          extraItem.fragmentEnd -= leftToRemove;
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   937
          leftToRemove = 0;
867
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   938
          uint16_t written = fragment.AddBig (fragment.m_head, 0xffff,
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   939
                                              &item, &extraItem);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   940
          fragment.UpdateHead (written);
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   941
          current = item.prev;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   942
          while (current != 0xffff)
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   943
            {
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   944
              ReadItems (current, &item, &extraItem);
867
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   945
              written = fragment.AddBig (fragment.m_head, 0xffff,
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   946
                                         &item, &extraItem);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   947
              fragment.UpdateHead (written);
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   948
              if (current == m_head)
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   949
                {
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   950
                  break;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   951
                }
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   952
              current = item.prev;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   953
            }
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   954
          *this = fragment;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   955
        }
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   956
      NS_ASSERT (item.size >= extraItem.fragmentEnd - extraItem.fragmentStart &&
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   957
                 extraItem.fragmentStart <= extraItem.fragmentEnd);
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   958
      if (current == m_head)
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   959
        {
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   960
          break;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   961
        }
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   962
      current = item.prev;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   963
    }
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   964
  NS_ASSERT (leftToRemove == 0);
790
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
   965
}
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
   966
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   967
uint32_t
907
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
   968
PacketMetadata::DoPrint (const struct PacketMetadata::SmallItem *item, 
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
   969
                         const struct PacketMetadata::ExtraItem *extraItem,
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
   970
                         Buffer data, uint32_t offset, const PacketPrinter &printer,
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
   971
                         std::ostream &os) const
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   972
{
1127
df45b772d989 make sure we return the right integer uid if the header of trailer was already registered.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 1021
diff changeset
   973
  uint32_t uid = (item->typeUid & 0xfffffffe) >> 1;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   974
  if (uid == 0)
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   975
    {
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   976
      // payload.
907
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
   977
      printer.PrintPayload (os, extraItem->packetUid, item->size, 
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
   978
                            extraItem->fragmentStart, 
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
   979
                            item->size - extraItem->fragmentEnd);
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   980
    }
907
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
   981
  else if (extraItem->fragmentStart != 0 ||
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
   982
           extraItem->fragmentEnd != item->size)
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   983
    {
907
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
   984
      printer.PrintChunkFragment (uid, os, extraItem->packetUid, item->size, 
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
   985
                                  extraItem->fragmentStart, 
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
   986
                                  item->size - extraItem->fragmentEnd);
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   987
    }
1141
a75fc1741700 rework the PacketPrinter API and implementation
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 1134
diff changeset
   988
  else if (ChunkRegistry::IsHeader (uid))
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   989
    {
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   990
      ns3::Buffer::Iterator j = data.Begin ();
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   991
      j.Next (offset);
907
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
   992
      printer.PrintChunk (uid, j, os, extraItem->packetUid, item->size);
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   993
    }
1141
a75fc1741700 rework the PacketPrinter API and implementation
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 1134
diff changeset
   994
  else if (ChunkRegistry::IsTrailer (uid))
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   995
    {
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   996
      ns3::Buffer::Iterator j = data.End ();
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   997
      j.Prev (data.GetSize () - (offset + item->size));
907
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
   998
      printer.PrintChunk (uid, j, os, extraItem->packetUid, item->size);
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   999
    }
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1000
  else 
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1001
    {
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1002
      NS_ASSERT (false);
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1003
    }
907
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
  1004
  return extraItem->fragmentEnd - extraItem->fragmentStart;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1005
}
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1006
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1007
uint32_t
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1008
PacketMetadata::GetTotalSize (void) const
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1009
{
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1010
  uint32_t totalSize = 0;
840
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
  1011
  uint16_t current = m_head;
841
83a5df185d90 fix the list iteration logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 840
diff changeset
  1012
  uint16_t tail = m_tail;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1013
  while (current != 0xffff)
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1014
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1015
      struct PacketMetadata::SmallItem item;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1016
      PacketMetadata::ExtraItem extraItem;
850
470258d962cc simplify GetTotalSize
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 849
diff changeset
  1017
      ReadItems (current, &item, &extraItem);
470258d962cc simplify GetTotalSize
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 849
diff changeset
  1018
      totalSize += extraItem.fragmentEnd - extraItem.fragmentStart;
841
83a5df185d90 fix the list iteration logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 840
diff changeset
  1019
      if (current == tail)
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1020
        {
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1021
          break;
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1022
        }
904
baa02d31c1ff add failing assert
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 900
diff changeset
  1023
      NS_ASSERT (current != item.next);
841
83a5df185d90 fix the list iteration logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 840
diff changeset
  1024
      current = item.next;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1025
    }
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1026
  return totalSize;
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1027
}
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1028
887
acd1bbdf4f2f avoid duplicating the packet uid
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 884
diff changeset
  1029
uint32_t 
acd1bbdf4f2f avoid duplicating the packet uid
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 884
diff changeset
  1030
PacketMetadata::GetUid (void) const
acd1bbdf4f2f avoid duplicating the packet uid
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 884
diff changeset
  1031
{
acd1bbdf4f2f avoid duplicating the packet uid
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 884
diff changeset
  1032
  return m_packetUid;
acd1bbdf4f2f avoid duplicating the packet uid
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 884
diff changeset
  1033
}
acd1bbdf4f2f avoid duplicating the packet uid
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 884
diff changeset
  1034
806
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1035
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1036
PacketMetadata::Print (std::ostream &os, Buffer data, const PacketPrinter &printer) const
806
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1037
{
790
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
  1038
  if (!m_enable) 
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
  1039
    {
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
  1040
      return;
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
  1041
    }
872
cd19d2692521 unconditionally set m_data
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 870
diff changeset
  1042
  NS_ASSERT (m_data != 0);
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1043
  NS_ASSERT (GetTotalSize () == data.GetSize ());
907
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
  1044
  struct PacketMetadata::SmallItem item;
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
  1045
  struct PacketMetadata::ExtraItem extraItem;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1046
  if (printer.m_forward)
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1047
    {
907
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
  1048
      uint32_t current = m_head;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1049
      uint32_t offset = 0;
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1050
      while (current != 0xffff)
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1051
        {
907
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
  1052
          ReadItems (current, &item, &extraItem);
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
  1053
          uint32_t realSize = DoPrint (&item, &extraItem, data, offset, printer, os);
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1054
          offset += realSize;
907
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
  1055
          if (current == m_tail)
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1056
            {
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1057
              break;
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1058
            }
892
b3f73643c055 add separator support to PacketPrinter
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 887
diff changeset
  1059
          if (item.next != 0xffff)
b3f73643c055 add separator support to PacketPrinter
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 887
diff changeset
  1060
            {
b3f73643c055 add separator support to PacketPrinter
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 887
diff changeset
  1061
              os << printer.m_separator;
b3f73643c055 add separator support to PacketPrinter
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 887
diff changeset
  1062
            }
904
baa02d31c1ff add failing assert
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 900
diff changeset
  1063
          NS_ASSERT (current != item.next);
841
83a5df185d90 fix the list iteration logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 840
diff changeset
  1064
          current = item.next;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1065
        }
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1066
    }
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1067
  else
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1068
    {
907
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
  1069
      uint32_t current = m_tail;
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
  1070
      uint32_t offset = data.GetSize ();
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1071
      while (current != 0xffff)
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1072
        {
907
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
  1073
          ReadItems (current, &item, &extraItem);
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
  1074
          uint32_t realSize = DoPrint (&item, &extraItem, data, offset - item.size, printer, os);
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1075
          offset -= realSize;
907
c67b33c30a8e test and fix backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 906
diff changeset
  1076
          if (current == m_head)
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1077
            {
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1078
              break;
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1079
            }
895
b90ba0bcfd36 add separator support to backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 892
diff changeset
  1080
          if (item.prev != 0xffff)
b90ba0bcfd36 add separator support to backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 892
diff changeset
  1081
            {
b90ba0bcfd36 add separator support to backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 892
diff changeset
  1082
              os << printer.m_separator;
b90ba0bcfd36 add separator support to backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 892
diff changeset
  1083
            }
904
baa02d31c1ff add failing assert
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 900
diff changeset
  1084
          NS_ASSERT (current != item.prev);
841
83a5df185d90 fix the list iteration logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 840
diff changeset
  1085
          current = item.prev;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1086
        }
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1087
    }
790
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
  1088
}
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
  1089
1134
5f5d33e01eb9 split test code out of the main PacketMetadata code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 1133
diff changeset
  1090
} // namespace ns3
806
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1091