src/common/packet-metadata.cc
author Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
Wed, 13 Jun 2007 00:20:53 +0200
changeset 895 b90ba0bcfd36
parent 892 b3f73643c055
child 900 2087082ba3ed
permissions -rw-r--r--
add separator support to backward printing
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
 * All rights reserved.
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
     5
 *
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
     6
 * 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
     7
 * 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
     8
 * published by the Free Software Foundation;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
     9
 *
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    10
 * 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
    11
 * 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
    12
 * 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
    13
 * GNU General Public License for more details.
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    14
 *
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    15
 * 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
    16
 * 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
    17
 * 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
    18
 *
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    19
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    20
 */
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    21
#include <utility>
792
99423210502e implement ItemList construction
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 791
diff changeset
    22
#include <list>
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    23
#include "ns3/assert.h"
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    24
#include "ns3/fatal-error.h"
833
224bfad58818 a bunch of optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 830
diff changeset
    25
#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
    26
#include "packet-metadata.h"
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    27
#include "chunk.h"
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    28
#include "buffer.h"
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    29
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    30
NS_DEBUG_COMPONENT_DEFINE ("PacketMetadata");
833
224bfad58818 a bunch of optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 830
diff changeset
    31
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    32
namespace ns3 {
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    33
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    34
bool PacketMetadata::m_enable = false;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    35
uint32_t PacketMetadata::m_maxSize = 0;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    36
uint16_t PacketMetadata::m_chunkUid = 0;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    37
PacketMetadata::DataFreeList PacketMetadata::m_freeList;
876
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
    38
bool g_optOne = false;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    39
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    40
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    41
PacketMetadata::Enable (void)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    42
{
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    43
  m_enable = true;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    44
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
    45
876
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
    46
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    47
PacketMetadata::SetOptOne (bool optOne)
876
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
    48
{
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
    49
  g_optOne = optOne;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
    50
}
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
    51
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    52
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    53
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
    54
{
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    55
  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
    56
  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
    57
  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
    58
  m_data->m_count--;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    59
  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
    60
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    61
      PacketMetadata::Recycle (m_data);
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    62
    }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    63
  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
    64
  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
    65
    {
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
    66
      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
    67
      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
    68
      // 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
    69
      start = &m_data->m_data[m_tail];
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
    70
      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
    71
      // 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
    72
      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
    73
      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
    74
    }
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    75
}
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    76
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    77
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
    78
{
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    79
  NS_ASSERT (m_data != 0);
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    80
  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
    81
      (m_head == 0xffff ||
e335d37541c3 try alternative implementation of AddSmall
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 869
diff changeset
    82
       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
    83
       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
    84
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    85
      /* enough room, not dirty. */
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    86
    }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    87
  else 
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    88
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
    89
      /* (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
    90
      ReserveCopy (size);
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
}
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
uint32_t 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
    95
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
    96
{
869
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
    97
  if (value < 0x80)
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
    98
    {
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
    99
      return 1;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   100
    }
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   101
  if (value < 0x4000)
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   102
    {
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   103
      return 2;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   104
    }
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   105
  if (value < 0x200000)
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   106
    {
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   107
      return 3;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   108
    }
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   109
  if (value < 0x10000000)
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   110
    {
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   111
      return 4;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   112
    }
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   113
  return 5;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   114
}
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   115
uint32_t
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   116
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
   117
{
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   118
  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
   119
  uint32_t result = 0;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   120
  uint8_t byte;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   121
  result = 0;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   122
  byte = buffer[0];
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   123
  result = (byte & (~0x80));
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   124
  if (!(byte & 0x80))
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   125
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   126
      *pBuffer = buffer + 1;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   127
      return result;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   128
    }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   129
  byte = buffer[1];
884
f3836277079e fix uleb128 reading bug
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 883
diff changeset
   130
  result |= (byte & (~0x80)) << 7;
835
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 + 2;
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[2];
884
f3836277079e fix uleb128 reading bug
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 883
diff changeset
   137
  result |= (byte & (~0x80)) << 14;
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 + 3;
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[3];
884
f3836277079e fix uleb128 reading bug
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 883
diff changeset
   144
  result |= (byte & (~0x80)) << 21;
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 + 4;
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[4];
884
f3836277079e fix uleb128 reading bug
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 883
diff changeset
   151
  result |= (byte & (~0x80)) << 28;
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 + 5;
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
  /* 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
   158
   * 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
   159
   */
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   160
  NS_ASSERT (false);
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   161
  return 0;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   162
}
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
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   165
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
   166
{
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   167
  buffer[0] = value & 0xff;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   168
  value >>= 8;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   169
  buffer[1] = value;
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   170
}
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   171
bool
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   172
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
   173
{
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   174
  uint8_t *start = *pBuffer;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   175
  if (value < 0x80 && start < end)
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   176
    {
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   177
      start[0] = value;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   178
      *pBuffer = start + 1;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   179
      return true;
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
  if (value < 0x4000 && start + 1 < end)
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   182
    {
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   183
      uint8_t byte = value & (~0x80);
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   184
      start[0] = 0x80 | byte;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   185
      value >>= 7;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   186
      start[1] = value;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   187
      *pBuffer = start + 2;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   188
      return true;
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
  return false;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   191
}
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   192
bool
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   193
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
   194
{
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   195
  uint8_t *start = *pBuffer;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   196
  if (start + 1 < end)
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   197
    {
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   198
      start[0] = value & 0xff;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   199
      start[1] = value >> 8;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   200
      *pBuffer = start + 2;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   201
      return true;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   202
    }
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   203
  return false;
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
bool
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   206
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
   207
{
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   208
  uint8_t *start = *pBuffer;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   209
  if (start + 3 < end)
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   210
    {
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   211
      start[0] = value & 0xff;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   212
      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
   213
      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
   214
      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
   215
      *pBuffer = start + 4;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   216
      return true;
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
  return false;
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   219
}
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   220
bool
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   221
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
   222
{
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   223
  uint8_t *start = *pBuffer;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   224
  if (value < 0x80 && start < end)
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   225
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   226
      start[0] = value;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   227
      *pBuffer = start + 1;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   228
      return true;
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
  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
   231
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   232
      uint8_t byte = value & (~0x80);
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   233
      start[0] = 0x80 | byte;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   234
      value >>= 7;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   235
      start[1] = value;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   236
      *pBuffer = start + 2;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   237
      return true;
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
  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
   240
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   241
      uint8_t byte = value & (~0x80);
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   242
      start[0] = 0x80 | byte;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   243
      value >>= 7;
869
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   244
      byte = value & (~0x80);
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   245
      start[1] = 0x80 | byte;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   246
      value >>= 7;
869
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   247
      byte = value & (~0x80);
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   248
      start[2] = value;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   249
      *pBuffer = start + 3;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   250
      return true;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   251
    }
869
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   252
  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
   253
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   254
      uint8_t byte = value & (~0x80);
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   255
      start[0] = 0x80 | byte;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   256
      value >>= 7;
869
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   257
      byte = value & (~0x80);
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   258
      start[1] = 0x80 | byte;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   259
      value >>= 7;
869
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   260
      byte = value & (~0x80);
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   261
      start[2] = 0x80 | byte;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   262
      value >>= 7;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   263
      start[3] = value;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   264
      *pBuffer = start + 4;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   265
      return true;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   266
    }
869
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   267
  if (start + 4 < end)
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   268
    {
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   269
      uint8_t byte = value & (~0x80);
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   270
      start[0] = 0x80 | byte;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   271
      value >>= 7;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   272
      byte = value & (~0x80);
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   273
      start[1] = 0x80 | byte;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   274
      value >>= 7;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   275
      byte = value & (~0x80);
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   276
      start[2] = 0x80 | byte;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   277
      value >>= 7;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   278
      byte = value & (~0x80);
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   279
      start[3] = 0x80 | byte;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   280
      value >>= 7;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   281
      start[4] = value;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   282
      *pBuffer = start + 5;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   283
      return true;
652907a5e97d fix Append and optimize GetUleb128Size
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 867
diff changeset
   284
    }
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   285
  return false;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   286
}
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   287
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   288
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   289
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
   290
{
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   291
  if (value < 0x200000)
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   292
    {
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   293
      uint8_t byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   294
      buffer[0] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   295
      value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   296
      byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   297
      buffer[1] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   298
      value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   299
      byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   300
      buffer[2] = value;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   301
      return;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   302
    }
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   303
  if (value < 0x10000000)
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   304
    {
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   305
      uint8_t byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   306
      buffer[0] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   307
      value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   308
      byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   309
      buffer[1] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   310
      value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   311
      byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   312
      buffer[2] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   313
      value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   314
      buffer[3] = value;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   315
      return;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   316
    }
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   317
  {
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   318
    uint8_t byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   319
    buffer[0] = 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
    byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   322
    buffer[1] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   323
    value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   324
    byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   325
    buffer[2] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   326
    value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   327
    byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   328
    buffer[3] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   329
    value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   330
    buffer[4] = value;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   331
  }
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   332
}
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   333
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   334
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   335
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
   336
{
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   337
  if (value < 0x80)
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
      buffer[0] = value;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   340
      return;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   341
    }
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   342
  if (value < 0x4000)
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
      uint8_t byte = value & (~0x80);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   345
      buffer[0] = 0x80 | byte;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   346
      value >>= 7;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   347
      buffer[1] = value;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   348
      return;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   349
    }
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   350
  AppendValueExtra (value, buffer);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   351
}
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   352
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   353
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   354
PacketMetadata::UpdateTail (uint16_t written)
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   355
{
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   356
  if (m_head == 0xffff)
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   357
    {
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   358
      NS_ASSERT (m_tail == 0xffff);
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   359
      m_head = m_used;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   360
      m_tail = m_used;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   361
    } 
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   362
  else
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   363
    {
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   364
      NS_ASSERT (m_tail != 0xffff);
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   365
      // 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
   366
      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
   367
      Append16 (m_used, previousTail);
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   368
      // 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
   369
      m_tail = m_used;
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
  NS_ASSERT (m_head != 0xffff);
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   373
  m_used += written;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   374
  m_data->m_dirtyEnd = m_used;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   375
}
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   376
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   377
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   378
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   379
PacketMetadata::UpdateHead (uint16_t written)
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   380
{
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   381
  if (m_head == 0xffff)
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   382
    {
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   383
      NS_ASSERT (m_tail == 0xffff);
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   384
      m_head = m_used;
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   385
      m_tail = m_used;
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   386
    } 
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   387
  else
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
      NS_ASSERT (m_head != 0xffff);
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   390
      // 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
   391
      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
   392
      Append16 (m_used, previousHead);
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   393
      // update the head of list to the new node.
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   394
      m_head = m_used;
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   395
    }
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   396
  NS_ASSERT (m_tail != 0xffff);
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
  m_used += written;
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   399
  m_data->m_dirtyEnd = m_used;
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   400
}
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   401
859
aa89ae478c3a remove Update call from within AddSmall and AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 858
diff changeset
   402
uint16_t
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   403
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
   404
{
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   405
  NS_ASSERT (m_data != 0);
876
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   406
  if (g_optOne)
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   407
    {
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   408
      uint32_t typeUidSize = GetUleb128Size (item->typeUid);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   409
      uint32_t sizeSize = GetUleb128Size (item->size);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   410
      uint32_t n = typeUidSize + sizeSize + 2 + 2 + 2;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   411
    restart:
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   412
      if (m_used + n <= m_data->m_size &&
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   413
      (m_head == 0xffff ||
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   414
       m_data->m_count == 1 ||
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   415
       m_used == m_data->m_dirtyEnd))
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   416
        {
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   417
          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
   418
          Append16 (item->next, buffer);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   419
          buffer += 2;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   420
          Append16 (item->prev, buffer);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   421
          buffer += 2;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   422
          AppendValue (item->typeUid, buffer);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   423
          buffer += typeUidSize;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   424
          AppendValue (item->size, buffer);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   425
          buffer += sizeSize;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   426
          Append16 (item->chunkUid, buffer);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   427
        }
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   428
      else
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   429
        {
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   430
          ReserveCopy (n);
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   431
          goto restart;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   432
        }
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   433
      return n;
850783184c36 add back optimization option
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 874
diff changeset
   434
    }
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   435
 append:
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   436
  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
   437
  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
   438
  if (end - start >= 8 &&
858
280636166143 remove useless CanAdd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 857
diff changeset
   439
      (m_head == 0xffff ||
280636166143 remove useless CanAdd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 857
diff changeset
   440
       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
   441
       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
   442
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   443
      uint8_t *buffer = start;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   444
862
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   445
      Append16 (item->next, buffer);
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   446
      buffer += 2;
862
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   447
      Append16 (item->prev, buffer);
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   448
      buffer += 2;
862
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   449
      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
   450
          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
   451
          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
   452
        {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   453
          uintptr_t written = buffer - start;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   454
          NS_ASSERT (written <= 0xffff);
859
aa89ae478c3a remove Update call from within AddSmall and AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 858
diff changeset
   455
          return written;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   456
        }
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   457
    }
862
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   458
  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
   459
  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
   460
  n += 2;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   461
  n += 2 + 2;
870
e335d37541c3 try alternative implementation of AddSmall
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 869
diff changeset
   462
  Reserve (n);
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   463
  goto append;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   464
}
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   465
859
aa89ae478c3a remove Update call from within AddSmall and AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 858
diff changeset
   466
uint16_t
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   467
PacketMetadata::AddBig (uint32_t next, uint32_t prev, 
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   468
                       const PacketMetadata::SmallItem *item, 
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   469
                       const PacketMetadata::ExtraItem *extraItem)
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   470
{
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   471
  NS_ASSERT (m_data != 0);
852
a1a3c9bdb7f4 fix a few bugs in ::RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 851
diff changeset
   472
  uint32_t typeUid = ((item->typeUid & 0x1) == 0x1)?item->typeUid:item->typeUid+1;
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   473
 append:
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   474
  uint8_t *start = &m_data->m_data[m_used];
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   475
  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
   476
  if (end - start >= 14 &&
858
280636166143 remove useless CanAdd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 857
diff changeset
   477
      (m_head == 0xffff ||
280636166143 remove useless CanAdd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 857
diff changeset
   478
       m_data->m_count == 1 ||
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   479
       m_used == m_data->m_dirtyEnd))
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   480
    {
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   481
      uint8_t *buffer = start;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   482
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   483
      Append16 (next, buffer);
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   484
      buffer += 2;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   485
      Append16 (prev, buffer);
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   486
      buffer += 2;
852
a1a3c9bdb7f4 fix a few bugs in ::RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 851
diff changeset
   487
      if (TryToAppend (typeUid, &buffer, end) &&
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   488
          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
   489
          TryToAppend16 (item->chunkUid, &buffer, end) &&
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   490
          TryToAppend (extraItem->fragmentStart, &buffer, end) &&
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   491
          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
   492
          TryToAppend32 (extraItem->packetUid, &buffer, end))
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   493
        {
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   494
          uintptr_t written = buffer - start;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   495
          NS_ASSERT (written <= 0xffff);
859
aa89ae478c3a remove Update call from within AddSmall and AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 858
diff changeset
   496
          return written;
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   497
        }
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   498
    }
860
3095d7275585 add counters
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 859
diff changeset
   499
852
a1a3c9bdb7f4 fix a few bugs in ::RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 851
diff changeset
   500
  uint32_t n = GetUleb128Size (typeUid);
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   501
  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
   502
  n += 2;
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   503
  n += GetUleb128Size (extraItem->fragmentStart);
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   504
  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
   505
  n += 4;
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   506
  n += 2 + 2;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   507
  ReserveCopy (n);
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   508
  goto append;
854
cbe6790bf9fa simplify calls to AddBig and AddSmall
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 853
diff changeset
   509
}
cbe6790bf9fa simplify calls to AddBig and AddSmall
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 853
diff changeset
   510
cbe6790bf9fa simplify calls to AddBig and AddSmall
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 853
diff changeset
   511
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   512
PacketMetadata::ReplaceTail (PacketMetadata::SmallItem *item, 
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   513
                            PacketMetadata::ExtraItem *extraItem,
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   514
                            uint32_t available)
854
cbe6790bf9fa simplify calls to AddBig and AddSmall
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 853
diff changeset
   515
{
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   516
  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
   517
  if (available >= 14 &&
856
007981962639 make all tests pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 855
diff changeset
   518
      m_data->m_count == 1)
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   519
    {
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   520
      uint8_t *buffer = &m_data->m_data[m_tail];
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   521
      uint8_t *end = buffer + available;
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   522
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   523
      Append16 (item->next, buffer);
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   524
      buffer += 2;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   525
      Append16 (item->prev, buffer);
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   526
      buffer += 2;
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   527
      if (TryToAppend (item->typeUid, &buffer, end) &&
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   528
          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
   529
          TryToAppend16 (item->chunkUid, &buffer, end) &&
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   530
          TryToAppend (extraItem->fragmentStart, &buffer, end) &&
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   531
          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
   532
          TryToAppend32 (extraItem->packetUid, &buffer, end))
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   533
        {
856
007981962639 make all tests pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 855
diff changeset
   534
          m_used = buffer - &m_data->m_data[0];
007981962639 make all tests pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 855
diff changeset
   535
          m_data->m_dirtyEnd = m_used;
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   536
          return;
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   537
        }
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   538
    }
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   539
  
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   540
  // create a copy of the packet.
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   541
  PacketMetadata h (m_packetUid, 0);
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   542
  uint16_t current = m_head;
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   543
  while (current != 0xffff && current != m_tail)
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   544
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   545
      struct PacketMetadata::SmallItem tmpItem;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   546
      PacketMetadata::ExtraItem tmpExtraItem;
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   547
      ReadItems (current, &tmpItem, &tmpExtraItem);
867
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   548
      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
   549
                                   &tmpItem, &tmpExtraItem);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   550
      h.UpdateTail (written);
855
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
  // append new tail.
867
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   553
  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
   554
  h.UpdateTail (written);
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   555
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   556
  *this = h;
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   557
}
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   558
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   559
uint32_t
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   560
PacketMetadata::ReadItems (uint16_t current, 
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   561
                          struct PacketMetadata::SmallItem *item,
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   562
                          struct PacketMetadata::ExtraItem *extraItem) const
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   563
{
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   564
  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
   565
  item->next = buffer[0];
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   566
  item->next |= (buffer[1]) << 8;
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   567
  item->prev = buffer[2];
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   568
  item->prev |= (buffer[3]) << 8;
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   569
  buffer += 4;
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   570
  item->typeUid = ReadUleb128 (&buffer);
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   571
  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
   572
  item->chunkUid = buffer[0];
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   573
  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
   574
  buffer += 2;
865
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   575
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   576
  bool isExtra = (item->typeUid & 0x1) == 0x1;
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   577
  if (isExtra)
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   578
    {
865
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   579
      extraItem->fragmentStart = ReadUleb128 (&buffer);
7356a5847860 ReadItems does not depend on ReadSmall & ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 864
diff changeset
   580
      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
   581
      extraItem->packetUid = buffer[0];
2aab1eb32b12 store chunkUid and packetUid as fixed-size fields
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 872
diff changeset
   582
      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
   583
      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
   584
      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
   585
      buffer += 4;
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   586
    }
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   587
  else
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   588
    {
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   589
      extraItem->fragmentStart = 0;
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   590
      extraItem->fragmentEnd = item->size;
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   591
      extraItem->packetUid = m_packetUid;
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   592
    }
848
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
   593
  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
   594
  return buffer - &m_data->m_data[current];
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   595
}
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   596
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   597
struct PacketMetadata::Data *
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   598
PacketMetadata::Create (uint32_t size)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   599
{
833
224bfad58818 a bunch of optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 830
diff changeset
   600
  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
   601
  if (size > m_maxSize)
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   602
    {
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   603
      m_maxSize = size;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   604
    }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   605
  while (!m_freeList.empty ()) 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   606
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   607
      struct PacketMetadata::Data *data = m_freeList.back ();
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   608
      m_freeList.pop_back ();
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   609
      if (data->m_size >= size) 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   610
        {
833
224bfad58818 a bunch of optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 830
diff changeset
   611
          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
   612
          data->m_count = 1;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   613
          return data;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   614
        }
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   615
      PacketMetadata::Deallocate (data);
833
224bfad58818 a bunch of optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 830
diff changeset
   616
      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
   617
    }
833
224bfad58818 a bunch of optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 830
diff changeset
   618
  NS_DEBUG ("create alloc size="<<m_maxSize);
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   619
  return PacketMetadata::Allocate (m_maxSize);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   620
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   621
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   622
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   623
PacketMetadata::Recycle (struct PacketMetadata::Data *data)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   624
{
833
224bfad58818 a bunch of optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 830
diff changeset
   625
  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
   626
  NS_ASSERT (data->m_count == 0);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   627
  if (m_freeList.size () > 1000 ||
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   628
      data->m_size < m_maxSize) 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   629
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   630
      PacketMetadata::Deallocate (data);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   631
    } 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   632
  else 
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
      m_freeList.push_back (data);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   635
    }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   636
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   637
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   638
struct PacketMetadata::Data *
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   639
PacketMetadata::Allocate (uint32_t n)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   640
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   641
  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
   642
  if (n <= 10)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   643
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   644
      n = 10;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   645
    }
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   646
  size += n - 10;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   647
  uint8_t *buf = new uint8_t [size];
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   648
  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
   649
  data->m_size = n;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   650
  data->m_count = 1;
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   651
  data->m_dirtyEnd = 0;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   652
  return data;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   653
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   654
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   655
PacketMetadata::Deallocate (struct PacketMetadata::Data *data)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   656
{
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   657
  uint8_t *buf = (uint8_t *)data;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   658
  delete [] buf;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   659
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   660
791
ff528910ba40 prepare for forward iteration of history.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 790
diff changeset
   661
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   662
PacketMetadata 
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   663
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
   664
{
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   665
  PacketMetadata fragment = *this;
790
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
   666
  fragment.RemoveAtStart (start);
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
   667
  fragment.RemoveAtEnd (end);
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
   668
  return fragment;
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
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   671
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   672
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
   673
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   674
  if (!m_enable)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   675
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   676
      return;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   677
    }
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   678
  struct PacketMetadata::SmallItem item;
862
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   679
  item.next = m_head;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   680
  item.prev = 0xffff;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   681
  item.typeUid = uid;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   682
  item.size = size;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   683
  item.chunkUid = m_chunkUid;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   684
  m_chunkUid++;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   685
  uint16_t written = AddSmall (&item);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   686
  UpdateHead (written);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   687
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   688
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   689
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
   690
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   691
  if (!m_enable) 
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   692
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   693
      return;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   694
    }
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   695
  struct PacketMetadata::SmallItem item;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   696
  struct PacketMetadata::ExtraItem extraItem;
