File: | /tmp/asd-nat/home/nat/Work/ns-3-dev-git/build/../src/network/model/buffer.cc |
Location: | line 683, column 3 |
Description: | Value stored to 'p' is never read |
1 | /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ |
2 | /* |
3 | * Copyright (c) 2005,2006,2007 INRIA |
4 | * |
5 | * This program is free software; you can redistribute it and/or modify |
6 | * it under the terms of the GNU General Public License version 2 as |
7 | * published by the Free Software Foundation; |
8 | * |
9 | * This program is distributed in the hope that it will be useful, |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
12 | * GNU General Public License for more details. |
13 | * |
14 | * You should have received a copy of the GNU General Public License |
15 | * along with this program; if not, write to the Free Software |
16 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
17 | * |
18 | * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr> |
19 | */ |
20 | #include "buffer.h" |
21 | #include "ns3/assert.h" |
22 | #include "ns3/log.h" |
23 | |
24 | #define LOG_INTERNAL_STATE(y)do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std ::clog << g_log.Name () << ":" << __FUNCTION__ << "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL )) { std::clog << "[" << g_log.GetLevelLabel (ns3 ::LOG_LOGIC) << "] "; }; std::clog << y << "start=" <<m_start<<", end="<<m_end<<", zero start=" <<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd <<", count="<<m_data->m_count<<", size=" <<m_data->m_size<< ", dirty start="<<m_data ->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd << std::endl; } } while (false) \ |
25 | NS_LOG_LOGIC (y << "start="<<m_start<<", end="<<m_end<<", zero start="<<m_zeroAreaStart<< \do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std ::clog << g_log.Name () << ":" << __FUNCTION__ << "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL )) { std::clog << "[" << g_log.GetLevelLabel (ns3 ::LOG_LOGIC) << "] "; }; std::clog << y << "start=" <<m_start<<", end="<<m_end<<", zero start=" <<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd <<", count="<<m_data->m_count<<", size=" <<m_data->m_size<< ", dirty start="<<m_data ->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd << std::endl; } } while (false) |
26 | ", zero end="<<m_zeroAreaEnd<<", count="<<m_data->m_count<<", size="<<m_data->m_size<< \do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std ::clog << g_log.Name () << ":" << __FUNCTION__ << "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL )) { std::clog << "[" << g_log.GetLevelLabel (ns3 ::LOG_LOGIC) << "] "; }; std::clog << y << "start=" <<m_start<<", end="<<m_end<<", zero start=" <<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd <<", count="<<m_data->m_count<<", size=" <<m_data->m_size<< ", dirty start="<<m_data ->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd << std::endl; } } while (false) |
27 | ", dirty start="<<m_data->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd)do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std ::clog << g_log.Name () << ":" << __FUNCTION__ << "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL )) { std::clog << "[" << g_log.GetLevelLabel (ns3 ::LOG_LOGIC) << "] "; }; std::clog << y << "start=" <<m_start<<", end="<<m_end<<", zero start=" <<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd <<", count="<<m_data->m_count<<", size=" <<m_data->m_size<< ", dirty start="<<m_data ->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd << std::endl; } } while (false) |
28 | |
29 | namespace { |
30 | |
31 | /** |
32 | * \ingroup packet |
33 | * \brief Zero-filled buffer. |
34 | */ |
35 | static struct Zeroes |
36 | { |
37 | Zeroes () |
38 | : size (1000) |
39 | { |
40 | memset (buffer, 0, size); |
41 | } |
42 | char buffer[1000]; //!< buffer containing zero values |
43 | const uint32_t size; //!< buffer size |
44 | } g_zeroes; //!< Zero-filled buffer |
45 | |
46 | } |
47 | |
48 | namespace ns3 { |
49 | |
50 | NS_LOG_COMPONENT_DEFINE ("Buffer")static ns3::LogComponent g_log = ns3::LogComponent ("Buffer", "../src/network/model/buffer.cc"); |
51 | |
52 | |
53 | uint32_t Buffer::g_recommendedStart = 0; |
54 | #ifdef BUFFER_FREE_LIST1 |
55 | /* The following macros are pretty evil but they are needed to allow us to |
56 | * keep track of 3 possible states for the g_freeList variable: |
57 | * - uninitialized means that no one has created a buffer yet |
58 | * so no one has created the associated free list (it is created |
59 | * on-demand when the first buffer is created) |
60 | * - initialized means that the free list exists and is valid |
61 | * - destroyed means that the static destructors of this compilation unit |
62 | * have run so, the free list has been cleared from its content |
63 | * The key is that in destroyed state, we are careful not re-create it |
64 | * which is a typical weakness of lazy evaluation schemes which use |
65 | * '0' as a special value to indicate both un-initialized and destroyed. |
66 | * Note that it is important to use '0' as the marker for un-initialized state |
67 | * because the variable holding this state information is initialized to zero |
68 | * which the compiler assigns to zero-memory which is initialized to _zero_ |
69 | * before the constructors run so this ensures perfect handling of crazy |
70 | * constructor orderings. |
71 | */ |
72 | #define MAGIC_DESTROYED(~(long) 0) (~(long) 0) |
73 | #define IS_UNINITIALIZED(x)(x == (Buffer::FreeList*)0) (x == (Buffer::FreeList*)0) |
74 | #define IS_DESTROYED(x)(x == (Buffer::FreeList*)(~(long) 0)) (x == (Buffer::FreeList*)MAGIC_DESTROYED(~(long) 0)) |
75 | #define IS_INITIALIZED(x)(!(x == (Buffer::FreeList*)0) && !(x == (Buffer::FreeList *)(~(long) 0))) (!IS_UNINITIALIZED (x)(x == (Buffer::FreeList*)0) && !IS_DESTROYED (x)(x == (Buffer::FreeList*)(~(long) 0))) |
76 | #define DESTROYED((Buffer::FreeList*)(~(long) 0)) ((Buffer::FreeList*)MAGIC_DESTROYED(~(long) 0)) |
77 | #define UNINITIALIZED((Buffer::FreeList*)0) ((Buffer::FreeList*)0) |
78 | uint32_t Buffer::g_maxSize = 0; |
79 | Buffer::FreeList *Buffer::g_freeList = 0; |
80 | struct Buffer::LocalStaticDestructor Buffer::g_localStaticDestructor; |
81 | |
82 | Buffer::LocalStaticDestructor::~LocalStaticDestructor(void) |
83 | { |
84 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
85 | if (IS_INITIALIZED (g_freeList)(!(g_freeList == (Buffer::FreeList*)0) && !(g_freeList == (Buffer::FreeList*)(~(long) 0)))) |
86 | { |
87 | for (Buffer::FreeList::iterator i = g_freeList->begin (); |
88 | i != g_freeList->end (); i++) |
89 | { |
90 | Buffer::Deallocate (*i); |
91 | } |
92 | delete g_freeList; |
93 | g_freeList = DESTROYED((Buffer::FreeList*)(~(long) 0)); |
94 | } |
95 | } |
96 | |
97 | void |
98 | Buffer::Recycle (struct Buffer::Data *data) |
99 | { |
100 | NS_LOG_FUNCTION (data)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << data; std::clog << ")" << std::endl; } } while ( false); |
101 | NS_ASSERT (data->m_count == 0)do { if (!(data->m_count == 0)) { std::cerr << "assert failed. cond=\"" << "data->m_count == 0" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 101 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
102 | NS_ASSERT (!IS_UNINITIALIZED (g_freeList))do { if (!(!(g_freeList == (Buffer::FreeList*)0))) { std::cerr << "assert failed. cond=\"" << "!IS_UNINITIALIZED (g_freeList)" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 102 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
103 | g_maxSize = std::max (g_maxSize, data->m_size); |
104 | /* feed into free list */ |
105 | if (data->m_size < g_maxSize || |
106 | IS_DESTROYED (g_freeList)(g_freeList == (Buffer::FreeList*)(~(long) 0)) || |
107 | g_freeList->size () > 1000) |
108 | { |
109 | Buffer::Deallocate (data); |
110 | } |
111 | else |
112 | { |
113 | NS_ASSERT (IS_INITIALIZED (g_freeList))do { if (!((!(g_freeList == (Buffer::FreeList*)0) && ! (g_freeList == (Buffer::FreeList*)(~(long) 0))))) { std::cerr << "assert failed. cond=\"" << "IS_INITIALIZED (g_freeList)" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 113 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
114 | g_freeList->push_back (data); |
115 | } |
116 | } |
117 | |
118 | Buffer::Data * |
119 | Buffer::Create (uint32_t dataSize) |
120 | { |
121 | NS_LOG_FUNCTION (dataSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << dataSize; std::clog << ")" << std::endl; } } while (false); |
122 | /* try to find a buffer correctly sized. */ |
123 | if (IS_UNINITIALIZED (g_freeList)(g_freeList == (Buffer::FreeList*)0)) |
124 | { |
125 | g_freeList = new Buffer::FreeList (); |
126 | } |
127 | else if (IS_INITIALIZED (g_freeList)(!(g_freeList == (Buffer::FreeList*)0) && !(g_freeList == (Buffer::FreeList*)(~(long) 0)))) |
128 | { |
129 | while (!g_freeList->empty ()) |
130 | { |
131 | struct Buffer::Data *data = g_freeList->back (); |
132 | g_freeList->pop_back (); |
133 | if (data->m_size >= dataSize) |
134 | { |
135 | data->m_count = 1; |
136 | return data; |
137 | } |
138 | Buffer::Deallocate (data); |
139 | } |
140 | } |
141 | struct Buffer::Data *data = Buffer::Allocate (dataSize); |
142 | NS_ASSERT (data->m_count == 1)do { if (!(data->m_count == 1)) { std::cerr << "assert failed. cond=\"" << "data->m_count == 1" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 142 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
143 | return data; |
144 | } |
145 | #else /* BUFFER_FREE_LIST */ |
146 | void |
147 | Buffer::Recycle (struct Buffer::Data *data) |
148 | { |
149 | NS_LOG_FUNCTION (data)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << data; std::clog << ")" << std::endl; } } while ( false); |
150 | NS_ASSERT (data->m_count == 0)do { if (!(data->m_count == 0)) { std::cerr << "assert failed. cond=\"" << "data->m_count == 0" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 150 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
151 | Deallocate (data); |
152 | } |
153 | |
154 | Buffer::Data * |
155 | Buffer::Create (uint32_t size) |
156 | { |
157 | NS_LOG_FUNCTION (size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << size; std::clog << ")" << std::endl; } } while ( false); |
158 | return Allocate (size); |
159 | } |
160 | #endif /* BUFFER_FREE_LIST */ |
161 | |
162 | struct Buffer::Data * |
163 | Buffer::Allocate (uint32_t reqSize) |
164 | { |
165 | NS_LOG_FUNCTION (reqSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << reqSize; std::clog << ")" << std::endl; } } while (false); |
166 | if (reqSize == 0) |
167 | { |
168 | reqSize = 1; |
169 | } |
170 | NS_ASSERT (reqSize >= 1)do { if (!(reqSize >= 1)) { std::cerr << "assert failed. cond=\"" << "reqSize >= 1" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 170 << std::endl; ::ns3::FatalImpl::FlushStreams (); if (true) std::terminate (); } while (false); } } while ( false); |
171 | uint32_t size = reqSize - 1 + sizeof (struct Buffer::Data); |
172 | uint8_t *b = new uint8_t [size]; |
173 | struct Buffer::Data *data = reinterpret_cast<struct Buffer::Data*>(b); |
174 | data->m_size = reqSize; |
175 | data->m_count = 1; |
176 | return data; |
177 | } |
178 | |
179 | void |
180 | Buffer::Deallocate (struct Buffer::Data *data) |
181 | { |
182 | NS_LOG_FUNCTION (data)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << data; std::clog << ")" << std::endl; } } while ( false); |
183 | NS_ASSERT (data->m_count == 0)do { if (!(data->m_count == 0)) { std::cerr << "assert failed. cond=\"" << "data->m_count == 0" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 183 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
184 | uint8_t *buf = reinterpret_cast<uint8_t *> (data); |
185 | delete [] buf; |
186 | } |
187 | |
188 | Buffer::Buffer () |
189 | { |
190 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
191 | Initialize (0); |
192 | } |
193 | |
194 | Buffer::Buffer (uint32_t dataSize) |
195 | { |
196 | NS_LOG_FUNCTION (this << dataSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << dataSize; std::clog << ")" << std:: endl; } } while (false); |
197 | Initialize (dataSize); |
198 | } |
199 | |
200 | Buffer::Buffer (uint32_t dataSize, bool initialize) |
201 | { |
202 | NS_LOG_FUNCTION (this << dataSize << initialize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << dataSize << initialize; std::clog << ")" << std::endl; } } while (false); |
203 | if (initialize == true) |
204 | { |
205 | Initialize (dataSize); |
206 | } |
207 | } |
208 | |
209 | bool |
210 | Buffer::CheckInternalState (void) const |
211 | { |
212 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
213 | #if 0 |
214 | // If you want to modify any code in this file, enable this checking code. |
215 | // Otherwise, there is not much point is enabling it because the |
216 | // current implementation has been fairly seriously tested and the cost |
217 | // of this constant checking is pretty high, even for a debug build. |
218 | bool offsetsOk = |
219 | m_start <= m_zeroAreaStart && |
220 | m_zeroAreaStart <= m_zeroAreaEnd && |
221 | m_zeroAreaEnd <= m_end; |
222 | bool dirtyOk = |
223 | m_start >= m_data->m_dirtyStart && |
224 | m_end <= m_data->m_dirtyEnd; |
225 | bool internalSizeOk = m_end - (m_zeroAreaEnd - m_zeroAreaStart) <= m_data->m_size && |
226 | m_start <= m_data->m_size && |
227 | m_zeroAreaStart <= m_data->m_size; |
228 | |
229 | bool ok = m_data->m_count > 0 && offsetsOk && dirtyOk && internalSizeOk; |
230 | if (!ok) |
231 | { |
232 | LOG_INTERNAL_STATE ("check " << this <<do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std ::clog << g_log.Name () << ":" << __FUNCTION__ << "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL )) { std::clog << "[" << g_log.GetLevelLabel (ns3 ::LOG_LOGIC) << "] "; }; std::clog << "check " << this << ", " << (offsetsOk ? "true" : "false") << ", " << (dirtyOk ? "true" : "false") << ", " << (internalSizeOk ? "true" : "false") << " " << "start=" <<m_start<<", end="<<m_end<<", zero start=" <<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd <<", count="<<m_data->m_count<<", size=" <<m_data->m_size<< ", dirty start="<<m_data ->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd << std::endl; } } while (false) |
233 | ", " << (offsetsOk ? "true" : "false") <<do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std ::clog << g_log.Name () << ":" << __FUNCTION__ << "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL )) { std::clog << "[" << g_log.GetLevelLabel (ns3 ::LOG_LOGIC) << "] "; }; std::clog << "check " << this << ", " << (offsetsOk ? "true" : "false") << ", " << (dirtyOk ? "true" : "false") << ", " << (internalSizeOk ? "true" : "false") << " " << "start=" <<m_start<<", end="<<m_end<<", zero start=" <<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd <<", count="<<m_data->m_count<<", size=" <<m_data->m_size<< ", dirty start="<<m_data ->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd << std::endl; } } while (false) |
234 | ", " << (dirtyOk ? "true" : "false") <<do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std ::clog << g_log.Name () << ":" << __FUNCTION__ << "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL )) { std::clog << "[" << g_log.GetLevelLabel (ns3 ::LOG_LOGIC) << "] "; }; std::clog << "check " << this << ", " << (offsetsOk ? "true" : "false") << ", " << (dirtyOk ? "true" : "false") << ", " << (internalSizeOk ? "true" : "false") << " " << "start=" <<m_start<<", end="<<m_end<<", zero start=" <<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd <<", count="<<m_data->m_count<<", size=" <<m_data->m_size<< ", dirty start="<<m_data ->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd << std::endl; } } while (false) |
235 | ", " << (internalSizeOk ? "true" : "false") << " ")do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std ::clog << g_log.Name () << ":" << __FUNCTION__ << "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL )) { std::clog << "[" << g_log.GetLevelLabel (ns3 ::LOG_LOGIC) << "] "; }; std::clog << "check " << this << ", " << (offsetsOk ? "true" : "false") << ", " << (dirtyOk ? "true" : "false") << ", " << (internalSizeOk ? "true" : "false") << " " << "start=" <<m_start<<", end="<<m_end<<", zero start=" <<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd <<", count="<<m_data->m_count<<", size=" <<m_data->m_size<< ", dirty start="<<m_data ->m_dirtyStart<<", dirty end="<<m_data->m_dirtyEnd << std::endl; } } while (false); |
236 | } |
237 | return ok; |
238 | #else |
239 | return true; |
240 | #endif |
241 | } |
242 | |
243 | void |
244 | Buffer::Initialize (uint32_t zeroSize) |
245 | { |
246 | NS_LOG_FUNCTION (this << zeroSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << zeroSize; std::clog << ")" << std:: endl; } } while (false); |
247 | m_data = Buffer::Create (0); |
248 | m_start = std::min (m_data->m_size, g_recommendedStart); |
249 | m_maxZeroAreaStart = m_start; |
250 | m_zeroAreaStart = m_start; |
251 | m_zeroAreaEnd = m_zeroAreaStart + zeroSize; |
252 | m_end = m_zeroAreaEnd; |
253 | m_data->m_dirtyStart = m_start; |
254 | m_data->m_dirtyEnd = m_end; |
255 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 255 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
256 | } |
257 | |
258 | Buffer & |
259 | Buffer::operator = (Buffer const&o) |
260 | { |
261 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 261 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
262 | if (m_data != o.m_data) |
263 | { |
264 | // not assignment to self. |
265 | m_data->m_count--; |
266 | if (m_data->m_count == 0) |
267 | { |
268 | Recycle (m_data); |
269 | } |
270 | m_data = o.m_data; |
271 | m_data->m_count++; |
272 | } |
273 | g_recommendedStart = std::max (g_recommendedStart, m_maxZeroAreaStart); |
274 | m_maxZeroAreaStart = o.m_maxZeroAreaStart; |
275 | m_zeroAreaStart = o.m_zeroAreaStart; |
276 | m_zeroAreaEnd = o.m_zeroAreaEnd; |
277 | m_start = o.m_start; |
278 | m_end = o.m_end; |
279 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 279 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
280 | return *this; |
281 | } |
282 | |
283 | Buffer::~Buffer () |
284 | { |
285 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
286 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 286 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
287 | g_recommendedStart = std::max (g_recommendedStart, m_maxZeroAreaStart); |
288 | m_data->m_count--; |
289 | if (m_data->m_count == 0) |
290 | { |
291 | Recycle (m_data); |
292 | } |
293 | } |
294 | |
295 | uint32_t |
296 | Buffer::GetInternalSize (void) const |
297 | { |
298 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
299 | return m_zeroAreaStart - m_start + m_end - m_zeroAreaEnd; |
300 | } |
301 | uint32_t |
302 | Buffer::GetInternalEnd (void) const |
303 | { |
304 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
305 | return m_end - (m_zeroAreaEnd - m_zeroAreaStart); |
306 | } |
307 | |
308 | void |
309 | Buffer::AddAtStart (uint32_t start) |
310 | { |
311 | NS_LOG_FUNCTION (this << start)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << start; std::clog << ")" << std::endl ; } } while (false); |
312 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 312 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
313 | bool isDirty = m_data->m_count > 1 && m_start > m_data->m_dirtyStart; |
314 | if (m_start >= start && !isDirty) |
315 | { |
316 | /* enough space in the buffer and not dirty. |
317 | * To add: |..| |
318 | * Before: |*****---------***| |
319 | * After: |***..---------***| |
320 | */ |
321 | NS_ASSERT (m_data->m_count == 1 || m_start == m_data->m_dirtyStart)do { if (!(m_data->m_count == 1 || m_start == m_data->m_dirtyStart )) { std::cerr << "assert failed. cond=\"" << "m_data->m_count == 1 || m_start == m_data->m_dirtyStart" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 321 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
322 | m_start -= start; |
323 | // update dirty area |
324 | m_data->m_dirtyStart = m_start; |
325 | } |
326 | else |
327 | { |
328 | uint32_t newSize = GetInternalSize () + start; |
329 | struct Buffer::Data *newData = Buffer::Create (newSize); |
330 | memcpy (newData->m_data + start, m_data->m_data + m_start, GetInternalSize ()); |
331 | m_data->m_count--; |
332 | if (m_data->m_count == 0) |
333 | { |
334 | Buffer::Recycle (m_data); |
335 | } |
336 | m_data = newData; |
337 | |
338 | int32_t delta = start - m_start; |
339 | m_start += delta; |
340 | m_zeroAreaStart += delta; |
341 | m_zeroAreaEnd += delta; |
342 | m_end += delta; |
343 | m_start -= start; |
344 | |
345 | // update dirty area |
346 | m_data->m_dirtyStart = m_start; |
347 | m_data->m_dirtyEnd = m_end; |
348 | } |
349 | m_maxZeroAreaStart = std::max (m_maxZeroAreaStart, m_zeroAreaStart); |
350 | LOG_INTERNAL_STATE ("add start=" << start << ", ")do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std ::clog << g_log.Name () << ":" << __FUNCTION__ << "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL )) { std::clog << "[" << g_log.GetLevelLabel (ns3 ::LOG_LOGIC) << "] "; }; std::clog << "add start=" << start << ", " << "start="<<m_start <<", end="<<m_end<<", zero start="<<m_zeroAreaStart << ", zero end="<<m_zeroAreaEnd<<", count=" <<m_data->m_count<<", size="<<m_data-> m_size<< ", dirty start="<<m_data->m_dirtyStart <<", dirty end="<<m_data->m_dirtyEnd << std ::endl; } } while (false); |
351 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 351 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
352 | } |
353 | void |
354 | Buffer::AddAtEnd (uint32_t end) |
355 | { |
356 | NS_LOG_FUNCTION (this << end)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << end; std::clog << ")" << std::endl ; } } while (false); |
357 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 357 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
358 | bool isDirty = m_data->m_count > 1 && m_end < m_data->m_dirtyEnd; |
359 | if (GetInternalEnd () + end <= m_data->m_size && !isDirty) |
360 | { |
361 | /* enough space in buffer and not dirty |
362 | * Add: |...| |
363 | * Before: |**----*****| |
364 | * After: |**----...**| |
365 | */ |
366 | NS_ASSERT (m_data->m_count == 1 || m_end == m_data->m_dirtyEnd)do { if (!(m_data->m_count == 1 || m_end == m_data->m_dirtyEnd )) { std::cerr << "assert failed. cond=\"" << "m_data->m_count == 1 || m_end == m_data->m_dirtyEnd" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 366 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
367 | m_end += end; |
368 | // update dirty area. |
369 | m_data->m_dirtyEnd = m_end; |
370 | } |
371 | else |
372 | { |
373 | uint32_t newSize = GetInternalSize () + end; |
374 | struct Buffer::Data *newData = Buffer::Create (newSize); |
375 | memcpy (newData->m_data, m_data->m_data + m_start, GetInternalSize ()); |
376 | m_data->m_count--; |
377 | if (m_data->m_count == 0) |
378 | { |
379 | Buffer::Recycle (m_data); |
380 | } |
381 | m_data = newData; |
382 | |
383 | int32_t delta = -m_start; |
384 | m_zeroAreaStart += delta; |
385 | m_zeroAreaEnd += delta; |
386 | m_end += delta; |
387 | m_start += delta; |
388 | m_end += end; |
389 | |
390 | // update dirty area |
391 | m_data->m_dirtyStart = m_start; |
392 | m_data->m_dirtyEnd = m_end; |
393 | } |
394 | m_maxZeroAreaStart = std::max (m_maxZeroAreaStart, m_zeroAreaStart); |
395 | LOG_INTERNAL_STATE ("add end=" << end << ", ")do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std ::clog << g_log.Name () << ":" << __FUNCTION__ << "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL )) { std::clog << "[" << g_log.GetLevelLabel (ns3 ::LOG_LOGIC) << "] "; }; std::clog << "add end=" << end << ", " << "start="<<m_start<<", end=" <<m_end<<", zero start="<<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd<<", count="<< m_data->m_count<<", size="<<m_data->m_size<< ", dirty start="<<m_data->m_dirtyStart<<", dirty end=" <<m_data->m_dirtyEnd << std::endl; } } while ( false); |
396 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 396 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
397 | } |
398 | |
399 | void |
400 | Buffer::AddAtEnd (const Buffer &o) |
401 | { |
402 | NS_LOG_FUNCTION (this << &o)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << &o; std::clog << ")" << std::endl ; } } while (false); |
403 | if (m_data->m_count == 1 && |
404 | m_end == m_zeroAreaEnd && |
405 | m_end == m_data->m_dirtyEnd && |
406 | o.m_start == o.m_zeroAreaStart && |
407 | o.m_zeroAreaEnd - o.m_zeroAreaStart > 0) |
408 | { |
409 | /** |
410 | * This is an optimization which kicks in when |
411 | * we attempt to aggregate two buffers which contain |
412 | * adjacent zero areas. |
413 | */ |
414 | uint32_t zeroSize = o.m_zeroAreaEnd - o.m_zeroAreaStart; |
415 | m_zeroAreaEnd += zeroSize; |
416 | m_end = m_zeroAreaEnd; |
417 | m_data->m_dirtyEnd = m_zeroAreaEnd; |
418 | uint32_t endData = o.m_end - o.m_zeroAreaEnd; |
419 | AddAtEnd (endData); |
420 | Buffer::Iterator dst = End (); |
421 | dst.Prev (endData); |
422 | Buffer::Iterator src = o.End (); |
423 | src.Prev (endData); |
424 | dst.Write (src, o.End ()); |
425 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 425 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
426 | return; |
427 | } |
428 | |
429 | Buffer dst = CreateFullCopy (); |
430 | Buffer src = o.CreateFullCopy (); |
431 | |
432 | dst.AddAtEnd (src.GetSize ()); |
433 | Buffer::Iterator destStart = dst.End (); |
434 | destStart.Prev (src.GetSize ()); |
435 | destStart.Write (src.Begin (), src.End ()); |
436 | *this = dst; |
437 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 437 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
438 | } |
439 | |
440 | void |
441 | Buffer::RemoveAtStart (uint32_t start) |
442 | { |
443 | NS_LOG_FUNCTION (this << start)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << start; std::clog << ")" << std::endl ; } } while (false); |
444 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 444 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
445 | uint32_t newStart = m_start + start; |
446 | if (newStart <= m_zeroAreaStart) |
447 | { |
448 | /* only remove start of buffer |
449 | */ |
450 | m_start = newStart; |
451 | } |
452 | else if (newStart <= m_zeroAreaEnd) |
453 | { |
454 | /* remove start of buffer _and_ start of zero area |
455 | */ |
456 | uint32_t delta = newStart - m_zeroAreaStart; |
457 | m_start = m_zeroAreaStart; |
458 | m_zeroAreaEnd -= delta; |
459 | m_end -= delta; |
460 | } |
461 | else if (newStart <= m_end) |
462 | { |
463 | /* remove start of buffer, complete zero area, and part |
464 | * of end of buffer |
465 | */ |
466 | NS_ASSERT (m_end >= start)do { if (!(m_end >= start)) { std::cerr << "assert failed. cond=\"" << "m_end >= start" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 466 << std::endl; ::ns3::FatalImpl:: FlushStreams (); if (true) std::terminate (); } while (false) ; } } while (false); |
467 | uint32_t zeroSize = m_zeroAreaEnd - m_zeroAreaStart; |
468 | m_start = newStart - zeroSize; |
469 | m_end -= zeroSize; |
470 | m_zeroAreaStart = m_start; |
471 | m_zeroAreaEnd = m_start; |
472 | } |
473 | else |
474 | { |
475 | /* remove all buffer */ |
476 | m_end -= m_zeroAreaEnd - m_zeroAreaStart; |
477 | m_start = m_end; |
478 | m_zeroAreaEnd = m_end; |
479 | m_zeroAreaStart = m_end; |
480 | } |
481 | m_maxZeroAreaStart = std::max (m_maxZeroAreaStart, m_zeroAreaStart); |
482 | LOG_INTERNAL_STATE ("rem start=" << start << ", ")do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std ::clog << g_log.Name () << ":" << __FUNCTION__ << "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL )) { std::clog << "[" << g_log.GetLevelLabel (ns3 ::LOG_LOGIC) << "] "; }; std::clog << "rem start=" << start << ", " << "start="<<m_start <<", end="<<m_end<<", zero start="<<m_zeroAreaStart << ", zero end="<<m_zeroAreaEnd<<", count=" <<m_data->m_count<<", size="<<m_data-> m_size<< ", dirty start="<<m_data->m_dirtyStart <<", dirty end="<<m_data->m_dirtyEnd << std ::endl; } } while (false); |
483 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 483 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
484 | } |
485 | void |
486 | Buffer::RemoveAtEnd (uint32_t end) |
487 | { |
488 | NS_LOG_FUNCTION (this << end)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << end; std::clog << ")" << std::endl ; } } while (false); |
489 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 489 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
490 | uint32_t newEnd = m_end - std::min (end, m_end - m_start); |
491 | if (newEnd > m_zeroAreaEnd) |
492 | { |
493 | /* remove part of end of buffer */ |
494 | m_end = newEnd; |
495 | } |
496 | else if (newEnd > m_zeroAreaStart) |
497 | { |
498 | /* remove end of buffer, part of zero area */ |
499 | m_end = newEnd; |
500 | m_zeroAreaEnd = newEnd; |
501 | } |
502 | else if (newEnd > m_start) |
503 | { |
504 | /* remove end of buffer, zero area, part of start of buffer */ |
505 | m_end = newEnd; |
506 | m_zeroAreaEnd = newEnd; |
507 | m_zeroAreaStart = newEnd; |
508 | } |
509 | else |
510 | { |
511 | /* remove all buffer */ |
512 | m_end = m_start; |
513 | m_zeroAreaEnd = m_start; |
514 | m_zeroAreaStart = m_start; |
515 | } |
516 | m_maxZeroAreaStart = std::max (m_maxZeroAreaStart, m_zeroAreaStart); |
517 | LOG_INTERNAL_STATE ("rem end=" << end << ", ")do { if (g_log.IsEnabled (ns3::LOG_LOGIC)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; if (g_log.IsEnabled (ns3::LOG_PREFIX_FUNC)) { std ::clog << g_log.Name () << ":" << __FUNCTION__ << "(): "; }; if (g_log.IsEnabled (ns3::LOG_PREFIX_LEVEL )) { std::clog << "[" << g_log.GetLevelLabel (ns3 ::LOG_LOGIC) << "] "; }; std::clog << "rem end=" << end << ", " << "start="<<m_start<<", end=" <<m_end<<", zero start="<<m_zeroAreaStart<< ", zero end="<<m_zeroAreaEnd<<", count="<< m_data->m_count<<", size="<<m_data->m_size<< ", dirty start="<<m_data->m_dirtyStart<<", dirty end=" <<m_data->m_dirtyEnd << std::endl; } } while ( false); |
518 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 518 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
519 | } |
520 | |
521 | Buffer |
522 | Buffer::CreateFragment (uint32_t start, uint32_t length) const |
523 | { |
524 | NS_LOG_FUNCTION (this << start << length)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << start << length; std::clog << ")" << std::endl; } } while (false); |
525 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 525 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
526 | Buffer tmp = *this; |
527 | tmp.RemoveAtStart (start); |
528 | tmp.RemoveAtEnd (GetSize () - (start + length)); |
529 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 529 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
530 | return tmp; |
531 | } |
532 | |
533 | Buffer |
534 | Buffer::CreateFullCopy (void) const |
535 | { |
536 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
537 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 537 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
538 | if (m_zeroAreaEnd - m_zeroAreaStart != 0) |
539 | { |
540 | Buffer tmp; |
541 | tmp.AddAtStart (m_zeroAreaEnd - m_zeroAreaStart); |
542 | tmp.Begin ().WriteU8 (0, m_zeroAreaEnd - m_zeroAreaStart); |
543 | uint32_t dataStart = m_zeroAreaStart - m_start; |
544 | tmp.AddAtStart (dataStart); |
545 | tmp.Begin ().Write (m_data->m_data+m_start, dataStart); |
546 | uint32_t dataEnd = m_end - m_zeroAreaEnd; |
547 | tmp.AddAtEnd (dataEnd); |
548 | Buffer::Iterator i = tmp.End (); |
549 | i.Prev (dataEnd); |
550 | i.Write (m_data->m_data+m_zeroAreaStart,dataEnd); |
551 | NS_ASSERT (tmp.CheckInternalState ())do { if (!(tmp.CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "tmp.CheckInternalState ()" << "\", "; do { std ::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 551 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
552 | return tmp; |
553 | } |
554 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 554 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
555 | return *this; |
556 | } |
557 | |
558 | uint32_t |
559 | Buffer::GetSerializedSize (void) const |
560 | { |
561 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
562 | uint32_t dataStart = (m_zeroAreaStart - m_start + 3) & (~0x3); |
563 | uint32_t dataEnd = (m_end - m_zeroAreaEnd + 3) & (~0x3); |
564 | |
565 | // total size 4-bytes for dataStart length |
566 | // + X number of bytes for dataStart |
567 | // + 4-bytes for dataEnd length |
568 | // + X number of bytes for dataEnd |
569 | uint32_t sz = sizeof (uint32_t) |
570 | + sizeof (uint32_t) |
571 | + dataStart |
572 | + sizeof (uint32_t) |
573 | + dataEnd; |
574 | |
575 | return sz; |
576 | } |
577 | |
578 | uint32_t |
579 | Buffer::Serialize (uint8_t* buffer, uint32_t maxSize) const |
580 | { |
581 | NS_LOG_FUNCTION (this << &buffer << maxSize)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << &buffer << maxSize; std::clog << ")" << std::endl; } } while (false); |
582 | uint32_t* p = reinterpret_cast<uint32_t *> (buffer); |
583 | uint32_t size = 0; |
584 | |
585 | // Add the zero data length |
586 | if (size + 4 <= maxSize) |
587 | { |
588 | size += 4; |
589 | *p++ = m_zeroAreaEnd - m_zeroAreaStart; |
590 | } |
591 | else |
592 | { |
593 | return 0; |
594 | } |
595 | |
596 | // Add the length of actual start data |
597 | uint32_t dataStartLength = m_zeroAreaStart - m_start; |
598 | if (size + 4 <= maxSize) |
599 | { |
600 | size += 4; |
601 | *p++ = dataStartLength; |
602 | } |
603 | else |
604 | { |
605 | return 0; |
606 | } |
607 | |
608 | // Add the actual data |
609 | if (size + ((dataStartLength + 3) & (~3)) <= maxSize) |
610 | { |
611 | size += (dataStartLength + 3) & (~3); |
612 | memcpy (p, m_data->m_data + m_start, dataStartLength); |
613 | p += (((dataStartLength + 3) & (~3))/4); // Advance p, insuring 4 byte boundary |
614 | } |
615 | else |
616 | { |
617 | return 0; |
618 | } |
619 | |
620 | // Add the length of the actual end data |
621 | uint32_t dataEndLength = m_end - m_zeroAreaEnd; |
622 | if (size + 4 <= maxSize) |
623 | { |
624 | size += 4; |
625 | *p++ = dataEndLength; |
626 | } |
627 | else |
628 | { |
629 | return 0; |
630 | } |
631 | |
632 | // Add the actual data |
633 | if (size + ((dataEndLength + 3) & (~3)) <= maxSize) |
634 | { |
635 | size += (dataEndLength + 3) & (~3); |
636 | memcpy (p, m_data->m_data+m_zeroAreaStart,dataEndLength); |
637 | p += (((dataEndLength + 3) & (~3))/4); // Advance p, insuring 4 byte boundary |
638 | } |
639 | else |
640 | { |
641 | return 0; |
642 | } |
643 | |
644 | // Serialzed everything successfully |
645 | return 1; |
646 | } |
647 | |
648 | uint32_t |
649 | Buffer::Deserialize (const uint8_t *buffer, uint32_t size) |
650 | { |
651 | NS_LOG_FUNCTION (this << &buffer << size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << &buffer << size; std::clog << ")" << std::endl; } } while (false); |
652 | const uint32_t* p = reinterpret_cast<const uint32_t *> (buffer); |
653 | uint32_t sizeCheck = size-4; |
654 | |
655 | NS_ASSERT (sizeCheck >= 4)do { if (!(sizeCheck >= 4)) { std::cerr << "assert failed. cond=\"" << "sizeCheck >= 4" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 655 << std::endl; ::ns3::FatalImpl:: FlushStreams (); if (true) std::terminate (); } while (false) ; } } while (false); |
656 | uint32_t zeroDataLength = *p++; |
657 | sizeCheck -= 4; |
658 | |
659 | // Create zero bytes |
660 | Initialize (zeroDataLength); |
661 | |
662 | // Add start data |
663 | NS_ASSERT (sizeCheck >= 4)do { if (!(sizeCheck >= 4)) { std::cerr << "assert failed. cond=\"" << "sizeCheck >= 4" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 663 << std::endl; ::ns3::FatalImpl:: FlushStreams (); if (true) std::terminate (); } while (false) ; } } while (false); |
664 | uint32_t dataStartLength = *p++; |
665 | sizeCheck -= 4; |
666 | AddAtStart (dataStartLength); |
667 | |
668 | NS_ASSERT (sizeCheck >= dataStartLength)do { if (!(sizeCheck >= dataStartLength)) { std::cerr << "assert failed. cond=\"" << "sizeCheck >= dataStartLength" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 668 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
669 | Begin ().Write (reinterpret_cast<uint8_t *> (const_cast<uint32_t *> (p)), dataStartLength); |
670 | p += (((dataStartLength+3)&(~3))/4); // Advance p, insuring 4 byte boundary |
671 | sizeCheck -= ((dataStartLength+3)&(~3)); |
672 | |
673 | // Add end data |
674 | NS_ASSERT (sizeCheck >= 4)do { if (!(sizeCheck >= 4)) { std::cerr << "assert failed. cond=\"" << "sizeCheck >= 4" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 674 << std::endl; ::ns3::FatalImpl:: FlushStreams (); if (true) std::terminate (); } while (false) ; } } while (false); |
675 | uint32_t dataEndLength = *p++; |
676 | sizeCheck -= 4; |
677 | AddAtEnd (dataEndLength); |
678 | |
679 | NS_ASSERT (sizeCheck >= dataEndLength)do { if (!(sizeCheck >= dataEndLength)) { std::cerr << "assert failed. cond=\"" << "sizeCheck >= dataEndLength" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 679 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
680 | Buffer::Iterator tmp = End (); |
681 | tmp.Prev (dataEndLength); |
682 | tmp.Write (reinterpret_cast<uint8_t *> (const_cast<uint32_t *> (p)), dataEndLength); |
683 | p += (((dataEndLength+3)&(~3))/4); // Advance p, insuring 4 byte boundary |
Value stored to 'p' is never read | |
684 | sizeCheck -= ((dataEndLength+3)&(~3)); |
685 | |
686 | NS_ASSERT (sizeCheck == 0)do { if (!(sizeCheck == 0)) { std::cerr << "assert failed. cond=\"" << "sizeCheck == 0" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 686 << std::endl; ::ns3::FatalImpl::FlushStreams (); if (true) std::terminate (); } while (false); } } while ( false); |
687 | // return zero if buffer did not |
688 | // contain a complete message |
689 | return (sizeCheck != 0) ? 0 : 1; |
690 | } |
691 | |
692 | |
693 | void |
694 | Buffer::TransformIntoRealBuffer (void) const |
695 | { |
696 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
697 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 697 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
698 | Buffer tmp = CreateFullCopy (); |
699 | *const_cast<Buffer *> (this) = tmp; |
700 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 700 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
701 | } |
702 | |
703 | |
704 | uint8_t const* |
705 | Buffer::PeekData (void) const |
706 | { |
707 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
708 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 708 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
709 | TransformIntoRealBuffer (); |
710 | NS_ASSERT (CheckInternalState ())do { if (!(CheckInternalState ())) { std::cerr << "assert failed. cond=\"" << "CheckInternalState ()" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 710 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
711 | return m_data->m_data + m_start; |
712 | } |
713 | |
714 | void |
715 | Buffer::CopyData (std::ostream *os, uint32_t size) const |
716 | { |
717 | NS_LOG_FUNCTION (this << &os << size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << &os << size; std::clog << ")" << std::endl; } } while (false); |
718 | if (size > 0) |
719 | { |
720 | uint32_t tmpsize = std::min (m_zeroAreaStart-m_start, size); |
721 | os->write ((const char*)(m_data->m_data + m_start), tmpsize); |
722 | if (size > tmpsize) |
723 | { |
724 | size -= m_zeroAreaStart-m_start; |
725 | tmpsize = std::min (m_zeroAreaEnd - m_zeroAreaStart, size); |
726 | uint32_t left = tmpsize; |
727 | while (left > 0) |
728 | { |
729 | uint32_t toWrite = std::min (left, g_zeroes.size); |
730 | os->write (g_zeroes.buffer, toWrite); |
731 | left -= toWrite; |
732 | } |
733 | if (size > tmpsize) |
734 | { |
735 | size -= tmpsize; |
736 | tmpsize = std::min (m_end - m_zeroAreaEnd, size); |
737 | os->write ((const char*)(m_data->m_data + m_zeroAreaStart), tmpsize); |
738 | } |
739 | } |
740 | } |
741 | } |
742 | |
743 | uint32_t |
744 | Buffer::CopyData (uint8_t *buffer, uint32_t size) const |
745 | { |
746 | NS_LOG_FUNCTION (this << &buffer << size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << &buffer << size; std::clog << ")" << std::endl; } } while (false); |
747 | uint32_t originalSize = size; |
748 | if (size > 0) |
749 | { |
750 | uint32_t tmpsize = std::min (m_zeroAreaStart-m_start, size); |
751 | memcpy (buffer, (const char*)(m_data->m_data + m_start), tmpsize); |
752 | buffer += tmpsize; |
753 | size -= tmpsize; |
754 | if (size > 0) |
755 | { |
756 | tmpsize = std::min (m_zeroAreaEnd - m_zeroAreaStart, size); |
757 | uint32_t left = tmpsize; |
758 | while (left > 0) |
759 | { |
760 | uint32_t toWrite = std::min (left, g_zeroes.size); |
761 | memcpy (buffer, g_zeroes.buffer, toWrite); |
762 | left -= toWrite; |
763 | buffer += toWrite; |
764 | } |
765 | size -= tmpsize; |
766 | if (size > 0) |
767 | { |
768 | tmpsize = std::min (m_end - m_zeroAreaEnd, size); |
769 | memcpy (buffer, (const char*)(m_data->m_data + m_zeroAreaStart), tmpsize); |
770 | size -= tmpsize; |
771 | } |
772 | } |
773 | } |
774 | return originalSize - size; |
775 | } |
776 | |
777 | /****************************************************** |
778 | * The buffer iterator below. |
779 | ******************************************************/ |
780 | |
781 | |
782 | uint32_t |
783 | Buffer::Iterator::GetDistanceFrom (Iterator const &o) const |
784 | { |
785 | NS_LOG_FUNCTION (this << &o)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << &o; std::clog << ")" << std::endl ; } } while (false); |
786 | NS_ASSERT (m_data == o.m_data)do { if (!(m_data == o.m_data)) { std::cerr << "assert failed. cond=\"" << "m_data == o.m_data" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 786 << std::endl; ::ns3::FatalImpl:: FlushStreams (); if (true) std::terminate (); } while (false) ; } } while (false); |
787 | int32_t diff = m_current - o.m_current; |
788 | if (diff < 0) |
789 | { |
790 | return -diff; |
791 | } |
792 | else |
793 | { |
794 | return diff; |
795 | } |
796 | } |
797 | |
798 | bool |
799 | Buffer::Iterator::IsEnd (void) const |
800 | { |
801 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
802 | return m_current == m_dataEnd; |
803 | } |
804 | bool |
805 | Buffer::Iterator::IsStart (void) const |
806 | { |
807 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
808 | return m_current == m_dataStart; |
809 | } |
810 | |
811 | bool |
812 | Buffer::Iterator::CheckNoZero (uint32_t start, uint32_t end) const |
813 | { |
814 | NS_LOG_FUNCTION (this << &start << &end)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << &start << &end; std::clog << ")" << std::endl; } } while (false); |
815 | for (uint32_t i = start; i < end; i++) |
816 | { |
817 | if (!Check (i)) |
818 | { |
819 | return false; |
820 | } |
821 | } |
822 | return true; |
823 | } |
824 | bool |
825 | Buffer::Iterator::Check (uint32_t i) const |
826 | { |
827 | NS_LOG_FUNCTION (this << &i)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << &i; std::clog << ")" << std::endl ; } } while (false); |
828 | return i >= m_dataStart && |
829 | !(i >= m_zeroStart && i < m_zeroEnd) && |
830 | i <= m_dataEnd; |
831 | } |
832 | |
833 | |
834 | void |
835 | Buffer::Iterator::Write (Iterator start, Iterator end) |
836 | { |
837 | NS_LOG_FUNCTION (this << &start << &end)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << &start << &end; std::clog << ")" << std::endl; } } while (false); |
838 | NS_ASSERT (start.m_data == end.m_data)do { if (!(start.m_data == end.m_data)) { std::cerr << "assert failed. cond=\"" << "start.m_data == end.m_data" << "\", "; do { std ::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 838 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
839 | NS_ASSERT (start.m_current <= end.m_current)do { if (!(start.m_current <= end.m_current)) { std::cerr << "assert failed. cond=\"" << "start.m_current <= end.m_current" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 839 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
840 | NS_ASSERT (start.m_zeroStart == end.m_zeroStart)do { if (!(start.m_zeroStart == end.m_zeroStart)) { std::cerr << "assert failed. cond=\"" << "start.m_zeroStart == end.m_zeroStart" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 840 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
841 | NS_ASSERT (start.m_zeroEnd == end.m_zeroEnd)do { if (!(start.m_zeroEnd == end.m_zeroEnd)) { std::cerr << "assert failed. cond=\"" << "start.m_zeroEnd == end.m_zeroEnd" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 841 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
842 | NS_ASSERT (m_data != start.m_data)do { if (!(m_data != start.m_data)) { std::cerr << "assert failed. cond=\"" << "m_data != start.m_data" << "\", "; do { std:: cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 842 << std::endl; ::ns3::FatalImpl ::FlushStreams (); if (true) std::terminate (); } while (false ); } } while (false); |
843 | uint32_t size = end.m_current - start.m_current; |
844 | NS_ASSERT_MSG (CheckNoZero (m_current, m_current + size),do { if (!(CheckNoZero (m_current, m_current + size))) { std:: cerr << "assert failed. cond=\"" << "CheckNoZero (m_current, m_current + size)" << "\", "; do { std::cerr << "msg=\"" << GetWriteErrorMessage () << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 845 << std::endl; ::ns3::FatalImpl::FlushStreams (); if (true) std::terminate (); } while (false); } while (false); } } while (false) |
845 | GetWriteErrorMessage ())do { if (!(CheckNoZero (m_current, m_current + size))) { std:: cerr << "assert failed. cond=\"" << "CheckNoZero (m_current, m_current + size)" << "\", "; do { std::cerr << "msg=\"" << GetWriteErrorMessage () << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 845 << std::endl; ::ns3::FatalImpl::FlushStreams (); if (true) std::terminate (); } while (false); } while (false); } } while (false); |
846 | if (start.m_current <= start.m_zeroStart) |
847 | { |
848 | uint32_t toCopy = std::min (size, start.m_zeroStart - start.m_current); |
849 | memcpy (&m_data[m_current], &start.m_data[start.m_current], toCopy); |
850 | start.m_current += toCopy; |
851 | m_current += toCopy; |
852 | size -= toCopy; |
853 | } |
854 | if (start.m_current <= start.m_zeroEnd) |
855 | { |
856 | uint32_t toCopy = std::min (size, start.m_zeroEnd - start.m_current); |
857 | memset (&m_data[m_current], 0, toCopy); |
858 | start.m_current += toCopy; |
859 | m_current += toCopy; |
860 | size -= toCopy; |
861 | } |
862 | uint32_t toCopy = std::min (size, start.m_dataEnd - start.m_current); |
863 | uint8_t *from = &start.m_data[start.m_current - (start.m_zeroEnd-start.m_zeroStart)]; |
864 | uint8_t *to = &m_data[m_current]; |
865 | memcpy (to, from, toCopy); |
866 | m_current += toCopy; |
867 | } |
868 | |
869 | void |
870 | Buffer::Iterator::WriteU16 (uint16_t data) |
871 | { |
872 | NS_LOG_FUNCTION (this << data)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << data; std::clog << ")" << std::endl ; } } while (false); |
873 | WriteU8 (data & 0xff); |
874 | data >>= 8; |
875 | WriteU8 (data & 0xff); |
876 | } |
877 | void |
878 | Buffer::Iterator::WriteU32 (uint32_t data) |
879 | { |
880 | NS_LOG_FUNCTION (this << data)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << data; std::clog << ")" << std::endl ; } } while (false); |
881 | WriteU8 (data & 0xff); |
882 | data >>= 8; |
883 | WriteU8 (data & 0xff); |
884 | data >>= 8; |
885 | WriteU8 (data & 0xff); |
886 | data >>= 8; |
887 | WriteU8 (data & 0xff); |
888 | } |
889 | void |
890 | Buffer::Iterator::WriteU64 (uint64_t data) |
891 | { |
892 | NS_LOG_FUNCTION (this << data)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << data; std::clog << ")" << std::endl ; } } while (false); |
893 | WriteU8 (data & 0xff); |
894 | data >>= 8; |
895 | WriteU8 (data & 0xff); |
896 | data >>= 8; |
897 | WriteU8 (data & 0xff); |
898 | data >>= 8; |
899 | WriteU8 (data & 0xff); |
900 | data >>= 8; |
901 | WriteU8 (data & 0xff); |
902 | data >>= 8; |
903 | WriteU8 (data & 0xff); |
904 | data >>= 8; |
905 | WriteU8 (data & 0xff); |
906 | data >>= 8; |
907 | WriteU8 (data & 0xff); |
908 | } |
909 | void |
910 | Buffer::Iterator::WriteHtolsbU16 (uint16_t data) |
911 | { |
912 | NS_LOG_FUNCTION (this << data)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << data; std::clog << ")" << std::endl ; } } while (false); |
913 | WriteU8 ((data >> 0) & 0xff); |
914 | WriteU8 ((data >> 8) & 0xff); |
915 | } |
916 | void |
917 | Buffer::Iterator::WriteHtolsbU32 (uint32_t data) |
918 | { |
919 | NS_LOG_FUNCTION (this << data)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << data; std::clog << ")" << std::endl ; } } while (false); |
920 | WriteU8 ((data >> 0) & 0xff); |
921 | WriteU8 ((data >> 8) & 0xff); |
922 | WriteU8 ((data >> 16) & 0xff); |
923 | WriteU8 ((data >> 24) & 0xff); |
924 | } |
925 | void |
926 | Buffer::Iterator::WriteHtolsbU64 (uint64_t data) |
927 | { |
928 | NS_LOG_FUNCTION (this << data)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << data; std::clog << ")" << std::endl ; } } while (false); |
929 | WriteU8 ((data >> 0) & 0xff); |
930 | WriteU8 ((data >> 8) & 0xff); |
931 | WriteU8 ((data >> 16) & 0xff); |
932 | WriteU8 ((data >> 24) & 0xff); |
933 | WriteU8 ((data >> 32) & 0xff); |
934 | WriteU8 ((data >> 40) & 0xff); |
935 | WriteU8 ((data >> 48) & 0xff); |
936 | WriteU8 ((data >> 56) & 0xff); |
937 | } |
938 | |
939 | void |
940 | Buffer::Iterator::WriteHtonU64 (uint64_t data) |
941 | { |
942 | NS_LOG_FUNCTION (this << data)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << data; std::clog << ")" << std::endl ; } } while (false); |
943 | WriteU8 ((data >> 56) & 0xff); |
944 | WriteU8 ((data >> 48) & 0xff); |
945 | WriteU8 ((data >> 40) & 0xff); |
946 | WriteU8 ((data >> 32) & 0xff); |
947 | WriteU8 ((data >> 24) & 0xff); |
948 | WriteU8 ((data >> 16) & 0xff); |
949 | WriteU8 ((data >> 8) & 0xff); |
950 | WriteU8 ((data >> 0) & 0xff); |
951 | } |
952 | void |
953 | Buffer::Iterator::Write (uint8_t const*buffer, uint32_t size) |
954 | { |
955 | NS_LOG_FUNCTION (this << &buffer << size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << &buffer << size; std::clog << ")" << std::endl; } } while (false); |
956 | NS_ASSERT_MSG (CheckNoZero (m_current, size),do { if (!(CheckNoZero (m_current, size))) { std::cerr << "assert failed. cond=\"" << "CheckNoZero (m_current, size)" << "\", "; do { std::cerr << "msg=\"" << GetWriteErrorMessage () << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 957 << std::endl; ::ns3::FatalImpl::FlushStreams (); if (true) std::terminate (); } while (false); } while (false); } } while (false) |
957 | GetWriteErrorMessage ())do { if (!(CheckNoZero (m_current, size))) { std::cerr << "assert failed. cond=\"" << "CheckNoZero (m_current, size)" << "\", "; do { std::cerr << "msg=\"" << GetWriteErrorMessage () << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 957 << std::endl; ::ns3::FatalImpl::FlushStreams (); if (true) std::terminate (); } while (false); } while (false); } } while (false); |
958 | uint8_t *to; |
959 | if (m_current <= m_zeroStart) |
960 | { |
961 | to = &m_data[m_current]; |
962 | } |
963 | else |
964 | { |
965 | to = &m_data[m_current - (m_zeroEnd - m_zeroStart)]; |
966 | } |
967 | memcpy (to, buffer, size); |
968 | m_current += size; |
969 | } |
970 | |
971 | uint32_t |
972 | Buffer::Iterator::ReadU32 (void) |
973 | { |
974 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
975 | uint8_t byte0 = ReadU8 (); |
976 | uint8_t byte1 = ReadU8 (); |
977 | uint8_t byte2 = ReadU8 (); |
978 | uint8_t byte3 = ReadU8 (); |
979 | uint32_t data = byte3; |
980 | data <<= 8; |
981 | data |= byte2; |
982 | data <<= 8; |
983 | data |= byte1; |
984 | data <<= 8; |
985 | data |= byte0; |
986 | return data; |
987 | } |
988 | uint64_t |
989 | Buffer::Iterator::ReadU64 (void) |
990 | { |
991 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
992 | uint8_t byte0 = ReadU8 (); |
993 | uint8_t byte1 = ReadU8 (); |
994 | uint8_t byte2 = ReadU8 (); |
995 | uint8_t byte3 = ReadU8 (); |
996 | uint8_t byte4 = ReadU8 (); |
997 | uint8_t byte5 = ReadU8 (); |
998 | uint8_t byte6 = ReadU8 (); |
999 | uint8_t byte7 = ReadU8 (); |
1000 | uint64_t data = byte7; |
1001 | data <<= 8; |
1002 | data |= byte6; |
1003 | data <<= 8; |
1004 | data |= byte5; |
1005 | data <<= 8; |
1006 | data |= byte4; |
1007 | data <<= 8; |
1008 | data |= byte3; |
1009 | data <<= 8; |
1010 | data |= byte2; |
1011 | data <<= 8; |
1012 | data |= byte1; |
1013 | data <<= 8; |
1014 | data |= byte0; |
1015 | |
1016 | return data; |
1017 | } |
1018 | uint16_t |
1019 | Buffer::Iterator::SlowReadNtohU16 (void) |
1020 | { |
1021 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
1022 | uint16_t retval = 0; |
1023 | retval |= ReadU8 (); |
1024 | retval <<= 8; |
1025 | retval |= ReadU8 (); |
1026 | return retval; |
1027 | } |
1028 | uint32_t |
1029 | Buffer::Iterator::SlowReadNtohU32 (void) |
1030 | { |
1031 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
1032 | uint32_t retval = 0; |
1033 | retval |= ReadU8 (); |
1034 | retval <<= 8; |
1035 | retval |= ReadU8 (); |
1036 | retval <<= 8; |
1037 | retval |= ReadU8 (); |
1038 | retval <<= 8; |
1039 | retval |= ReadU8 (); |
1040 | return retval; |
1041 | } |
1042 | uint64_t |
1043 | Buffer::Iterator::ReadNtohU64 (void) |
1044 | { |
1045 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
1046 | uint64_t retval = 0; |
1047 | retval |= ReadU8 (); |
1048 | retval <<= 8; |
1049 | retval |= ReadU8 (); |
1050 | retval <<= 8; |
1051 | retval |= ReadU8 (); |
1052 | retval <<= 8; |
1053 | retval |= ReadU8 (); |
1054 | retval <<= 8; |
1055 | retval |= ReadU8 (); |
1056 | retval <<= 8; |
1057 | retval |= ReadU8 (); |
1058 | retval <<= 8; |
1059 | retval |= ReadU8 (); |
1060 | retval <<= 8; |
1061 | retval |= ReadU8 (); |
1062 | return retval; |
1063 | } |
1064 | uint16_t |
1065 | Buffer::Iterator::ReadLsbtohU16 (void) |
1066 | { |
1067 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
1068 | uint8_t byte0 = ReadU8 (); |
1069 | uint8_t byte1 = ReadU8 (); |
1070 | uint16_t data = byte1; |
1071 | data <<= 8; |
1072 | data |= byte0; |
1073 | return data; |
1074 | } |
1075 | uint32_t |
1076 | Buffer::Iterator::ReadLsbtohU32 (void) |
1077 | { |
1078 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
1079 | uint8_t byte0 = ReadU8 (); |
1080 | uint8_t byte1 = ReadU8 (); |
1081 | uint8_t byte2 = ReadU8 (); |
1082 | uint8_t byte3 = ReadU8 (); |
1083 | uint32_t data = byte3; |
1084 | data <<= 8; |
1085 | data |= byte2; |
1086 | data <<= 8; |
1087 | data |= byte1; |
1088 | data <<= 8; |
1089 | data |= byte0; |
1090 | return data; |
1091 | } |
1092 | uint64_t |
1093 | Buffer::Iterator::ReadLsbtohU64 (void) |
1094 | { |
1095 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
1096 | uint8_t byte0 = ReadU8 (); |
1097 | uint8_t byte1 = ReadU8 (); |
1098 | uint8_t byte2 = ReadU8 (); |
1099 | uint8_t byte3 = ReadU8 (); |
1100 | uint8_t byte4 = ReadU8 (); |
1101 | uint8_t byte5 = ReadU8 (); |
1102 | uint8_t byte6 = ReadU8 (); |
1103 | uint8_t byte7 = ReadU8 (); |
1104 | uint64_t data = byte7; |
1105 | data <<= 8; |
1106 | data |= byte6; |
1107 | data <<= 8; |
1108 | data |= byte5; |
1109 | data <<= 8; |
1110 | data |= byte4; |
1111 | data <<= 8; |
1112 | data |= byte3; |
1113 | data <<= 8; |
1114 | data |= byte2; |
1115 | data <<= 8; |
1116 | data |= byte1; |
1117 | data <<= 8; |
1118 | data |= byte0; |
1119 | |
1120 | return data; |
1121 | } |
1122 | void |
1123 | Buffer::Iterator::Read (uint8_t *buffer, uint32_t size) |
1124 | { |
1125 | NS_LOG_FUNCTION (this << &buffer << size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << &buffer << size; std::clog << ")" << std::endl; } } while (false); |
1126 | for (uint32_t i = 0; i < size; i++) |
1127 | { |
1128 | buffer[i] = ReadU8 (); |
1129 | } |
1130 | } |
1131 | |
1132 | uint16_t |
1133 | Buffer::Iterator::CalculateIpChecksum (uint16_t size) |
1134 | { |
1135 | NS_LOG_FUNCTION (this << size)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << size; std::clog << ")" << std::endl ; } } while (false); |
1136 | return CalculateIpChecksum (size, 0); |
1137 | } |
1138 | |
1139 | uint16_t |
1140 | Buffer::Iterator::CalculateIpChecksum (uint16_t size, uint32_t initialChecksum) |
1141 | { |
1142 | NS_LOG_FUNCTION (this << size << initialChecksum)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this << size << initialChecksum; std::clog << ")" << std::endl; } } while (false); |
1143 | /* see RFC 1071 to understand this code. */ |
1144 | uint32_t sum = initialChecksum; |
1145 | |
1146 | for (int j = 0; j < size/2; j++) |
1147 | sum += ReadU16 (); |
1148 | |
1149 | if (size & 1) |
1150 | sum += ReadU8 (); |
1151 | |
1152 | while (sum >> 16) |
1153 | sum = (sum & 0xffff) + (sum >> 16); |
1154 | return ~sum; |
1155 | } |
1156 | |
1157 | uint32_t |
1158 | Buffer::Iterator::GetSize (void) const |
1159 | { |
1160 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
1161 | return m_dataEnd - m_dataStart; |
1162 | } |
1163 | |
1164 | uint32_t |
1165 | Buffer::Iterator::GetRemainingSize (void) const |
1166 | { |
1167 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
1168 | return m_dataEnd - m_current; |
1169 | } |
1170 | |
1171 | |
1172 | std::string |
1173 | Buffer::Iterator::GetReadErrorMessage (void) const |
1174 | { |
1175 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
1176 | std::string str = "You have attempted to read beyond the bounds of the " |
1177 | "available buffer space. This usually indicates that a " |
1178 | "Header::Deserialize or Trailer::Deserialize method " |
1179 | "is trying to read data which was not written by " |
1180 | "a Header::Serialize or Trailer::Serialize method. " |
1181 | "In short: check the code of your Serialize and Deserialize " |
1182 | "methods."; |
1183 | return str; |
1184 | } |
1185 | std::string |
1186 | Buffer::Iterator::GetWriteErrorMessage (void) const |
1187 | { |
1188 | NS_LOG_FUNCTION (this)do { if (g_log.IsEnabled (ns3::LOG_FUNCTION)) { if (g_log.IsEnabled (ns3::LOG_PREFIX_TIME)) { ns3::LogTimePrinter printer = ns3:: LogGetTimePrinter (); if (printer != 0) { (*printer)(std::clog ); std::clog << " "; } }; if (g_log.IsEnabled (ns3::LOG_PREFIX_NODE )) { ns3::LogNodePrinter printer = ns3::LogGetNodePrinter (); if (printer != 0) { (*printer)(std::clog); std::clog << " "; } }; ; std::clog << g_log.Name () << ":" << __FUNCTION__ << "("; ns3::ParameterLogger (std::clog) << this; std::clog << ")" << std::endl; } } while ( false); |
1189 | std::string str; |
1190 | if (m_current < m_dataStart) |
1191 | { |
1192 | str = "You have attempted to write before the start of the available " |
1193 | "buffer space. This usually indicates that Trailer::GetSerializedSize " |
1194 | "returned a size which is too small compared to what Trailer::Serialize " |
1195 | "is actually using."; |
1196 | } |
1197 | else if (m_current >= m_dataEnd) |
1198 | { |
1199 | str = "You have attempted to write after the end of the available " |
1200 | "buffer space. This usually indicates that Header::GetSerializedSize " |
1201 | "returned a size which is too small compared to what Header::Serialize " |
1202 | "is actually using."; |
1203 | } |
1204 | else |
1205 | { |
1206 | NS_ASSERT (m_current >= m_zeroStart && m_current < m_zeroEnd)do { if (!(m_current >= m_zeroStart && m_current < m_zeroEnd)) { std::cerr << "assert failed. cond=\"" << "m_current >= m_zeroStart && m_current < m_zeroEnd" << "\", "; do { std::cerr << "file=" << "../src/network/model/buffer.cc" << ", line=" << 1206 << std::endl; ::ns3:: FatalImpl::FlushStreams (); if (true) std::terminate (); } while (false); } } while (false); |
1207 | str = "You have attempted to write inside the payload area of the " |
1208 | "buffer. This usually indicates that your Serialize method uses more " |
1209 | "buffer space than what your GetSerialized method returned."; |
1210 | } |
1211 | return str; |
1212 | } |
1213 | |
1214 | |
1215 | } // namespace ns3 |
1216 | |
1217 |