--- a/samples/main-packet.cc Tue Sep 05 11:23:39 2006 +0200
+++ b/samples/main-packet.cc Tue Sep 05 12:54:53 2006 +0200
@@ -69,7 +69,7 @@
/* A sample Tag implementation
*/
struct MyTag {
- uint16_t m_stream_id;
+ uint16_t m_streamId;
};
@@ -93,7 +93,7 @@
std::cout << "send data=2" << std::endl;
p.add (&my);
struct MyTag my_tag;
- my_tag.m_stream_id = 5;
+ my_tag.m_streamId = 5;
p.add_tag (&my_tag);
receive (p);
return 0;
--- a/src/common/buffer.cc Tue Sep 05 11:23:39 2006 +0200
+++ b/src/common/buffer.cc Tue Sep 05 12:54:53 2006 +0200
@@ -27,9 +27,9 @@
namespace ns3 {
-Buffer::BufferDataList Buffer::m_free_list;
-uint32_t Buffer::m_max_total_add_start = 0;
-uint32_t Buffer::m_max_total_add_end = 0;
+Buffer::BufferDataList Buffer::m_freeList;
+uint32_t Buffer::m_maxTotalAddStart = 0;
+uint32_t Buffer::m_maxTotalAddEnd = 0;
struct Buffer::BufferData *
Buffer::allocate (uint32_t req_size, uint32_t req_start)
@@ -42,9 +42,9 @@
uint8_t *b = new uint8_t [size];
struct BufferData *data = reinterpret_cast<struct Buffer::BufferData*>(b);
data->m_size = req_size;
- data->m_initial_start = req_start;
- data->m_dirty_start = req_start;
- data->m_dirty_size = 0;
+ data->m_initialStart = req_start;
+ data->m_dirtyStart = req_start;
+ data->m_dirtySize = 0;
data->m_count = 1;
return data;
}
@@ -61,15 +61,15 @@
{
assert (data->m_count == 0);
/* get rid of it if it is too small for later reuse. */
- if (data->m_size < (Buffer::m_max_total_add_start + Buffer::m_max_total_add_end)) {
+ if (data->m_size < (Buffer::m_maxTotalAddStart + Buffer::m_maxTotalAddEnd)) {
Buffer::deallocate (data);
return;
}
/* feed into free list */
- if (Buffer::m_free_list.size () > 1000) {
+ if (Buffer::m_freeList.size () > 1000) {
Buffer::deallocate (data);
} else {
- Buffer::m_free_list.push_back (data);
+ Buffer::m_freeList.push_back (data);
}
}
@@ -77,20 +77,20 @@
Buffer::create (void)
{
/* try to find a buffer correctly sized. */
- while (!Buffer::m_free_list.empty ()) {
- struct Buffer::BufferData *data = Buffer::m_free_list.back ();
- Buffer::m_free_list.pop_back ();
- if (data->m_size >= (m_max_total_add_start + m_max_total_add_end)) {
- data->m_initial_start = m_max_total_add_start;
- data->m_dirty_start = m_max_total_add_start;
- data->m_dirty_size = 0;
+ while (!Buffer::m_freeList.empty ()) {
+ struct Buffer::BufferData *data = Buffer::m_freeList.back ();
+ Buffer::m_freeList.pop_back ();
+ if (data->m_size >= (m_maxTotalAddStart + m_maxTotalAddEnd)) {
+ data->m_initialStart = m_maxTotalAddStart;
+ data->m_dirtyStart = m_maxTotalAddStart;
+ data->m_dirtySize = 0;
data->m_count = 1;
return data;
}
Buffer::deallocate (data);
}
- struct Buffer::BufferData *data = Buffer::allocate (m_max_total_add_start+m_max_total_add_end,
- m_max_total_add_start);
+ struct Buffer::BufferData *data = Buffer::allocate (m_maxTotalAddStart+m_maxTotalAddEnd,
+ m_maxTotalAddStart);
assert (data->m_count == 1);
return data;
}
@@ -104,8 +104,8 @@
Buffer::BufferData *
Buffer::create (void)
{
- return Buffer::allocate (m_max_total_add_start+m_max_total_add_end,
- m_max_total_add_start);
+ return Buffer::allocate (m_maxTotalAddStart+m_maxTotalAddEnd,
+ m_maxTotalAddStart);
}
#endif
@@ -120,8 +120,8 @@
void
Buffer::add_at_start (uint32_t start)
{
- assert (m_start <= m_data->m_initial_start);
- bool is_dirty = m_data->m_count > 1 && m_start > m_data->m_dirty_start;
+ assert (m_start <= m_data->m_initialStart);
+ bool is_dirty = m_data->m_count > 1 && m_start > m_data->m_dirtyStart;
if (m_start >= start && !is_dirty) {
/* enough space in the buffer and not dirty. */
m_start -= start;
@@ -130,7 +130,7 @@
/* enough space but need to move data around to fit new data */
memmove (m_data->m_data + start, get_start (), m_size);
assert (start > m_start);
- m_data->m_initial_start += start;
+ m_data->m_initialStart += start;
m_start = 0;
m_size += start;
} else if (m_start < start) {
@@ -138,7 +138,7 @@
uint32_t new_size = m_size + start;
struct Buffer::BufferData *new_data = Buffer::allocate (new_size, 0);
memcpy (new_data->m_data + start, get_start (), m_size);
- new_data->m_initial_start = m_data->m_initial_start + start;
+ new_data->m_initialStart = m_data->m_initialStart + start;
m_data->m_count--;
if (m_data->m_count == 0) {
Buffer::deallocate (m_data);
@@ -151,7 +151,7 @@
assert (is_dirty);
struct Buffer::BufferData *new_data = Buffer::create ();
memcpy (new_data->m_data + m_start, get_start (), m_size);
- new_data->m_initial_start = m_data->m_initial_start;
+ new_data->m_initialStart = m_data->m_initialStart;
m_data->m_count--;
if (m_data->m_count == 0) {
recycle (m_data);
@@ -161,28 +161,28 @@
m_size += start;
}
// update dirty area
- m_data->m_dirty_start = m_start;
- m_data->m_dirty_size = m_size;
- // update m_max_total_add_start
+ m_data->m_dirtyStart = m_start;
+ m_data->m_dirtySize = m_size;
+ // update m_maxTotalAddStart
uint32_t added_at_start;
- if (m_data->m_initial_start > m_start) {
- added_at_start = m_data->m_initial_start - m_start;
+ if (m_data->m_initialStart > m_start) {
+ added_at_start = m_data->m_initialStart - m_start;
} else {
added_at_start = 0;
}
- if (added_at_start > m_max_total_add_start) {
- m_max_total_add_start = added_at_start;
+ if (added_at_start > m_maxTotalAddStart) {
+ m_maxTotalAddStart = added_at_start;
}
- TRACE ("start add="<<start<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zero_area_size<<
- ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initial_start<<
- ", dirty start="<<m_data->m_dirty_start<<", dirty size="<<m_data->m_dirty_size);
+ TRACE ("start add="<<start<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zeroAreaSize<<
+ ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initialStart<<
+ ", dirty start="<<m_data->m_dirtyStart<<", dirty size="<<m_data->m_dirtySize);
}
void
Buffer::add_at_end (uint32_t end)
{
- assert (m_start <= m_data->m_initial_start);
+ assert (m_start <= m_data->m_initialStart);
bool is_dirty = m_data->m_count > 1 &&
- m_start + m_size < m_data->m_dirty_start + m_data->m_dirty_size;
+ m_start + m_size < m_data->m_dirtyStart + m_data->m_dirtySize;
if (m_start + m_size + end <= m_data->m_size && !is_dirty) {
/* enough space in buffer and not dirty */
m_size += end;
@@ -191,7 +191,7 @@
uint32_t new_start = m_data->m_size - (m_size + end);
memmove (m_data->m_data + new_start, get_start (), m_size);
assert (new_start < m_start);
- m_data->m_initial_start -= m_start - new_start;
+ m_data->m_initialStart -= m_start - new_start;
m_start = new_start;
m_size += end;
} else if (m_start + m_size + end > m_data->m_size) {
@@ -199,7 +199,7 @@
uint32_t new_size = m_size + end;
struct Buffer::BufferData *new_data = Buffer::allocate (new_size, 0);
memcpy (new_data->m_data, get_start (), m_size);
- new_data->m_initial_start = m_data->m_initial_start;
+ new_data->m_initialStart = m_data->m_initialStart;
m_data->m_count--;
if (m_data->m_count == 0) {
Buffer::deallocate (m_data);
@@ -212,7 +212,7 @@
assert (is_dirty);
struct Buffer::BufferData *new_data = Buffer::create ();
memcpy (new_data->m_data + m_start, get_start (), m_size);
- new_data->m_initial_start = m_data->m_initial_start;
+ new_data->m_initialStart = m_data->m_initialStart;
m_data->m_count--;
if (m_data->m_count == 0) {
recycle (m_data);
@@ -221,28 +221,28 @@
m_size += end;
}
// update dirty area
- m_data->m_dirty_start = m_start;
- m_data->m_dirty_size = m_size;
- // update m_max_total_add_end
+ m_data->m_dirtyStart = m_start;
+ m_data->m_dirtySize = m_size;
+ // update m_maxTotalAddEnd
uint32_t end_loc = m_start + m_size;
uint32_t added_at_end;
- if (m_data->m_initial_start < end_loc) {
- added_at_end = end_loc - m_data->m_initial_start;
+ if (m_data->m_initialStart < end_loc) {
+ added_at_end = end_loc - m_data->m_initialStart;
} else {
added_at_end = 0;
}
- if (added_at_end > m_max_total_add_end) {
- m_max_total_add_end = added_at_end;
+ if (added_at_end > m_maxTotalAddEnd) {
+ m_maxTotalAddEnd = added_at_end;
}
- TRACE ("end add="<<end<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zero_area_size<<
- ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initial_start<<
- ", dirty start="<<m_data->m_dirty_start<<", dirty size="<<m_data->m_dirty_size);
+ TRACE ("end add="<<end<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zeroAreaSize<<
+ ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initialStart<<
+ ", dirty start="<<m_data->m_dirtyStart<<", dirty size="<<m_data->m_dirtySize);
}
void
Buffer::remove_at_start (uint32_t start)
{
- if (m_zero_area_size == 0) {
+ if (m_zeroAreaSize == 0) {
if (m_size <= start) {
m_start += m_size;
m_size = 0;
@@ -251,10 +251,10 @@
m_size -= start;
}
} else {
- assert (m_data->m_initial_start >= m_start);
- uint32_t zero_start = m_data->m_initial_start - m_start;
- uint32_t zero_end = zero_start + m_zero_area_size;
- uint32_t data_end = m_size + m_zero_area_size;
+ assert (m_data->m_initialStart >= m_start);
+ uint32_t zero_start = m_data->m_initialStart - m_start;
+ uint32_t zero_end = zero_start + m_zeroAreaSize;
+ uint32_t data_end = m_size + m_zeroAreaSize;
if (start <= zero_start) {
/* only remove start of buffer */
m_start += start;
@@ -263,76 +263,76 @@
/* remove start of buffer _and_ start of zero area */
m_start += zero_start;
uint32_t zero_delta = start - zero_start;
- m_zero_area_size -= zero_delta;
+ m_zeroAreaSize -= zero_delta;
assert (zero_delta <= start);
m_size -= zero_start;
} else if (start <= data_end) {
/* remove start of buffer, complete zero area, and part
* of end of buffer */
- m_start += start - m_zero_area_size;
- m_size -= start - m_zero_area_size;
- m_zero_area_size = 0;
+ m_start += start - m_zeroAreaSize;
+ m_size -= start - m_zeroAreaSize;
+ m_zeroAreaSize = 0;
} else {
/* remove all buffer */
m_start += m_size;
m_size = 0;
- m_zero_area_size = 0;
+ m_zeroAreaSize = 0;
}
}
- TRACE ("start remove="<<start<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zero_area_size<<
- ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initial_start<<
- ", dirty start="<<m_data->m_dirty_start<<", dirty size="<<m_data->m_dirty_size);
+ TRACE ("start remove="<<start<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zeroAreaSize<<
+ ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initialStart<<
+ ", dirty start="<<m_data->m_dirtyStart<<", dirty size="<<m_data->m_dirtySize);
}
void
Buffer::remove_at_end (uint32_t end)
{
- if (m_zero_area_size == 0) {
+ if (m_zeroAreaSize == 0) {
if (m_size <= end) {
m_size = 0;
} else {
m_size -= end;
}
} else {
- assert (m_data->m_initial_start >= m_start);
- uint32_t zero_start = m_data->m_initial_start - m_start;
- uint32_t zero_end = zero_start + m_zero_area_size;
- uint32_t data_end = m_size + m_zero_area_size;
+ assert (m_data->m_initialStart >= m_start);
+ uint32_t zero_start = m_data->m_initialStart - m_start;
+ uint32_t zero_end = zero_start + m_zeroAreaSize;
+ uint32_t data_end = m_size + m_zeroAreaSize;
assert (zero_start <= m_size);
- assert (zero_end <= m_size + m_zero_area_size);
+ assert (zero_end <= m_size + m_zeroAreaSize);
if (data_end <= end) {
/* remove all buffer */
- m_zero_area_size = 0;
+ m_zeroAreaSize = 0;
m_start += m_size;
m_size = 0;
} else if (data_end - zero_start <= end) {
/* remove end of buffer, zero area, part of start of buffer */
- assert (end >= m_zero_area_size);
- m_size -= end - m_zero_area_size;
- m_zero_area_size = 0;
+ assert (end >= m_zeroAreaSize);
+ m_size -= end - m_zeroAreaSize;
+ m_zeroAreaSize = 0;
} else if (data_end - zero_end <= end) {
/* remove end of buffer, part of zero area */
uint32_t zero_delta = end - (data_end - zero_end);
- m_zero_area_size -= zero_delta;
+ m_zeroAreaSize -= zero_delta;
m_size -= end - zero_delta;
} else {
/* remove part of end of buffer */
m_size -= end;
}
}
- TRACE ("end remove="<<end<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zero_area_size<<
- ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initial_start<<
- ", dirty start="<<m_data->m_dirty_start<<", dirty size="<<m_data->m_dirty_size);
+ TRACE ("end remove="<<end<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zeroAreaSize<<
+ ", real size="<<m_data->m_size<<", ini start="<<m_data->m_initialStart<<
+ ", dirty start="<<m_data->m_dirtyStart<<", dirty size="<<m_data->m_dirtySize);
}
Buffer
Buffer::create_fragment (uint32_t start, uint32_t length) const
{
- uint32_t zero_start = m_data->m_initial_start - m_start;
- uint32_t zero_end = zero_start + m_zero_area_size;
- if (m_zero_area_size != 0 &&
+ uint32_t zero_start = m_data->m_initialStart - m_start;
+ uint32_t zero_end = zero_start + m_zeroAreaSize;
+ if (m_zeroAreaSize != 0 &&
start + length > zero_start &&
start <= zero_end) {
- transform_into_real_buffer ();
+ transform_intoRealBuffer ();
}
Buffer tmp = *this;
tmp.remove_at_start (start);
@@ -341,22 +341,22 @@
}
void
-Buffer::transform_into_real_buffer (void) const
+Buffer::transform_intoRealBuffer (void) const
{
- if (m_zero_area_size != 0) {
- assert (m_data->m_initial_start >= m_start);
- assert (m_size >= (m_data->m_initial_start - m_start));
+ if (m_zeroAreaSize != 0) {
+ assert (m_data->m_initialStart >= m_start);
+ assert (m_size >= (m_data->m_initialStart - m_start));
Buffer tmp;
- tmp.add_at_start (m_zero_area_size);
- tmp.begin ().write_u8 (0, m_zero_area_size);
- uint32_t data_start = m_data->m_initial_start - m_start;
+ tmp.add_at_start (m_zeroAreaSize);
+ tmp.begin ().write_u8 (0, m_zeroAreaSize);
+ uint32_t data_start = m_data->m_initialStart - m_start;
tmp.add_at_start (data_start);
tmp.begin ().write (m_data->m_data+m_start, data_start);
- uint32_t data_end = m_size - (m_data->m_initial_start - m_start);
+ uint32_t data_end = m_size - (m_data->m_initialStart - m_start);
tmp.add_at_end (data_end);
Buffer::Iterator i = tmp.end ();
i.prev (data_end);
- i.write (m_data->m_data+m_data->m_initial_start,data_end);
+ i.write (m_data->m_data+m_data->m_initialStart,data_end);
*const_cast<Buffer *> (this) = tmp;
}
}
@@ -365,7 +365,7 @@
uint8_t *
Buffer::peek_data (void) const
{
- transform_into_real_buffer ();
+ transform_intoRealBuffer ();
return m_data->m_data + m_start;
}
--- a/src/common/buffer.h Tue Sep 05 11:23:39 2006 +0200
+++ b/src/common/buffer.h Tue Sep 05 12:54:53 2006 +0200
@@ -240,9 +240,9 @@
friend class Buffer;
inline Iterator (Buffer const*buffer, uint32_t m_current);
inline uint32_t get_index (uint32_t n);
- uint32_t m_zero_start;
- uint32_t m_zero_end;
- uint32_t m_data_end;
+ uint32_t m_zeroStart;
+ uint32_t m_zeroEnd;
+ uint32_t m_dataEnd;
uint32_t m_current;
uint8_t *m_data;
};
@@ -329,26 +329,26 @@
struct BufferData {
uint32_t m_count;
uint32_t m_size;
- uint32_t m_initial_start;
- uint32_t m_dirty_start;
- uint32_t m_dirty_size;
+ uint32_t m_initialStart;
+ uint32_t m_dirtyStart;
+ uint32_t m_dirtySize;
uint8_t m_data[1];
};
typedef std::vector<struct Buffer::BufferData*> BufferDataList;
inline uint8_t *get_start (void) const;
- void transform_into_real_buffer (void) const;
+ void transform_intoRealBuffer (void) const;
static void recycle (struct Buffer::BufferData *data);
static struct Buffer::BufferData *create (void);
static struct Buffer::BufferData *allocate (uint32_t size, uint32_t start);
static void deallocate (struct Buffer::BufferData *data);
- static BufferDataList m_free_list;
- static uint32_t m_max_total_add_start;
- static uint32_t m_max_total_add_end;
+ static BufferDataList m_freeList;
+ static uint32_t m_maxTotalAddStart;
+ static uint32_t m_maxTotalAddEnd;
struct BufferData *m_data;
- uint32_t m_zero_area_size;
+ uint32_t m_zeroAreaSize;
uint32_t m_start;
uint32_t m_size;
};
@@ -361,8 +361,8 @@
Buffer::Buffer ()
: m_data (Buffer::create ()),
- m_zero_area_size (0),
- m_start (m_max_total_add_start),
+ m_zeroAreaSize (0),
+ m_start (m_maxTotalAddStart),
m_size (0)
{
if (m_start > m_data->m_size) {
@@ -373,8 +373,8 @@
Buffer::Buffer (uint32_t data_size)
: m_data (Buffer::create ()),
- m_zero_area_size (data_size),
- m_start (m_max_total_add_start),
+ m_zeroAreaSize (data_size),
+ m_start (m_maxTotalAddStart),
m_size (0)
{
if (m_start > m_data->m_size) {
@@ -386,7 +386,7 @@
Buffer::Buffer (Buffer const&o)
: m_data (o.m_data),
- m_zero_area_size (o.m_zero_area_size),
+ m_zeroAreaSize (o.m_zeroAreaSize),
m_start (o.m_start),
m_size (o.m_size)
{
@@ -406,7 +406,7 @@
m_data = o.m_data;
m_data->m_count++;
}
- m_zero_area_size = o.m_zero_area_size;
+ m_zeroAreaSize = o.m_zeroAreaSize;
m_start = o.m_start;
m_size = o.m_size;
assert (m_start <= m_data->m_size);
@@ -431,7 +431,7 @@
uint32_t
Buffer::get_size (void) const
{
- return m_size + m_zero_area_size;
+ return m_size + m_zeroAreaSize;
}
Buffer::Iterator
@@ -447,16 +447,16 @@
Buffer::Iterator::Iterator ()
- : m_zero_start (0),
- m_zero_end (0),
- m_data_end (0),
+ : m_zeroStart (0),
+ m_zeroEnd (0),
+ m_dataEnd (0),
m_current (0),
m_data (0)
{}
Buffer::Iterator::Iterator (Buffer const*buffer, uint32_t current)
- : m_zero_start (buffer->m_data->m_initial_start-buffer->m_start),
- m_zero_end (m_zero_start+buffer->m_zero_area_size),
- m_data_end (buffer->get_size ()),
+ : m_zeroStart (buffer->m_data->m_initialStart-buffer->m_start),
+ m_zeroEnd (m_zeroStart+buffer->m_zeroAreaSize),
+ m_dataEnd (buffer->get_size ()),
m_current (current),
m_data (buffer->m_data->m_data+buffer->m_start)
{}
@@ -464,7 +464,7 @@
void
Buffer::Iterator::next (void)
{
- assert (m_current + 1 <= m_data_end);
+ assert (m_current + 1 <= m_dataEnd);
m_current++;
}
void
@@ -476,7 +476,7 @@
void
Buffer::Iterator::next (uint32_t delta)
{
- assert (m_current + delta <= m_data_end);
+ assert (m_current + delta <= m_dataEnd);
m_current += delta;
}
void
@@ -497,7 +497,7 @@
bool
Buffer::Iterator::is_end (void) const
{
- return m_current == m_data_end;
+ return m_current == m_dataEnd;
}
bool
Buffer::Iterator::is_start (void) const
@@ -509,15 +509,15 @@
Buffer::Iterator::get_index (uint32_t n)
{
assert (
- (m_current + n <= m_data_end) &&
- ((m_current + n <= m_zero_start) ||
- (m_current >= m_zero_end))
+ (m_current + n <= m_dataEnd) &&
+ ((m_current + n <= m_zeroStart) ||
+ (m_current >= m_zeroEnd))
);
uint32_t index;
- if (m_current < m_zero_start) {
+ if (m_current < m_zeroStart) {
index = m_current;
} else {
- index = m_current - (m_zero_end-m_zero_start);
+ index = m_current - (m_zeroEnd-m_zeroStart);
}
return index;
}
--- a/src/common/chunk.cc Tue Sep 05 11:23:39 2006 +0200
+++ b/src/common/chunk.cc Tue Sep 05 12:54:53 2006 +0200
@@ -25,7 +25,7 @@
namespace ns3 {
Chunk::Chunk ()
- : m_must_peek_before_remove (false) {}
+ : m_mustPeekBeforeRemove (false) {}
void
Chunk::print (std::ostream &os) const
@@ -41,14 +41,14 @@
Chunk::peek (Buffer const *buffer)
{
peek_from (buffer);
- m_must_peek_before_remove = true;
+ m_mustPeekBeforeRemove = true;
}
void
Chunk::remove (Buffer *buffer)
{
- assert (m_must_peek_before_remove);
+ assert (m_mustPeekBeforeRemove);
remove_from (buffer);
- m_must_peek_before_remove = false;
+ m_mustPeekBeforeRemove = false;
}
--- a/src/common/chunk.h Tue Sep 05 11:23:39 2006 +0200
+++ b/src/common/chunk.h Tue Sep 05 12:54:53 2006 +0200
@@ -49,7 +49,7 @@
void peek (Buffer const *buffer);
void remove (Buffer *buffer);
private:
- bool m_must_peek_before_remove;
+ bool m_mustPeekBeforeRemove;
/**
* \param os the std output stream in which this
* protocol header must print itself.
--- a/src/common/pcap-writer.cc Tue Sep 05 11:23:39 2006 +0200
+++ b/src/common/pcap-writer.cc Tue Sep 05 12:54:53 2006 +0200
@@ -39,7 +39,7 @@
PcapWriter::PcapWriter ()
{
m_writer = 0;
- m_write_callback = make_callback (&PcapWriter::write_data, this);
+ m_writeCallback = make_callback (&PcapWriter::write_data, this);
}
PcapWriter::~PcapWriter ()
{
@@ -76,7 +76,7 @@
write_32 (us & 0xffffffff);
write_32 (packet.get_size ());
write_32 (packet.get_size ());
- packet.write (m_write_callback);
+ packet.write (m_writeCallback);
}
}
--- a/src/common/pcap-writer.h Tue Sep 05 11:23:39 2006 +0200
+++ b/src/common/pcap-writer.h Tue Sep 05 12:54:53 2006 +0200
@@ -65,7 +65,7 @@
void write_32 (uint32_t data);
void write_16 (uint16_t data);
SystemFile *m_writer;
- Callback<void,uint8_t *,uint32_t> m_write_callback;
+ Callback<void,uint8_t *,uint32_t> m_writeCallback;
};
}; // namespace ns3
--- a/src/common/trace-container.cc Tue Sep 05 11:23:39 2006 +0200
+++ b/src/common/trace-container.cc Tue Sep 05 12:54:53 2006 +0200
@@ -30,15 +30,15 @@
{}
TraceContainer::~TraceContainer ()
{
- m_ui_list.erase (m_ui_list.begin (), m_ui_list.end ());
- m_si_list.erase (m_si_list.begin (), m_si_list.end ());
- m_f_list.erase (m_f_list.begin (), m_f_list.end ());
+ m_uiList.erase (m_uiList.begin (), m_uiList.end ());
+ m_siList.erase (m_siList.begin (), m_siList.end ());
+ m_fList.erase (m_fList.begin (), m_fList.end ());
}
void
TraceContainer::set_ui_variable_callback (char const *name, Callback<void,uint64_t, uint64_t> callback)
{
- for (UiListI i = m_ui_list.begin (); i != m_ui_list.end (); i++) {
+ for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++) {
if ((*i).second == name) {
(*i).first->set_callback (callback);
return;
@@ -49,7 +49,7 @@
void
TraceContainer::set_si_variable_callback (char const *name, Callback<void,int64_t, int64_t> callback)
{
- for (SiListI i = m_si_list.begin (); i != m_si_list.end (); i++) {
+ for (SiListI i = m_siList.begin (); i != m_siList.end (); i++) {
if ((*i).second == name) {
(*i).first->set_callback (callback);
return;
@@ -65,7 +65,7 @@
void
TraceContainer::set_stream (char const *name, std::ostream *os)
{
- for (StreamTracerListI i = m_trace_stream_list.begin (); i != m_trace_stream_list.end (); i++) {
+ for (StreamTracerListI i = m_traceStreamList.begin (); i != m_traceStreamList.end (); i++) {
if ((*i).second == name) {
(*i).first->set_stream (os);
return;
@@ -78,25 +78,25 @@
TraceContainer::register_ui_variable (char const *name, UiVariableTracerBase *var)
{
// ensure unicity
- for (UiListI i = m_ui_list.begin (); i != m_ui_list.end (); i++) {
+ for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++) {
if (i->second == name) {
- m_ui_list.erase (i);
+ m_uiList.erase (i);
break;
}
}
- m_ui_list.push_back (std::make_pair (var, name));
+ m_uiList.push_back (std::make_pair (var, name));
}
void
TraceContainer::register_si_variable (char const *name, SiVariableTracerBase *var)
{
// ensure unicity
- for (SiListI i = m_si_list.begin (); i != m_si_list.end (); i++) {
+ for (SiListI i = m_siList.begin (); i != m_siList.end (); i++) {
if (i->second == name) {
- m_si_list.erase (i);
+ m_siList.erase (i);
break;
}
}
- m_si_list.push_back (std::make_pair (var, name));
+ m_siList.push_back (std::make_pair (var, name));
}
void
TraceContainer::register_f_variable (char const *name, FVariableTracerBase *var)
@@ -108,26 +108,26 @@
TraceContainer::register_stream (char const *name, StreamTracer *stream)
{
// ensure unicity
- for (StreamTracerListI i = m_trace_stream_list.begin (); i != m_trace_stream_list.end (); i++) {
+ for (StreamTracerListI i = m_traceStreamList.begin (); i != m_traceStreamList.end (); i++) {
if (i->second == name) {
- m_trace_stream_list.erase (i);
+ m_traceStreamList.erase (i);
break;
}
}
- m_trace_stream_list.push_back (std::make_pair (stream,name));
+ m_traceStreamList.push_back (std::make_pair (stream,name));
}
void
TraceContainer::register_callback (char const *name, CallbackTracerBase *tracer)
{
- for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
+ for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
- m_callback_list.erase (i);
+ m_callbackList.erase (i);
break;
}
}
- m_callback_list.push_back (std::make_pair (tracer, name));
+ m_callbackList.push_back (std::make_pair (tracer, name));
}
@@ -139,27 +139,27 @@
void
ns3::TraceContainer::print_debug (void)
{
- if (!m_ui_list.empty ()) {
+ if (!m_uiList.empty ()) {
std::cout << "ui var: " << std::endl;
- for (UiListI i = m_ui_list.begin (); i != m_ui_list.end (); i++) {
+ for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++) {
std::cout << " \"" << (*i).second << "\""<<std::endl;
}
}
- if (!m_si_list.empty ()) {
+ if (!m_siList.empty ()) {
std::cout << "si var: " << std::endl;
- for (SiListI i = m_si_list.begin (); i != m_si_list.end (); i++) {
+ for (SiListI i = m_siList.begin (); i != m_siList.end (); i++) {
std::cout << " \"" << (*i).second << "\""<<std::endl;
}
}
- if (!m_f_list.empty ()) {
+ if (!m_fList.empty ()) {
std::cout << "f var: " << std::endl;
- for (FListI i = m_f_list.begin (); i != m_f_list.end (); i++) {
+ for (FListI i = m_fList.begin (); i != m_fList.end (); i++) {
std::cout << " \"" << (*i).second << "\""<<std::endl;
}
}
- if (!m_callback_list.empty ()) {
+ if (!m_callbackList.empty ()) {
std::cout << "callback list: "<<std::endl;
- for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
+ for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
std::cout << " \"" << i->second << "\""<<std::endl;
}
}
--- a/src/common/trace-container.h Tue Sep 05 11:23:39 2006 +0200
+++ b/src/common/trace-container.h Tue Sep 05 12:54:53 2006 +0200
@@ -187,11 +187,11 @@
typedef std::list<std::pair<CallbackTracerBase *, std::string> > CallbackList;
typedef std::list<std::pair<CallbackTracerBase *, std::string> >::iterator CallbackListI;
- UiList m_ui_list;
- SiList m_si_list;
- FList m_f_list;
- StreamTracerList m_trace_stream_list;
- CallbackList m_callback_list;
+ UiList m_uiList;
+ SiList m_siList;
+ FList m_fList;
+ StreamTracerList m_traceStreamList;
+ CallbackList m_callbackList;
};
}; // namespace ns3
@@ -206,7 +206,7 @@
void
TraceContainer::set_callback (char const *name, Callback<void,T1> callback)
{
- for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
+ for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
static_cast<CallbackTracer<T1> *> (i->first)->set_callback (callback);
return;
@@ -220,7 +220,7 @@
void
TraceContainer::set_callback (char const *name, Callback<void,T1,T2> callback)
{
- for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
+ for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
static_cast<CallbackTracer<T1,T2> *> (i->first)->set_callback (callback);
return;
@@ -234,7 +234,7 @@
void
TraceContainer::set_callback (char const *name, Callback<void,T1,T2,T3> callback)
{
- for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
+ for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
static_cast<CallbackTracer<T1,T2,T3> *> (i->first)->set_callback (callback);
return;
@@ -248,7 +248,7 @@
void
TraceContainer::set_callback (char const *name, Callback<void,T1,T2,T3,T4> callback)
{
- for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
+ for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
static_cast<CallbackTracer<T1,T2,T3,T4> *> (i->first)->set_callback (callback);
return;
@@ -262,7 +262,7 @@
void
TraceContainer::set_callback (char const *name, Callback<void,T1,T2,T3,T4,T5> callback)
{
- for (CallbackListI i = m_callback_list.begin (); i != m_callback_list.end (); i++) {
+ for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
static_cast<CallbackTracer<T1,T2,T3,T4,T5> *> (i->first)->set_callback (callback);
return;
--- a/src/core/callback.h Tue Sep 05 11:23:39 2006 +0200
+++ b/src/core/callback.h Tue Sep 05 12:54:53 2006 +0200
@@ -169,29 +169,29 @@
class MemPtrCallbackImpl : public CallbackImpl<R,T1,T2,T3,T4,T5> {
public:
MemPtrCallbackImpl (OBJ_PTR const&obj_ptr, MEM_PTR mem_ptr)
- : m_obj_ptr (obj_ptr), m_mem_ptr (mem_ptr) {}
+ : m_objPtr (obj_ptr), m_memPtr (mem_ptr) {}
virtual ~MemPtrCallbackImpl () {}
R operator() (void) {
- return ((*m_obj_ptr).*m_mem_ptr) ();
+ return ((*m_objPtr).*m_memPtr) ();
}
R operator() (T1 a1) {
- return ((*m_obj_ptr).*m_mem_ptr) (a1);
+ return ((*m_objPtr).*m_memPtr) (a1);
}
R operator() (T1 a1,T2 a2) {
- return ((*m_obj_ptr).*m_mem_ptr) (a1,a2);
+ return ((*m_objPtr).*m_memPtr) (a1,a2);
}
R operator() (T1 a1,T2 a2,T3 a3) {
- return ((*m_obj_ptr).*m_mem_ptr) (a1,a2,a3);
+ return ((*m_objPtr).*m_memPtr) (a1,a2,a3);
}
R operator() (T1 a1,T2 a2,T3 a3,T4 a4) {
- return ((*m_obj_ptr).*m_mem_ptr) (a1,a2,a3,a4);
+ return ((*m_objPtr).*m_memPtr) (a1,a2,a3,a4);
}
R operator() (T1 a1,T2 a2,T3 a3,T4 a4,T5 a5) {
- return ((*m_obj_ptr).*m_mem_ptr) (a1,a2,a3,a4,a5);
+ return ((*m_objPtr).*m_memPtr) (a1,a2,a3,a4,a5);
}
private:
- OBJ_PTR const m_obj_ptr;
- MEM_PTR m_mem_ptr;
+ OBJ_PTR const m_objPtr;
+ MEM_PTR m_memPtr;
};
/**
--- a/src/core/reference-list.h Tue Sep 05 11:23:39 2006 +0200
+++ b/src/core/reference-list.h Tue Sep 05 12:54:53 2006 +0200
@@ -38,7 +38,7 @@
class ReferenceList {
public:
ReferenceList ()
- : m_obj_ptr (),
+ : m_objPtr (),
m_prev (),
m_next ()
{
@@ -46,7 +46,7 @@
m_next = this;
}
ReferenceList (ReferenceList &o)
- : m_obj_ptr (),
+ : m_objPtr (),
m_prev (),
m_next ()
{
@@ -55,7 +55,7 @@
insert_self_in_other (o);
}
ReferenceList (ReferenceList const&o)
- : m_obj_ptr (),
+ : m_objPtr (),
m_prev (),
m_next ()
{
@@ -64,7 +64,7 @@
insert_self_in_other (o);
}
ReferenceList (OBJ_PTR const &obj_ptr)
- : m_obj_ptr (obj_ptr),
+ : m_objPtr (obj_ptr),
m_prev (),
m_next ()
{
@@ -80,15 +80,15 @@
return *this;
}
OBJ_PTR operator-> () {
- return m_obj_ptr;
+ return m_objPtr;
}
void set (OBJ_PTR obj_ptr) {
remove_from_list ();
- m_obj_ptr = obj_ptr;
+ m_objPtr = obj_ptr;
}
OBJ_PTR get (void) {
// explicit conversion to raw pointer type.
- return m_obj_ptr;
+ return m_objPtr;
}
private:
void insert_self_in_other (ReferenceList const&o) {
@@ -96,18 +96,18 @@
m_next = o.m_next;
m_next->m_prev = this;
o.m_next = this;
- m_obj_ptr = o.m_obj_ptr;
+ m_objPtr = o.m_objPtr;
}
void remove_from_list (void) {
if (m_prev == this) {
//assert (m_next == this);
- delete m_obj_ptr;
- m_obj_ptr = OBJ_PTR ();
+ delete m_objPtr;
+ m_objPtr = OBJ_PTR ();
}
m_prev->m_next = m_next;
m_next->m_prev = m_prev;
}
- OBJ_PTR m_obj_ptr;
+ OBJ_PTR m_objPtr;
mutable ReferenceList const*m_prev;
mutable ReferenceList const*m_next;
};
--- a/src/core/unix-system-wall-clock-ms.cc Tue Sep 05 11:23:39 2006 +0200
+++ b/src/core/unix-system-wall-clock-ms.cc Tue Sep 05 12:54:53 2006 +0200
@@ -29,24 +29,24 @@
void start (void);
unsigned long long end (void);
private:
- struct timeval m_start_tv;
- struct timeval m_end_tv;
+ struct timeval m_startTv;
+ struct timeval m_endTv;
};
void
SystemWallClockMsPrivate::start (void)
{
struct timezone tz;
- gettimeofday (&m_start_tv, &tz);
+ gettimeofday (&m_startTv, &tz);
}
unsigned long long
SystemWallClockMsPrivate::end (void)
{
struct timezone tz;
- gettimeofday (&m_end_tv, &tz);
- unsigned long long end = m_end_tv.tv_sec *1000 + m_end_tv.tv_usec / 1000;
- unsigned long long start = m_start_tv.tv_sec *1000 + m_start_tv.tv_usec / 1000;
+ gettimeofday (&m_endTv, &tz);
+ unsigned long long end = m_endTv.tv_sec *1000 + m_endTv.tv_usec / 1000;
+ unsigned long long start = m_startTv.tv_sec *1000 + m_startTv.tv_usec / 1000;
return end - start;
}
--- a/src/simulator/event-id.cc Tue Sep 05 11:23:39 2006 +0200
+++ b/src/simulator/event-id.cc Tue Sep 05 12:54:53 2006 +0200
@@ -24,13 +24,13 @@
namespace ns3 {
EventId::EventId ()
- : m_event_impl (0),
+ : m_eventImpl (0),
m_ns (0),
m_uid (0)
{}
EventId::EventId (EventImpl *impl, uint64_t ns, uint32_t uid)
- : m_event_impl (impl),
+ : m_eventImpl (impl),
m_ns (ns),
m_uid (uid)
{}
@@ -47,7 +47,7 @@
EventImpl *
EventId::get_event_impl (void) const
{
- return m_event_impl;
+ return m_eventImpl;
}
uint64_t
EventId::get_ns (void) const
--- a/src/simulator/event-id.h Tue Sep 05 11:23:39 2006 +0200
+++ b/src/simulator/event-id.h Tue Sep 05 12:54:53 2006 +0200
@@ -42,7 +42,7 @@
uint64_t get_ns (void) const;
uint32_t get_uid (void) const;
private:
- EventImpl *m_event_impl;
+ EventImpl *m_eventImpl;
uint64_t m_ns;
uint32_t m_uid;
};
--- a/src/simulator/event-impl.cc Tue Sep 05 11:23:39 2006 +0200
+++ b/src/simulator/event-impl.cc Tue Sep 05 12:54:53 2006 +0200
@@ -29,7 +29,7 @@
{}
EventImpl::EventImpl ()
- : m_internal_iterator (0),
+ : m_internalIterator (0),
m_cancel (false)
{}
void
@@ -42,12 +42,12 @@
void
EventImpl::set_internal_iterator (void *tag)
{
- m_internal_iterator = tag;
+ m_internalIterator = tag;
}
void *
EventImpl::get_internal_iterator (void) const
{
- return m_internal_iterator;
+ return m_internalIterator;
}
void
EventImpl::cancel (void)
--- a/src/simulator/event-impl.h Tue Sep 05 11:23:39 2006 +0200
+++ b/src/simulator/event-impl.h Tue Sep 05 12:54:53 2006 +0200
@@ -37,7 +37,7 @@
virtual void notify (void) = 0;
private:
friend class Event;
- void *m_internal_iterator;
+ void *m_internalIterator;
bool m_cancel;
};
--- a/src/simulator/simulator.cc Tue Sep 05 11:23:39 2006 +0200
+++ b/src/simulator/simulator.cc Tue Sep 05 12:54:53 2006 +0200
@@ -70,15 +70,15 @@
typedef std::list<std::pair<EventImpl *,uint32_t> > Events;
Events m_destroy;
- uint64_t m_stop_at;
+ uint64_t m_stopAt;
bool m_stop;
Scheduler *m_events;
uint32_t m_uid;
- uint32_t m_current_uid;
- uint64_t m_current_ns;
+ uint32_t m_currentUid;
+ uint64_t m_currentNs;
std::ofstream m_log;
- std::ifstream m_input_log;
- bool m_log_enable;
+ std::ifstream m_inputLog;
+ bool m_logEnable;
};
@@ -87,11 +87,11 @@
SimulatorPrivate::SimulatorPrivate (Scheduler *events)
{
m_stop = false;
- m_stop_at = 0;
+ m_stopAt = 0;
m_events = events;
m_uid = 0;
- m_log_enable = false;
- m_current_ns = 0;
+ m_logEnable = false;
+ m_currentNs = 0;
}
SimulatorPrivate::~SimulatorPrivate ()
@@ -112,7 +112,7 @@
SimulatorPrivate::enable_log_to (char const *filename)
{
m_log.open (filename);
- m_log_enable = true;
+ m_logEnable = true;
}
void
@@ -122,9 +122,9 @@
Scheduler::EventKey next_key = m_events->peek_next_key ();
m_events->remove_next ();
TRACE ("handle " << next_ev);
- m_current_ns = next_key.m_ns;
- m_current_uid = next_key.m_uid;
- if (m_log_enable) {
+ m_currentNs = next_key.m_ns;
+ m_currentUid = next_key.m_uid;
+ if (m_logEnable) {
m_log << "e "<<next_key.m_uid << " " << next_key.m_ns << std::endl;
}
next_ev->invoke ();
@@ -149,7 +149,7 @@
SimulatorPrivate::run (void)
{
while (!m_events->is_empty () && !m_stop &&
- (m_stop_at == 0 || m_stop_at > next ().ns ())) {
+ (m_stopAt == 0 || m_stopAt > next ().ns ())) {
process_one_event ();
}
m_log.close ();
@@ -164,15 +164,15 @@
void
SimulatorPrivate::stop_at (Time at)
{
- m_stop_at = at.ns ();
+ m_stopAt = at.ns ();
}
EventId
SimulatorPrivate::schedule (Time time, EventImpl *event)
{
if (time.is_destroy ()) {
m_destroy.push_back (std::make_pair (event, m_uid));
- if (m_log_enable) {
- m_log << "id " << m_current_uid << " " << now ().ns () << " "
+ if (m_logEnable) {
+ m_log << "id " << m_currentUid << " " << now ().ns () << " "
<< m_uid << std::endl;
}
m_uid++;
@@ -181,8 +181,8 @@
}
assert (time.ns () >= now ().ns ());
Scheduler::EventKey key = {time.ns (), m_uid};
- if (m_log_enable) {
- m_log << "i "<<m_current_uid<<" "<<now ().ns ()<<" "
+ if (m_logEnable) {
+ m_log << "i "<<m_currentUid<<" "<<now ().ns ()<<" "
<<m_uid<<" "<<time.ns () << std::endl;
}
m_uid++;
@@ -191,7 +191,7 @@
Time
SimulatorPrivate::now (void) const
{
- return Time::abs_ns (m_current_ns);
+ return Time::abs_ns (m_currentNs);
}
void
@@ -200,8 +200,8 @@
Scheduler::EventKey key;
EventImpl *impl = m_events->remove (ev, &key);
delete impl;
- if (m_log_enable) {
- m_log << "r " << m_current_uid << " " << now ().ns () << " "
+ if (m_logEnable) {
+ m_log << "r " << m_currentUid << " " << now ().ns () << " "
<< key.m_uid << " " << key.m_ns << std::endl;
}
}
@@ -219,7 +219,7 @@
{
if (ev.get_event_impl () != 0 &&
ev.get_ns () <= now ().ns () &&
- ev.get_uid () < m_current_uid) {
+ ev.get_uid () < m_currentUid) {
return false;
}
return true;
@@ -238,27 +238,27 @@
namespace ns3 {
SimulatorPrivate *Simulator::m_priv = 0;
-Simulator::ListType Simulator::m_list_type = LINKED_LIST;
-SchedulerFactory const*Simulator::m_sched_factory = 0;
+Simulator::ListType Simulator::m_listType = LINKED_LIST;
+SchedulerFactory const*Simulator::m_schedFactory = 0;
void Simulator::set_linked_list (void)
{
- m_list_type = LINKED_LIST;
+ m_listType = LINKED_LIST;
}
void Simulator::set_binary_heap (void)
{
- m_list_type = BINARY_HEAP;
+ m_listType = BINARY_HEAP;
}
void Simulator::set_std_map (void)
{
- m_list_type = STD_MAP;
+ m_listType = STD_MAP;
}
void
Simulator::set_external (SchedulerFactory const*factory)
{
assert (factory != 0);
- m_sched_factory = factory;
- m_list_type = EXTERNAL;
+ m_schedFactory = factory;
+ m_listType = EXTERNAL;
}
void Simulator::enable_log_to (char const *filename)
{
@@ -271,7 +271,7 @@
{
if (m_priv == 0) {
Scheduler *events;
- switch (m_list_type) {
+ switch (m_listType) {
case LINKED_LIST:
events = new SchedulerList ();
break;
@@ -282,7 +282,7 @@
events = new SchedulerMap ();
break;
case EXTERNAL:
- events = m_sched_factory->create ();
+ events = m_schedFactory->create ();
default: // not reached
events = 0;
assert (false);
@@ -382,7 +382,7 @@
bool m_a;
bool m_c;
bool m_d;
- EventId m_id_c;
+ EventId m_idC;
};
SimulatorTests::SimulatorTests ()
@@ -403,7 +403,7 @@
} else {
m_b = true;
}
- Simulator::remove (m_id_c);
+ Simulator::remove (m_idC);
Simulator::schedule (Time::rel_us (10), &SimulatorTests::d, this, 4);
}
void
@@ -430,7 +430,7 @@
m_d = false;
EventId a = Simulator::schedule (Time::abs_us (10), &SimulatorTests::a, this, 1);
EventId b = Simulator::schedule (Time::abs_us (11), &SimulatorTests::b, this, 2);
- m_id_c = Simulator::schedule (Time::abs_us (12), &SimulatorTests::c, this, 3);
+ m_idC = Simulator::schedule (Time::abs_us (12), &SimulatorTests::c, this, 3);
Simulator::cancel (a);
Simulator::run ();
--- a/src/simulator/simulator.h Tue Sep 05 11:23:39 2006 +0200
+++ b/src/simulator/simulator.h Tue Sep 05 12:54:53 2006 +0200
@@ -480,13 +480,13 @@
static SimulatorPrivate *get_priv (void);
static EventId schedule (Time time, EventImpl *event);
static SimulatorPrivate *m_priv;
- static SchedulerFactory const*m_sched_factory;
+ static SchedulerFactory const*m_schedFactory;
static enum ListType {
LINKED_LIST,
BINARY_HEAP,
STD_MAP,
EXTERNAL
- } m_list_type;
+ } m_listType;
};
}; // namespace ns3
--- a/src/simulator/time.cc Tue Sep 05 11:23:39 2006 +0200
+++ b/src/simulator/time.cc Tue Sep 05 12:54:53 2006 +0200
@@ -25,22 +25,22 @@
Time::Time ()
: m_ns (0),
- m_is_destroy (true)
+ m_isDestroy (true)
{}
Time::Time (Time const &o)
: m_ns (o.m_ns),
- m_is_destroy (o.m_is_destroy)
+ m_isDestroy (o.m_isDestroy)
{}
Time &
Time::operator = (Time const &o)
{
m_ns = o.m_ns;
- m_is_destroy = o.m_is_destroy;
+ m_isDestroy = o.m_isDestroy;
return *this;
}
Time::Time (uint64_t ns)
: m_ns (ns),
- m_is_destroy (false)
+ m_isDestroy (false)
{}
double
@@ -66,7 +66,7 @@
bool
Time::is_destroy (void) const
{
- return m_is_destroy;
+ return m_isDestroy;
}
Time
--- a/src/simulator/time.h Tue Sep 05 11:23:39 2006 +0200
+++ b/src/simulator/time.h Tue Sep 05 12:54:53 2006 +0200
@@ -46,7 +46,7 @@
Time ();
private:
uint64_t m_ns;
- bool m_is_destroy;
+ bool m_isDestroy;
};
--- a/utils/replay-simulation.cc Tue Sep 05 11:23:39 2006 +0200
+++ b/utils/replay-simulation.cc Tue Sep 05 12:54:53 2006 +0200
@@ -48,15 +48,15 @@
union {
struct {
// time at which the event is supposed to expire
- uint64_t m_ev_us;
+ uint64_t m_evUs;
} insert;
struct {
// location in the array of events to remove where
// to insert this event once it is inserted in
// the scheduler.
- uint32_t m_ev_loc;
+ uint32_t m_evLoc;
// time at which the event is supposed to expire
- uint64_t m_ev_us;
+ uint64_t m_evUs;
} insert_remove;
};
};
@@ -69,7 +69,7 @@
Commands m_commands;
CommandsI m_command;
- RemoveEvents m_remove_events;
+ RemoveEvents m_removeEvents;
uint32_t m_uid;
};
@@ -93,7 +93,7 @@
struct Command cmd;
cmd.m_type = Command::INSERT;
cmd.m_uid = now_uid;
- cmd.insert.m_ev_us = ev_us;
+ cmd.insert.m_evUs = ev_us;
m_commands.push_back (cmd);
} else if (type == "r") {
uint32_t now_uid, ev_uid;
@@ -122,12 +122,12 @@
for (RemovesI j = removes.begin (); j != removes.end (); j++) {
if (j->second == i->m_uid) {
// this insert will be removed later.
- uint64_t us = i->insert.m_ev_us;
+ uint64_t us = i->insert.m_evUs;
uint32_t uid = i->m_uid;
i->m_type = Command::INSERT_REMOVE;
i->m_uid = uid;
- i->insert_remove.m_ev_us = us;
- i->insert_remove.m_ev_loc = j->first;
+ i->insert_remove.m_evUs = us;
+ i->insert_remove.m_evLoc = j->first;
break;
}
}
@@ -140,8 +140,8 @@
uint32_t loc = 0;
for (CommandsI tmp = i; tmp != m_commands.end (); tmp++) {
if (tmp->m_type == Command::REMOVE &&
- tmp->m_uid == i->insert_remove.m_ev_loc) {
- i->insert_remove.m_ev_loc = loc;
+ tmp->m_uid == i->insert_remove.m_evLoc) {
+ i->insert_remove.m_evLoc = loc;
break;
}
loc++;
@@ -163,8 +163,8 @@
switch (cmd.m_type) {
case Command::INSERT:
//std::cout << "exec insert now=" << Simulator::now_us ()
- //<< ", time=" << cmd.insert.m_ev_us << std::endl;
- Simulator::schedule_abs_us (cmd.insert.m_ev_us,
+ //<< ", time=" << cmd.insert.m_evUs << std::endl;
+ Simulator::schedule_abs_us (cmd.insert.m_evUs,
make_event (&LogReader::execute_log_commands, this, m_uid));
m_uid++;
break;
@@ -175,15 +175,15 @@
break;
case Command::REMOVE: {
//std::cout << "exec remove" << std::endl;
- Event ev = m_remove_events.front ();
- m_remove_events.pop_front ();
+ Event ev = m_removeEvents.front ();
+ m_removeEvents.pop_front ();
Simulator::remove (ev);
} break;
case Command::INSERT_REMOVE: {
//std::cout << "exec insert remove" << std::endl;
Event ev = make_event (&LogReader::execute_log_commands, this, m_uid);
- Simulator::schedule_abs_us (cmd.insert_remove.m_ev_us, ev);
- m_remove_events[cmd.insert_remove.m_ev_loc] = ev;
+ Simulator::schedule_abs_us (cmd.insert_remove.m_evUs, ev);
+ m_removeEvents[cmd.insert_remove.m_evLoc] = ev;
m_uid++;
} break;
}