866
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   697
  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
   698
  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
   699
      item.size != size)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   700
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   701
      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
   702
    }
866
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   703
  else if (item.typeUid != uid &&
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   704
           (extraItem.fragmentStart != 0 ||
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   705
            extraItem.fragmentEnd != size))
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   706
    {
866
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   707
      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
   708
    }
840
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
   709
  m_head = item.next;
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
   710
  if (m_head > m_tail)
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   711
    {
840
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
   712
      m_used = m_head;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   713
    }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   714
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   715
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   716
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
   717
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   718
  if (!m_enable)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   719
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   720
      return;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   721
    }
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   722
  struct PacketMetadata::SmallItem item;
862
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   723
  item.next = 0xffff;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   724
  item.prev = m_tail;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   725
  item.typeUid = uid;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   726
  item.size = size;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   727
  item.chunkUid = m_chunkUid;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   728
  m_chunkUid++;
4add4fe2020f simplify a bit the small item logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 861
diff changeset
   729
  uint16_t written = AddSmall (&item);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   730
  UpdateTail (written);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   731
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   732
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   733
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
   734
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   735
  if (!m_enable) 
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   736
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   737
      return;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   738
    }
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   739
  struct PacketMetadata::SmallItem item;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   740
  struct PacketMetadata::ExtraItem extraItem;
866
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   741
  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
   742
  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
   743
      item.size != size)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   744
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   745
      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
   746
    }
866
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   747
  else if (item.typeUid != uid &&
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   748
           (extraItem.fragmentStart != 0 ||
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   749
            extraItem.fragmentEnd != size))
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   750
    {
866
7880ebff9969 remove ReadSmall and ReadExtra
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 865
diff changeset
   751
      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
   752
    }
840
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
   753
  m_tail = item.prev;
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
   754
  if (m_tail > m_head)
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   755
    {
840
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
   756
      m_used = m_tail;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   757
    }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   758
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   759
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   760
PacketMetadata::AddAtEnd (PacketMetadata const&o)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   761
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   762
  if (!m_enable) 
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   763
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   764
      return;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   765
    }
872
cd19d2692521 unconditionally set m_data
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 870
diff changeset
   766
  if (m_tail == 0xffff)
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   767
    {
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   768
      *this = o;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   769
      return;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   770
    }
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   771
  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
   772
857
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   773
  uint16_t lastTail;
6f7593400c82 a few micro-optimizations
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 856
diff changeset
   774
  lastTail = m_tail;
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   775
  struct PacketMetadata::SmallItem lastItem;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   776
  PacketMetadata::ExtraItem lastExtraItem;
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   777
  uint32_t lastTailSize = ReadItems (m_tail, &lastItem, &lastExtraItem);
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   778
  if (m_tail + lastTailSize == m_used &&
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   779
      m_used == m_data->m_dirtyEnd)
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   780
    {
856
007981962639 make all tests pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 855
diff changeset
   781
      lastTailSize = m_data->m_size - m_tail;
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   782
    }
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   783
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   784
  uint16_t current = o.m_head;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   785
  while (current != 0xffff)
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   786
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   787
      struct PacketMetadata::SmallItem item;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   788
      PacketMetadata::ExtraItem extraItem;
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   789
      o.ReadItems (current, &item, &extraItem);
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   790
      if (extraItem.packetUid == lastExtraItem.packetUid &&
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   791
          item.typeUid == lastItem.typeUid &&
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   792
          item.chunkUid == lastItem.chunkUid &&
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   793
          item.size == lastItem.size &&
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   794
          extraItem.fragmentStart == lastExtraItem.fragmentEnd)
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   795
        {
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   796
          // replace previous tail.
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   797
          lastExtraItem.fragmentEnd = extraItem.fragmentEnd;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   798
          NS_ASSERT (m_tail == lastTail);
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   799
          ReplaceTail (&lastItem, &lastExtraItem, lastTailSize);
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   800
        }
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   801
      else
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   802
        {
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   803
          // append the extra items.
867
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   804
          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
   805
          UpdateTail (written);
853
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   806
        }
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   807
      if (current == o.m_tail)
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   808
        {
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   809
          break;
2477fe325610 share some code, implement AddAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 852
diff changeset
   810
        }
856
007981962639 make all tests pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 855
diff changeset
   811
      current = item.next;
855
6b27e6180fcb implement ReplaceTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 854
diff changeset
   812
    }
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   813
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   814
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   815
PacketMetadata::AddPaddingAtEnd (uint32_t end)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   816
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   817
  if (!m_enable)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   818
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   819
      return;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   820
    }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   821
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   822
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   823
PacketMetadata::RemoveAtStart (uint32_t start)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   824
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   825
  if (!m_enable) 
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   826
    {
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   827
      return;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   828
    }
872
cd19d2692521 unconditionally set m_data
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 870
diff changeset
   829
  NS_ASSERT (m_data != 0);
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   830
  uint32_t leftToRemove = start;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   831
  uint16_t current = m_head;
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   832
  while (current != 0xffff && leftToRemove > 0)
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   833
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   834
      struct PacketMetadata::SmallItem item;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   835
      PacketMetadata::ExtraItem extraItem;
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   836
      ReadItems (current, &item, &extraItem);
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   837
      uint32_t itemRealSize = extraItem.fragmentEnd - extraItem.fragmentStart;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   838
      if (itemRealSize <= leftToRemove)
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   839
        {
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   840
          // remove from list.
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   841
          m_head = item.next;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   842
          leftToRemove -= itemRealSize;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   843
        }
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   844
      else
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   845
        {
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   846
          // fragment the list item.
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   847
          PacketMetadata fragment (m_packetUid, 0);
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   848
          extraItem.fragmentStart += leftToRemove;
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   849
          leftToRemove = 0;
867
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   850
          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
   851
                                              &item, &extraItem);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   852
          fragment.UpdateTail (written);
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   853
          current = item.next;
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   854
          while (current != 0xffff)
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   855
            {
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   856
              ReadItems (current, &item, &extraItem);
867
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   857
              written = fragment.AddBig (0xffff, fragment.m_tail,
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   858
                                         &item, &extraItem);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   859
              fragment.UpdateTail (written);
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   860
              if (current == m_tail)
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   861
                {
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   862
                  break;
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   863
                }
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   864
              current = item.next;
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   865
            }
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   866
          *this = fragment;
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   867
        }
847
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   868
      NS_ASSERT (item.size >= extraItem.fragmentEnd - extraItem.fragmentStart &&
319d107f2435 rewrite PacketHistory::RemoveAtstart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 846
diff changeset
   869
                 extraItem.fragmentStart <= extraItem.fragmentEnd);
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   870
      if (current == m_tail)
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   871
        {
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
   872
          break;
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
      current = item.next;
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
  NS_ASSERT (leftToRemove == 0);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   877
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   878
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   879
PacketMetadata::RemoveAtEnd (uint32_t end)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
   880
{
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   881
  if (!m_enable) 
792
99423210502e implement ItemList construction
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 791
diff changeset
   882
    {
835
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   883
      return;
ea5ca71d6c0c a new implementation of the PacketHistory API
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 834
diff changeset
   884
    }
872
cd19d2692521 unconditionally set m_data
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 870
diff changeset
   885
  NS_ASSERT (m_data != 0);
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   886
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   887
  uint32_t leftToRemove = end;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   888
  uint16_t current = m_tail;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   889
  while (current != 0xffff && leftToRemove > 0)
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   890
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   891
      struct PacketMetadata::SmallItem item;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   892
      PacketMetadata::ExtraItem extraItem;
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   893
      ReadItems (current, &item, &extraItem);
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   894
      uint32_t itemRealSize = extraItem.fragmentEnd - extraItem.fragmentStart;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   895
      if (itemRealSize <= leftToRemove)
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   896
        {
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   897
          // remove from list.
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   898
          m_tail = item.prev;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   899
          leftToRemove -= itemRealSize;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   900
        }
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   901
      else
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   902
        {
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   903
          // fragment the list item.
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   904
          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
   905
          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
   906
          extraItem.fragmentEnd -= leftToRemove;
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   907
          leftToRemove = 0;
867
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   908
          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
   909
                                              &item, &extraItem);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   910
          fragment.UpdateHead (written);
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   911
          current = item.prev;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   912
          while (current != 0xffff)
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   913
            {
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   914
              ReadItems (current, &item, &extraItem);
867
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   915
              written = fragment.AddBig (fragment.m_head, 0xffff,
e98cde9aae4a remove atStart arg to AddBig
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 866
diff changeset
   916
                                         &item, &extraItem);
863
768945a45089 Update -> UpdateHead + UpdateTail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 862
diff changeset
   917
              fragment.UpdateHead (written);
849
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   918
              if (current == m_head)
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   919
                {
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   920
                  break;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   921
                }
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   922
              current = item.prev;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   923
            }
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   924
          *this = fragment;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   925
        }
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   926
      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
   927
                 extraItem.fragmentStart <= extraItem.fragmentEnd);
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   928
      if (current == m_head)
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   929
        {
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   930
          break;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   931
        }
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   932
      current = item.prev;
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   933
    }
5bc5818b09f0 fix simple bugs in RemoveAtEnd
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 848
diff changeset
   934
  NS_ASSERT (leftToRemove == 0);
790
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
   935
}
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
   936
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
   937
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   938
PacketMetadata::PrintDefault (std::ostream &os, Buffer buffer) const
790
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
   939
{
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
   940
  Print (os, buffer, PacketPrinter::GetDefault ());
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
   941
}
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
   942
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   943
uint32_t
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   944
PacketMetadata::DoPrint (struct PacketMetadata::SmallItem *item, uint32_t current,
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   945
                        Buffer data, uint32_t offset, const PacketPrinter &printer,
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   946
                        std::ostream &os) const
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   947
{
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   948
  PacketMetadata::ExtraItem extraItem;
848
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
   949
  ReadItems (current, 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
   950
  uint32_t uid = item->typeUid & 0xfffffffe;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   951
  if (uid == 0)
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   952
    {
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   953
      // payload.
848
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
   954
      printer.PrintPayload (os, extraItem.packetUid, item->size, 
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
   955
                            extraItem.fragmentStart, 
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
   956
                            extraItem.fragmentEnd);
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   957
    }
848
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
   958
  else if (extraItem.fragmentStart != 0 ||
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
   959
           extraItem.fragmentEnd != item->size)
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   960
    {
848
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
   961
      printer.PrintChunkFragment (uid, os, extraItem.packetUid, item->size, 
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
   962
                                  extraItem.fragmentStart, extraItem.fragmentEnd);
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   963
    }
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   964
  else if (PacketPrinter::IsHeader (uid))
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   965
    {
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   966
      ns3::Buffer::Iterator j = data.Begin ();
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   967
      j.Next (offset);
848
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
   968
      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
   969
    }
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   970
  else if (PacketPrinter::IsTrailer (uid))
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   971
    {
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   972
      ns3::Buffer::Iterator j = data.End ();
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   973
      j.Prev (data.GetSize () - (offset + item->size));
848
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
   974
      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
   975
    }
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   976
  else 
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   977
    {
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   978
      NS_ASSERT (false);
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   979
    }
848
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
   980
  return extraItem.fragmentEnd - extraItem.fragmentStart;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   981
}
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   982
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   983
uint32_t
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   984
PacketMetadata::GetTotalSize (void) const
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   985
{
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   986
  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
   987
  uint16_t current = m_head;
841
83a5df185d90 fix the list iteration logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 840
diff changeset
   988
  uint16_t tail = m_tail;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   989
  while (current != 0xffff)
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   990
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   991
      struct PacketMetadata::SmallItem item;
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
   992
      PacketMetadata::ExtraItem extraItem;
850
470258d962cc simplify GetTotalSize
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 849
diff changeset
   993
      ReadItems (current, &item, &extraItem);
470258d962cc simplify GetTotalSize
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 849
diff changeset
   994
      totalSize += extraItem.fragmentEnd - extraItem.fragmentStart;
841
83a5df185d90 fix the list iteration logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 840
diff changeset
   995
      if (current == tail)
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   996
        {
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   997
          break;
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
   998
        }
841
83a5df185d90 fix the list iteration logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 840
diff changeset
   999
      current = item.next;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1000
    }
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1001
  return totalSize;
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1002
}
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1003
887
acd1bbdf4f2f avoid duplicating the packet uid
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 884
diff changeset
  1004
uint32_t 
acd1bbdf4f2f avoid duplicating the packet uid
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 884
diff changeset
  1005
PacketMetadata::GetUid (void) const
acd1bbdf4f2f avoid duplicating the packet uid
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 884
diff changeset
  1006
{
acd1bbdf4f2f avoid duplicating the packet uid
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 884
diff changeset
  1007
  return m_packetUid;
acd1bbdf4f2f avoid duplicating the packet uid
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 884
diff changeset
  1008
}
acd1bbdf4f2f avoid duplicating the packet uid
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 884
diff changeset
  1009
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
  1010
void
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1011
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
  1012
{
790
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
  1013
  if (!m_enable) 
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
  1014
    {
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
  1015
      return;
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
  1016
    }
872
cd19d2692521 unconditionally set m_data
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 870
diff changeset
  1017
  NS_ASSERT (m_data != 0);
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1018
  NS_ASSERT (GetTotalSize () == data.GetSize ());
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1019
  if (printer.m_forward)
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1020
    {
840
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
  1021
      uint32_t tail = m_tail;
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
  1022
      uint32_t head = m_head;
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
  1023
      uint32_t current = head;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1024
      uint32_t offset = 0;
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1025
      while (current != 0xffff)
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1026
        {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1027
          struct PacketMetadata::SmallItem item;
848
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
  1028
          uint32_t realSize = DoPrint (&item, current, data, offset, printer, os);
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1029
          offset += realSize;
840
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
  1030
          if (current == tail)
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1031
            {
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1032
              break;
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1033
            }
892
b3f73643c055 add separator support to PacketPrinter
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 887
diff changeset
  1034
          if (item.next != 0xffff)
b3f73643c055 add separator support to PacketPrinter
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 887
diff changeset
  1035
            {
b3f73643c055 add separator support to PacketPrinter
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 887
diff changeset
  1036
              os << printer.m_separator;
b3f73643c055 add separator support to PacketPrinter
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 887
diff changeset
  1037
            }
841
83a5df185d90 fix the list iteration logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 840
diff changeset
  1038
          current = item.next;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1039
        }
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1040
    }
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1041
  else
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1042
    {
840
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
  1043
      uint32_t head = m_head;
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
  1044
      uint32_t tail = m_tail;
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
  1045
      uint32_t current = head;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1046
      uint32_t offset = 0;
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1047
      while (current != 0xffff)
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1048
        {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1049
          struct PacketMetadata::SmallItem item;
848
10e989a2ed6e fix fragment printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 847
diff changeset
  1050
          uint32_t realSize = DoPrint (&item, current, data, offset, printer, os);
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1051
          offset -= realSize;
840
e473844a60c2 rename begin to head and end to tail
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 839
diff changeset
  1052
          if (current == tail)
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1053
            {
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1054
              break;
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1055
            }
895
b90ba0bcfd36 add separator support to backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 892
diff changeset
  1056
          if (item.prev != 0xffff)
b90ba0bcfd36 add separator support to backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 892
diff changeset
  1057
            {
b90ba0bcfd36 add separator support to backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 892
diff changeset
  1058
              os << printer.m_separator;
b90ba0bcfd36 add separator support to backward printing
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 892
diff changeset
  1059
            }
841
83a5df185d90 fix the list iteration logic
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 840
diff changeset
  1060
          current = item.prev;
837
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1061
        }
b73b63e84130 implement PacketHistory::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 836
diff changeset
  1062
    }
790
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
  1063
}
de06cb662828 keep track of the aggregation state
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 789
diff changeset
  1064
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1065
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1066
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1067
}; // namespace ns3
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1068
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1069
#include <stdarg.h>
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1070
#include <iostream>
795
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1071
#include <sstream>
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1072
#include "ns3/test.h"
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1073
#include "header.h"
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1074
#include "trailer.h"
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1075
#include "packet.h"
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1076
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1077
namespace ns3 {
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1078
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1079
template <int N>
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1080
class HistoryHeader : public Header
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1081
{
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
  1082
public:
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1083
  HistoryHeader ();
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1084
  bool IsOk (void) const;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1085
private:
795
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1086
  virtual std::string DoGetName (void) const;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1087
  virtual void PrintTo (std::ostream &os) const;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1088
  virtual uint32_t GetSerializedSize (void) const;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1089
  virtual void SerializeTo (Buffer::Iterator start) const;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1090
  virtual uint32_t DeserializeFrom (Buffer::Iterator start);
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
  bool m_ok;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1092
};
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1093
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1094
template <int N>
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
  1095
HistoryHeader<N>::HistoryHeader ()
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1096
  : m_ok (false)
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1097
{}
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1098
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1099
template <int N>
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1100
bool 
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1101
HistoryHeader<N>::IsOk (void) const
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1102
{
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1103
  return m_ok;
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1104
}
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1105
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1106
template <int N>
795
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1107
std::string 
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1108
HistoryHeader<N>::DoGetName (void) const
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1109
{
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1110
  std::ostringstream oss;
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1111
  oss << N;
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1112
  return oss.str ();
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1113
}
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1114
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1115
template <int N>
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1116
void 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1117
HistoryHeader<N>::PrintTo (std::ostream &os) const
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1118
{
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
  1119
  NS_ASSERT (false);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1120
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1121
template <int N>
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1122
uint32_t 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1123
HistoryHeader<N>::GetSerializedSize (void) const
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1124
{
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1125
  return N;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1126
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1127
template <int N>
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1128
void 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1129
HistoryHeader<N>::SerializeTo (Buffer::Iterator start) const
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1130
{
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1131
  start.WriteU8 (N, N);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1132
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1133
template <int N>
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1134
uint32_t
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1135
HistoryHeader<N>::DeserializeFrom (Buffer::Iterator start)
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1136
{
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
  1137
  m_ok = true;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1138
  for (int i = 0; i < N; i++)
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1139
    {
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1140
      if (start.ReadU8 () != N)
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1141
        {
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
  1142
          m_ok = false;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1143
        }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1144
    }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1145
  return N;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1146
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1147
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1148
template <int N>
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1149
class HistoryTrailer : public Trailer
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1150
{
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
  1151
public:
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1152
  HistoryTrailer ();
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1153
  bool IsOk (void) const;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1154
private:
795
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1155
  virtual std::string DoGetName (void) const;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1156
  virtual void PrintTo (std::ostream &os) const;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1157
  virtual uint32_t GetSerializedSize (void) const;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1158
  virtual void SerializeTo (Buffer::Iterator start) const;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1159
  virtual uint32_t DeserializeFrom (Buffer::Iterator start);
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
  1160
  bool m_ok;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1161
};
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1162
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1163
template <int N>
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
  1164
HistoryTrailer<N>::HistoryTrailer ()
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1165
  : m_ok (false)
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1166
{}
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1167
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1168
template <int N>
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1169
bool
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1170
HistoryTrailer<N>::IsOk (void) const
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1171
{
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1172
  return m_ok;
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1173
}
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1174
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1175
template <int N>
795
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1176
std::string 
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1177
HistoryTrailer<N>::DoGetName (void) const
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1178
{
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1179
  std::ostringstream oss;
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1180
  oss << N;
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1181
  return oss.str ();
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1182
}
cd108c9817d0 add Chunk::GetName and implement it
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 794
diff changeset
  1183
template <int N>
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1184
void 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1185
HistoryTrailer<N>::PrintTo (std::ostream &os) const
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1186
{
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
  1187
  NS_ASSERT (false);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1188
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1189
template <int N>
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1190
uint32_t 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1191
HistoryTrailer<N>::GetSerializedSize (void) const
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1192
{
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1193
  return N;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1194
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1195
template <int N>
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1196
void 
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1197
HistoryTrailer<N>::SerializeTo (Buffer::Iterator start) const
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1198
{
817
cb803cd166a3 new test and fix to make it pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 814
diff changeset
  1199
  start.Prev (N);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1200
  start.WriteU8 (N, N);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1201
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1202
template <int N>
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1203
uint32_t
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1204
HistoryTrailer<N>::DeserializeFrom (Buffer::Iterator start)
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1205
{
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
  1206
  m_ok = true;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1207
  start.Prev (N);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1208
  for (int i = 0; i < N; i++)
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1209
    {
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1210
      if (start.ReadU8 () != N)
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1211
        {
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
  1212
          m_ok = false;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1213
        }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1214
    }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1215
  return N;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1216
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1217
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1218
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1219
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1220
class PacketMetadataTest : public Test {
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1221
public:
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1222
  PacketMetadataTest ();
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1223
  virtual ~PacketMetadataTest ();
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1224
  bool CheckHistory (Packet p, char *file, int line, uint32_t n, ...);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1225
  virtual bool RunTests (void);
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
  1226
private:
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1227
  template <int N>
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1228
  void PrintHeader (std::ostream &os, uint32_t packetUid, uint32_t size, const HistoryHeader<N> *header);
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1229
  template <int N>
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1230
  void PrintTrailer (std::ostream &os, uint32_t packetUid, uint32_t size, const HistoryTrailer<N> *trailer);
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1231
  void PrintFragment (std::ostream &os,uint32_t packetUid,
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1232
                      uint32_t size,std::string & name, 
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1233
                      struct PacketPrinter::FragmentInformation info);
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1234
  void PrintDefault (std::ostream& os,uint32_t packetUid,
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1235
                     uint32_t size,std::string& name,
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1236
                     struct PacketPrinter::FragmentInformation info);
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1237
  void PrintPayload (std::ostream &os,uint32_t packetUid,
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1238
                     uint32_t size,
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1239
                     struct PacketPrinter::FragmentInformation info);
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1240
  template <int N>
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1241
  void RegisterHeader (void);
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1242
  template <int N>
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1243
  void RegisterTrailer (void);
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1244
  void CleanupPrints (void);
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1245
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1246
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1247
  bool m_headerError;
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1248
  bool m_trailerError;
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1249
  std::list<int> m_prints;
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1250
  PacketPrinter m_printer;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1251
};
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1252
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1253
PacketMetadataTest::PacketMetadataTest ()
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1254
  : Test ("PacketMetadata")
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
  1255
{
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1256
  m_printer.AddPayloadPrinter (MakeCallback (&PacketMetadataTest::PrintPayload, this));
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1257
  m_printer.AddDefaultPrinter (MakeCallback (&PacketMetadataTest::PrintDefault, this));
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
  1258
}
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1259
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1260
PacketMetadataTest::~PacketMetadataTest ()
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1261
{}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1262
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
  1263
template <int N>
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1264
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1265
PacketMetadataTest::RegisterHeader (void)
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
  1266
{
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1267
  static bool registered = false;
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1268
  if (!registered)
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1269
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1270
      m_printer.AddHeaderPrinter (MakeCallback (&PacketMetadataTest::PrintHeader<N>, this),
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1271
                                  MakeCallback (&PacketMetadataTest::PrintFragment, this));
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
  1272
      registered = true;
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1273
    }
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1274
}
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1275
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1276
template <int N>
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1277
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1278
PacketMetadataTest::RegisterTrailer (void)
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
  1279
{
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1280
  static bool registered = false;
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1281
  if (!registered)
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1282
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1283
      m_printer.AddTrailerPrinter (MakeCallback (&PacketMetadataTest::PrintTrailer<N>, this),
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1284
                                   MakeCallback (&PacketMetadataTest::PrintFragment, this));
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
  1285
      registered = true;
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1286
    }
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1287
}
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1288
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1289
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1290
template <int N>
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1291
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1292
PacketMetadataTest::PrintHeader (std::ostream &os, uint32_t packetUid, uint32_t size, 
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
  1293
                                const HistoryHeader<N> *header)
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1294
{
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1295
  if (!header->IsOk ())
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1296
    {
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1297
      m_headerError = true;
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1298
    }
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1299
  m_prints.push_back (N);
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1300
}
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1301
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1302
template <int N>
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1303
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1304
PacketMetadataTest::PrintTrailer (std::ostream &os, uint32_t packetUid, uint32_t size, 
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
  1305
                                 const HistoryTrailer<N> *trailer)
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1306
{
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1307
  if (!trailer->IsOk ())
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1308
    {
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1309
      m_trailerError = true;
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1310
    }
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1311
  m_prints.push_back (N);
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1312
}
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1313
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1314
PacketMetadataTest::PrintFragment (std::ostream &os,uint32_t packetUid,
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
  1315
                                  uint32_t size,std::string & name, 
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1316
                                  struct PacketPrinter::FragmentInformation info)
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1317
{
813
0001e4abcf7b test fragments
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 812
diff changeset
  1318
  m_prints.push_back (info.end - info.start);
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
  1319
}
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1320
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1321
PacketMetadataTest::PrintDefault (std::ostream& os,uint32_t packetUid,
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
  1322
                     uint32_t size,std::string& name,
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1323
                     struct PacketPrinter::FragmentInformation info)
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1324
{
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1325
  NS_ASSERT (false);
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1326
}
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1327
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1328
PacketMetadataTest::PrintPayload (std::ostream &os,uint32_t packetUid,
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
  1329
                                 uint32_t size,
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1330
                                 struct PacketPrinter::FragmentInformation info)
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1331
{
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1332
  m_prints.push_back (info.end - info.start);
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
  1333
}
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1334
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1335
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1336
void 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1337
PacketMetadataTest::CleanupPrints (void)
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
  1338
{
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1339
  m_prints.clear ();
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1340
}
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1341
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1342
bool 
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1343
PacketMetadataTest::CheckHistory (Packet p, char *file, int line, uint32_t n, ...)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1344
{
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
  1345
  m_headerError = false;
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1346
  m_trailerError = false;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1347
  va_list ap;
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
  1348
  p.Print (std::cerr, m_printer);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1349
  va_start (ap, n);
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
  1350
  if (m_headerError)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1351
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1352
      std::cout << "PacketMetadata header error. file=" << file 
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1353
                << ", line=" << line << std::endl;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1354
      return false;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1355
    }
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
  1356
  if (m_trailerError)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1357
    {
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1358
      std::cout << "PacketMetadata trailer error. file=" << file 
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1359
                << ", line=" << line << std::endl;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1360
      return false;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1361
    }
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
  1362
  if (n != m_prints.size ())
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1363
    {
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1364
      goto error;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1365
    }
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
  1366
  for (std::list<int>::iterator i = m_prints.begin (); 
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1367
       i != m_prints.end (); i++)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1368
    {
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1369
      int v = va_arg (ap, int);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1370
      if (v != *i)
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1371
        {
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1372
          va_end (ap);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1373
          goto error;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1374
        }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1375
    }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1376
  va_end (ap);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1377
  return true;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1378
 error:
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1379
  std::cout << "PacketMetadata error. file="<< file 
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1380
            << ", line=" << line << ", got:\"";
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
  1381
  for (std::list<int>::iterator i = m_prints.begin (); 
0190f1b49dc8 re-implement PacketHistory to use the PacketPrinter and work on ItemList::Print
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 795
diff changeset
  1382
       i != m_prints.end (); i++)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1383
    {
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1384
      std::cout << *i << ", ";
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1385
    }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1386
  std::cout << "\", expected: \"";
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1387
  va_start (ap, n);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1388
  for (uint32_t j = 0; j < n; j++)
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1389
    {
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1390
      int v = va_arg (ap, int);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1391
      std::cout << v << ", ";
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1392
    }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1393
  va_end (ap);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1394
  std::cout << "\"" << std::endl;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1395
  return false;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1396
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1397
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1398
#define ADD_HEADER(p, n)                        \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1399
  {                                             \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1400
    HistoryHeader<n> header;                    \
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
  1401
    RegisterHeader<n> ();                       \
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1402
    p.AddHeader (header);                       \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1403
  }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1404
#define ADD_TRAILER(p, n)                       \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1405
  {                                             \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1406
    HistoryTrailer<n> trailer;                  \
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
  1407
    RegisterTrailer<n> ();                      \
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1408
    p.AddTrailer (trailer);                     \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1409
  }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1410
#define REM_HEADER(p, n)                        \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1411
  {                                             \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1412
    HistoryHeader<n> header;                    \
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
  1413
    RegisterHeader<n> ();                       \
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1414
    p.RemoveHeader (header);                    \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1415
  }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1416
#define REM_TRAILER(p, n)                       \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1417
  {                                             \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1418
    HistoryTrailer<n> trailer;                  \
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
  1419
    RegisterTrailer<n> ();                      \
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1420
    p.RemoveTrailer (trailer);                  \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1421
  }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1422
#define CHECK_HISTORY(p, ...)                   \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1423
  {                                             \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1424
    if (!CheckHistory (p, __FILE__,             \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1425
                      __LINE__, __VA_ARGS__))   \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1426
      {                                         \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1427
        ok = false;                             \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1428
      }                                         \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1429
    CleanupPrints ();                           \
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1430
  }
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1431
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1432
bool
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1433
PacketMetadataTest::RunTests (void)
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1434
{
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1435
  bool ok = true;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1436
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1437
  PacketMetadata::Enable ();
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1438
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1439
  Packet p = Packet (0);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1440
  Packet p1 = Packet (0);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1441
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1442
  p = Packet (10);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1443
  ADD_TRAILER (p, 100);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1444
  CHECK_HISTORY (p, 2, 10, 100);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1445
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1446
  p = Packet (10);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1447
  ADD_HEADER (p, 1);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1448
  ADD_HEADER (p, 2);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1449
  ADD_HEADER (p, 3);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1450
  CHECK_HISTORY (p, 4, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1451
                 3, 2, 1, 10);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1452
  ADD_HEADER (p, 5);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1453
  CHECK_HISTORY (p, 5, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1454
                 5, 3, 2, 1, 10);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1455
  ADD_HEADER (p, 6);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1456
  CHECK_HISTORY (p, 6, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1457
                 6, 5, 3, 2, 1, 10);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1458
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1459
  p = Packet (10);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1460
  ADD_HEADER (p, 1);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1461
  ADD_HEADER (p, 2);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1462
  ADD_HEADER (p, 3);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1463
  REM_HEADER (p, 3);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1464
  CHECK_HISTORY (p, 3, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1465
                 2, 1, 10);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1466
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1467
  p = Packet (10);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1468
  ADD_HEADER (p, 1);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1469
  ADD_HEADER (p, 2);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1470
  ADD_HEADER (p, 3);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1471
  REM_HEADER (p, 3);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1472
  REM_HEADER (p, 2);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1473
  CHECK_HISTORY (p, 2, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1474
                 1, 10);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1475
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1476
  p = Packet (10);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1477
  ADD_HEADER (p, 1);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1478
  ADD_HEADER (p, 2);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1479
  ADD_HEADER (p, 3);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1480
  REM_HEADER (p, 3);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1481
  REM_HEADER (p, 2);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1482
  REM_HEADER (p, 1);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1483
  CHECK_HISTORY (p, 1, 10);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1484
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1485
  p = Packet (10);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1486
  ADD_HEADER (p, 1);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1487
  ADD_HEADER (p, 2);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1488
  ADD_HEADER (p, 3);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1489
  p1 = p;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1490
  REM_HEADER (p1, 3);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1491
  REM_HEADER (p1, 2);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1492
  REM_HEADER (p1, 1);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1493
  CHECK_HISTORY (p1, 1, 10);
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1494
  CHECK_HISTORY (p, 4, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1495
                 3, 2, 1, 10);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1496
  ADD_HEADER (p1, 1);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1497
  ADD_HEADER (p1, 2);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1498
  CHECK_HISTORY (p1, 3, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1499
                 2, 1, 10);
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1500
  CHECK_HISTORY (p, 4, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1501
                 3, 2, 1, 10);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1502
  ADD_HEADER (p, 3);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1503
  CHECK_HISTORY (p, 5, 
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1504
                 3, 3, 2, 1, 10);
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1505
  ADD_TRAILER (p, 4);
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1506
  CHECK_HISTORY (p, 6, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1507
                 3, 3, 2, 1, 10, 4);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1508
  ADD_TRAILER (p, 5);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1509
  CHECK_HISTORY (p, 7, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1510
                 3, 3, 2, 1, 10, 4, 5);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1511
  REM_HEADER (p, 3);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1512
  CHECK_HISTORY (p, 6, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1513
                 3, 2, 1, 10, 4, 5);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1514
  REM_TRAILER (p, 5);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1515
  CHECK_HISTORY (p, 5, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1516
                 3, 2, 1, 10, 4);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1517
  p1 = p;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1518
  REM_TRAILER (p, 4);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1519
  CHECK_HISTORY (p, 4, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1520
                 3, 2, 1, 10);
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1521
  CHECK_HISTORY (p1, 5, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1522
                 3, 2, 1, 10, 4);
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1523
  p1.RemoveAtStart (3);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1524
  CHECK_HISTORY (p1, 4, 
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1525
                 2, 1, 10, 4);
845
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
  1526
  p1.RemoveAtStart (1);
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
  1527
  CHECK_HISTORY (p1, 4, 
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
  1528
                 1, 1, 10, 4);
7abb0f867d8f implement PacketHistory::RemoveAtStart
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 844
diff changeset
  1529
  p1.RemoveAtStart (1);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1530
  CHECK_HISTORY (p1, 3, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1531
                 1, 10, 4);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1532
  p1.RemoveAtEnd (4);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1533
  CHECK_HISTORY (p1, 2, 
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1534
                 1, 10);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1535
  p1.RemoveAtStart (1);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1536
  CHECK_HISTORY (p1, 1, 10);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1537
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1538
  p = Packet (10);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1539
  ADD_HEADER (p, 8);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1540
  ADD_TRAILER (p, 8);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1541
  ADD_TRAILER (p, 8);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1542
  p.RemoveAtStart (8+10+8);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1543
  CHECK_HISTORY (p, 1, 8);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1544
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1545
  p = Packet (10);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1546
  ADD_HEADER (p, 10);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1547
  ADD_HEADER (p, 8);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1548
  ADD_TRAILER (p, 6);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1549
  ADD_TRAILER (p, 7);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1550
  ADD_TRAILER (p, 9);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1551
  p.RemoveAtStart (5);
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1552
  p.RemoveAtEnd (12);
814
af117fb6eb5d test payload
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 813
diff changeset
  1553
  CHECK_HISTORY (p, 5, 3, 10, 10, 6, 4);
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1554
817
cb803cd166a3 new test and fix to make it pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 814
diff changeset
  1555
  p = Packet (10);
cb803cd166a3 new test and fix to make it pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 814
diff changeset
  1556
  ADD_HEADER (p, 10);
cb803cd166a3 new test and fix to make it pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 814
diff changeset
  1557
  ADD_TRAILER (p, 6);
cb803cd166a3 new test and fix to make it pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 814
diff changeset
  1558
  p.RemoveAtEnd (18);
cb803cd166a3 new test and fix to make it pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 814
diff changeset
  1559
  ADD_TRAILER (p, 5);
cb803cd166a3 new test and fix to make it pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 814
diff changeset
  1560
  ADD_HEADER (p, 3);
cb803cd166a3 new test and fix to make it pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 814
diff changeset
  1561
  CHECK_HISTORY (p, 3, 3, 8, 5);
cb803cd166a3 new test and fix to make it pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 814
diff changeset
  1562
  p.RemoveAtStart (12);
cb803cd166a3 new test and fix to make it pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 814
diff changeset
  1563
  CHECK_HISTORY (p, 1, 4);
818
1c6df07b7644 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 817
diff changeset
  1564
  p.RemoveAtEnd (2);
1c6df07b7644 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 817
diff changeset
  1565
  CHECK_HISTORY (p, 1, 2);
1c6df07b7644 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 817
diff changeset
  1566
  ADD_HEADER (p, 10);
1c6df07b7644 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 817
diff changeset
  1567
  CHECK_HISTORY (p, 2, 10, 2);
1c6df07b7644 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 817
diff changeset
  1568
  p.RemoveAtEnd (5);
1c6df07b7644 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 817
diff changeset
  1569
  CHECK_HISTORY (p, 1, 7);
817
cb803cd166a3 new test and fix to make it pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 814
diff changeset
  1570
820
5f5eed583a17 add more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 818
diff changeset
  1571
  Packet p2 = Packet (0);
5f5eed583a17 add more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 818
diff changeset
  1572
  Packet p3 = Packet (0);
5f5eed583a17 add more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 818
diff changeset
  1573
5f5eed583a17 add more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 818
diff changeset
  1574
  p = Packet (40);
5f5eed583a17 add more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 818
diff changeset
  1575
  ADD_HEADER (p, 5);
5f5eed583a17 add more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 818
diff changeset
  1576
  ADD_HEADER (p, 8);
821
c5ebe0778031 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 820
diff changeset
  1577
  CHECK_HISTORY (p, 3, 8, 5, 40);
820
5f5eed583a17 add more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 818
diff changeset
  1578
  p1 = p.CreateFragment (0, 5);
5f5eed583a17 add more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 818
diff changeset
  1579
  p2 = p.CreateFragment (5, 5);
5f5eed583a17 add more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 818
diff changeset
  1580
  p3 = p.CreateFragment (10, 43);
5f5eed583a17 add more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 818
diff changeset
  1581
  CHECK_HISTORY (p1, 1, 5);
5f5eed583a17 add more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 818
diff changeset
  1582
  CHECK_HISTORY (p2, 2, 3, 2);
5f5eed583a17 add more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 818
diff changeset
  1583
  CHECK_HISTORY (p3, 2, 3, 40);
821
c5ebe0778031 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 820
diff changeset
  1584
  p1.AddAtEnd (p2);
c5ebe0778031 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 820
diff changeset
  1585
  CHECK_HISTORY (p1, 2, 8, 2);
c5ebe0778031 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 820
diff changeset
  1586
  CHECK_HISTORY (p2, 2, 3, 2);
c5ebe0778031 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 820
diff changeset
  1587
  p1.AddAtEnd (p3);
c5ebe0778031 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 820
diff changeset
  1588
  CHECK_HISTORY (p1, 3, 8, 5, 40);
c5ebe0778031 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 820
diff changeset
  1589
  CHECK_HISTORY (p2, 2, 3, 2);
c5ebe0778031 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 820
diff changeset
  1590
  CHECK_HISTORY (p3, 2, 3, 40);
825
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1591
  p1 = p.CreateFragment (0, 5);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1592
  CHECK_HISTORY (p1, 1, 5);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1593
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1594
  p3 = Packet (50);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1595
  ADD_HEADER (p3, 8);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1596
  CHECK_HISTORY (p3, 2, 8, 50);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1597
  CHECK_HISTORY (p1, 1, 5);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1598
  p1.AddAtEnd (p3);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1599
  CHECK_HISTORY (p1, 3, 5, 8, 50);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1600
  ADD_HEADER (p1, 5);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1601
  CHECK_HISTORY (p1, 4, 5, 5, 8, 50);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1602
  ADD_TRAILER (p1, 2);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1603
  CHECK_HISTORY (p1, 5, 5, 5, 8, 50, 2);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1604
  REM_HEADER (p1, 5);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1605
  CHECK_HISTORY (p1, 4, 5, 8, 50, 2);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1606
  p1.RemoveAtEnd (60);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1607
  CHECK_HISTORY (p1, 1, 5);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1608
  p1.AddAtEnd (p2);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1609
  CHECK_HISTORY (p1, 2, 8, 2);
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1610
  CHECK_HISTORY (p2, 2, 3, 2);
828
5439722f60ec more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 825
diff changeset
  1611
5439722f60ec more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 825
diff changeset
  1612
  p3 = Packet (40);
5439722f60ec more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 825
diff changeset
  1613
  ADD_HEADER (p3, 5);
5439722f60ec more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 825
diff changeset
  1614
  ADD_HEADER (p3, 5);
5439722f60ec more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 825
diff changeset
  1615
  CHECK_HISTORY (p3, 3, 5, 5, 40);
5439722f60ec more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 825
diff changeset
  1616
  p1 = p3.CreateFragment (0, 5);
5439722f60ec more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 825
diff changeset
  1617
  p2 = p3.CreateFragment (5, 5);
5439722f60ec more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 825
diff changeset
  1618
  CHECK_HISTORY (p1, 1, 5);
5439722f60ec more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 825
diff changeset
  1619
  CHECK_HISTORY (p2, 1, 5);
5439722f60ec more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 825
diff changeset
  1620
  p1.AddAtEnd (p2);
5439722f60ec more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 825
diff changeset
  1621
  CHECK_HISTORY (p1, 2, 5, 5);
829
6f869667686f more tests, initial fix.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 828
diff changeset
  1622
6f869667686f more tests, initial fix.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 828
diff changeset
  1623
  p = Packet (0);
6f869667686f more tests, initial fix.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 828
diff changeset
  1624
  CHECK_HISTORY (p, 0);
6f869667686f more tests, initial fix.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 828
diff changeset
  1625
6f869667686f more tests, initial fix.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 828
diff changeset
  1626
  p3 = Packet (0);
6f869667686f more tests, initial fix.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 828
diff changeset
  1627
  ADD_HEADER (p3, 5);
6f869667686f more tests, initial fix.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 828
diff changeset
  1628
  ADD_HEADER (p3, 5);
6f869667686f more tests, initial fix.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 828
diff changeset
  1629
  CHECK_HISTORY (p3, 2, 5, 5);
6f869667686f more tests, initial fix.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 828
diff changeset
  1630
  p1 = p3.CreateFragment (0, 4);
6f869667686f more tests, initial fix.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 828
diff changeset
  1631
  p2 = p3.CreateFragment (9, 1);
6f869667686f more tests, initial fix.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 828
diff changeset
  1632
  CHECK_HISTORY (p1, 1, 4);
6f869667686f more tests, initial fix.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 828
diff changeset
  1633
  CHECK_HISTORY (p2, 1, 1);
6f869667686f more tests, initial fix.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 828
diff changeset
  1634
  p1.AddAtEnd (p2);
6f869667686f more tests, initial fix.
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 828
diff changeset
  1635
  CHECK_HISTORY (p1, 2, 4, 1);
884
f3836277079e fix uleb128 reading bug
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 883
diff changeset
  1636
f3836277079e fix uleb128 reading bug
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 883
diff changeset
  1637
f3836277079e fix uleb128 reading bug
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 883
diff changeset
  1638
  p = Packet (2000);
f3836277079e fix uleb128 reading bug
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 883
diff changeset
  1639
  CHECK_HISTORY (p, 1, 2000);
825
48b651e0c3c7 more tests
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 822
diff changeset
  1640
  
817
cb803cd166a3 new test and fix to make it pass
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 814
diff changeset
  1641
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1642
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1643
  return ok;
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1644
}
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1645
883
4d2da35c09b0 PacketHistory -> PacketMetadata
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents: 882
diff changeset
  1646
static PacketMetadataTest g_packetHistoryTest;
789
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1647
1e19322e9012 merge unfinished packet history code
Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
parents:
diff changeset
  1648
}//namespace ns3