F5/unison
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix coding style

Browse Source
This commit is contained in:
Mathieu Lacage
2006-10-21 11:35:02 +02:00
parent 7ea80521bb
commit df7747bbe6
13 changed files with 468 additions and 293 deletions
Download Patch File Download Diff File Expand all files Collapse all files

244
src/common/buffer.cc
View File

@@ -34,9 +34,10 @@ uint32_t Buffer::m_maxTotalAddEnd = 0;
struct Buffer::BufferData *
Buffer::Allocate (uint32_t reqSize, uint32_t reqStart)
{
if (reqSize == 0) {
if (reqSize == 0)
{
reqSize = 1;
}
}
assert (reqSize >= 1);
uint32_t size = reqSize - 1 + sizeof (struct Buffer::BufferData);
uint8_t *b = new uint8_t [size];
@@ -61,34 +62,40 @@ Buffer::Recycle (struct Buffer::BufferData *data)
{
assert (data->m_count == 0);
/* get rid of it if it is too small for later reuse. */
if (data->m_size < (Buffer::m_maxTotalAddStart + Buffer::m_maxTotalAddEnd)) {
if (data->m_size < (Buffer::m_maxTotalAddStart + Buffer::m_maxTotalAddEnd))
{
Buffer::Deallocate (data);
return;
}
}
/* feed into free list */
if (Buffer::m_freeList.size () > 1000) {
if (Buffer::m_freeList.size () > 1000)
{
Buffer::Deallocate (data);
} else {
}
else
{
Buffer::m_freeList.push_back (data);
}
}
}
Buffer::BufferData *
Buffer::Create (void)
{
/* try to find a buffer correctly sized. */
while (!Buffer::m_freeList.empty ()) {
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)) {
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_maxTotalAddStart+m_maxTotalAddEnd,
m_maxTotalAddStart);
assert (data->m_count == 1);
@@ -122,57 +129,70 @@ Buffer::AddAtStart (uint32_t start)
{
assert (m_start <= m_data->m_initialStart);
bool isDirty = m_data->m_count > 1 && m_start > m_data->m_dirtyStart;
if (m_start >= start && !isDirty) {
if (m_start >= start && !isDirty)
{
/* enough space in the buffer and not dirty. */
m_start -= start;
m_size += start;
} else if (m_size + start <= m_data->m_size && !isDirty) {
}
else if (m_size + start <= m_data->m_size && !isDirty)
{
/* enough space but need to move data around to fit new data */
memmove (m_data->m_data + start, GetStart (), m_size);
assert (start > m_start);
m_data->m_initialStart += start;
m_start = 0;
m_size += start;
} else if (m_start < start) {
}
else if (m_start < start)
{
/* not enough space in buffer */
uint32_t newSize = m_size + start;
struct Buffer::BufferData *newData = Buffer::Allocate (newSize, 0);
memcpy (newData->m_data + start, GetStart (), m_size);
newData->m_initialStart = m_data->m_initialStart + start;
m_data->m_count--;
if (m_data->m_count == 0) {
if (m_data->m_count == 0)
{
Buffer::Deallocate (m_data);
}
}
m_data = newData;
m_start = 0;
m_size = newSize;
} else {
}
else
{
/* enough space in the buffer but it is dirty ! */
assert (isDirty);
struct Buffer::BufferData *newData = Buffer::Create ();
memcpy (newData->m_data + m_start, GetStart (), m_size);
newData->m_initialStart = m_data->m_initialStart;
m_data->m_count--;
if (m_data->m_count == 0) {
if (m_data->m_count == 0)
{
Recycle (m_data);
}
}
m_data = newData;
m_start -= start;
m_size += start;
}
}
// update dirty area
m_data->m_dirtyStart = m_start;
m_data->m_dirtySize = m_size;
// update m_maxTotalAddStart
uint32_t addedAtStart;
if (m_data->m_initialStart > m_start) {
if (m_data->m_initialStart > m_start)
{
addedAtStart = m_data->m_initialStart - m_start;
} else {
}
else
{
addedAtStart = 0;
}
if (addedAtStart > m_maxTotalAddStart) {
}
if (addedAtStart > m_maxTotalAddStart)
{
m_maxTotalAddStart = addedAtStart;
}
}
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);
@@ -183,10 +203,13 @@ Buffer::AddAtEnd (uint32_t end)
assert (m_start <= m_data->m_initialStart);
bool isDirty = m_data->m_count > 1 &&
m_start + m_size < m_data->m_dirtyStart + m_data->m_dirtySize;
if (m_start + m_size + end <= m_data->m_size && !isDirty) {
if (m_start + m_size + end <= m_data->m_size && !isDirty)
{
/* enough space in buffer and not dirty */
m_size += end;
} else if (m_size + end <= m_data->m_size && !isDirty) {
}
else if (m_size + end <= m_data->m_size && !isDirty)
{
/* enough space but need to move data around to fit the extra data */
uint32_t newStart = m_data->m_size - (m_size + end);
memmove (m_data->m_data + newStart, GetStart (), m_size);
@@ -194,46 +217,56 @@ Buffer::AddAtEnd (uint32_t end)
m_data->m_initialStart -= m_start - newStart;
m_start = newStart;
m_size += end;
} else if (m_start + m_size + end > m_data->m_size) {
}
else if (m_start + m_size + end > m_data->m_size)
{
/* not enough space in buffer */
uint32_t newSize = m_size + end;
struct Buffer::BufferData *newData = Buffer::Allocate (newSize, 0);
memcpy (newData->m_data, GetStart (), m_size);
newData->m_initialStart = m_data->m_initialStart;
m_data->m_count--;
if (m_data->m_count == 0) {
if (m_data->m_count == 0)
{
Buffer::Deallocate (m_data);
}
}
m_data = newData;
m_size = newSize;
m_start = 0;
} else {
}
else
{
/* enough space in the buffer but it is dirty ! */
assert (isDirty);
struct Buffer::BufferData *newData = Buffer::Create ();
memcpy (newData->m_data + m_start, GetStart (), m_size);
newData->m_initialStart = m_data->m_initialStart;
m_data->m_count--;
if (m_data->m_count == 0) {
if (m_data->m_count == 0)
{
Recycle (m_data);
}
}
m_data = newData;
m_size += end;
}
}
// update dirty area
m_data->m_dirtyStart = m_start;
m_data->m_dirtySize = m_size;
// update m_maxTotalAddEnd
uint32_t endLoc = m_start + m_size;
uint32_t addedAtEnd;
if (m_data->m_initialStart < endLoc) {
if (m_data->m_initialStart < endLoc)
{
addedAtEnd = endLoc - m_data->m_initialStart;
} else {
}
else
{
addedAtEnd = 0;
}
if (addedAtEnd > m_maxTotalAddEnd) {
}
if (addedAtEnd > m_maxTotalAddEnd)
{
m_maxTotalAddEnd = addedAtEnd;
}
}
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);
@@ -242,83 +275,110 @@ Buffer::AddAtEnd (uint32_t end)
void
Buffer::RemoveAtStart (uint32_t start)
{
if (m_zeroAreaSize == 0) {
if (m_size <= start) {
if (m_zeroAreaSize == 0)
{
if (m_size <= start)
{
m_start += m_size;
m_size = 0;
} else {
}
else
{
m_start += start;
m_size -= start;
}
} else {
}
}
else
{
assert (m_data->m_initialStart >= m_start);
uint32_t zeroStart = m_data->m_initialStart - m_start;
uint32_t zeroEnd = zeroStart + m_zeroAreaSize;
uint32_t dataEnd = m_size + m_zeroAreaSize;
if (start <= zeroStart) {
if (start <= zeroStart)
{
/* only remove start of buffer */
m_start += start;
m_size -= start;
} else if (start <= zeroEnd) {
}
else if (start <= zeroEnd)
{
/* remove start of buffer _and_ start of zero area */
m_start += zeroStart;
uint32_t zeroDelta = start - zeroStart;
m_zeroAreaSize -= zeroDelta;
assert (zeroDelta <= start);
m_size -= zeroStart;
} else if (start <= dataEnd) {
}
else if (start <= dataEnd)
{
/* remove start of buffer, complete zero area, and part
* of end of buffer */
m_start += start - m_zeroAreaSize;
m_size -= start - m_zeroAreaSize;
m_zeroAreaSize = 0;
} else {
}
else
{
/* remove all buffer */
m_start += m_size;
m_size = 0;
m_zeroAreaSize = 0;
}
}
TRACE ("start remove="<<start<<", start="<<m_start<<", size="<<m_size<<", zero="<<m_zeroAreaSize<<
}
}
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::RemoveAtEnd (uint32_t end)
{
if (m_zeroAreaSize == 0) {
if (m_size <= end) {
if (m_zeroAreaSize == 0)
{
if (m_size <= end)
{
m_size = 0;
} else {
}
else
{
m_size -= end;
}
} else {
}
}
else
{
assert (m_data->m_initialStart >= m_start);
uint32_t zeroStart = m_data->m_initialStart - m_start;
uint32_t zeroEnd = zeroStart + m_zeroAreaSize;
uint32_t dataEnd = m_size + m_zeroAreaSize;
assert (zeroStart <= m_size);
assert (zeroEnd <= m_size + m_zeroAreaSize);
if (dataEnd <= end) {
if (dataEnd <= end)
{
/* remove all buffer */
m_zeroAreaSize = 0;
m_start += m_size;
m_size = 0;
} else if (dataEnd - zeroStart <= end) {
}
else if (dataEnd - zeroStart <= end)
{
/* remove end of buffer, zero area, part of start of buffer */
assert (end >= m_zeroAreaSize);
m_size -= end - m_zeroAreaSize;
m_zeroAreaSize = 0;
} else if (dataEnd - zeroEnd <= end) {
}
else if (dataEnd - zeroEnd <= end)
{
/* remove end of buffer, part of zero area */
uint32_t zeroDelta = end - (dataEnd - zeroEnd);
m_zeroAreaSize -= zeroDelta;
m_size -= end - zeroDelta;
} else {
}
else
{
/* remove part of end of buffer */
m_size -= end;
}
}
}
}
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);
@@ -331,9 +391,10 @@ Buffer::CreateFragment (uint32_t start, uint32_t length) const
uint32_t zeroEnd = zeroStart + m_zeroAreaSize;
if (m_zeroAreaSize != 0 &&
start + length > zeroStart &&
start <= zeroEnd) {
start <= zeroEnd)
{
TransformIntoRealBuffer ();
}
}
Buffer tmp = *this;
tmp.RemoveAtStart (start);
tmp.RemoveAtEnd (GetSize () - (start + length));
@@ -343,7 +404,8 @@ Buffer::CreateFragment (uint32_t start, uint32_t length) const
void
Buffer::TransformIntoRealBuffer (void) const
{
if (m_zeroAreaSize != 0) {
if (m_zeroAreaSize != 0)
{
assert (m_data->m_initialStart >= m_start);
assert (m_size >= (m_data->m_initialStart - m_start));
Buffer tmp;
@@ -358,7 +420,7 @@ Buffer::TransformIntoRealBuffer (void) const
i.Prev (dataEnd);
i.Write (m_data->m_data+m_data->m_initialStart,dataEnd);
*const_cast<Buffer *> (this) = tmp;
}
}
}
@@ -401,27 +463,32 @@ BufferTest::EnsureWrittenBytes (Buffer b, uint32_t n, uint8_t array[])
uint8_t *expected = array;
uint8_t const*got;
got = b.PeekData ();
for (uint32_t j = 0; j < n; j++) {
if (got[j] != expected[j]) {
for (uint32_t j = 0; j < n; j++)
{
if (got[j] != expected[j])
{
success = false;
}
}
if (!success) {
}
}
if (!success)
{
Failure () << "Buffer -- ";
Failure () << "expected: n=";
Failure () << n << ", ";
Failure ().setf (std::ios::hex, std::ios::basefield);
for (uint32_t j = 0; j < n; j++) {
for (uint32_t j = 0; j < n; j++)
{
Failure () << (uint16_t)expected[j] << " ";
}
}
Failure ().setf (std::ios::dec, std::ios::basefield);
Failure () << "got: ";
Failure ().setf (std::ios::hex, std::ios::basefield);
for (uint32_t j = 0; j < n; j++) {
for (uint32_t j = 0; j < n; j++)
{
Failure () << (uint16_t)got[j] << " ";
}
}
Failure () << std::endl;
}
}
return success;
}
@@ -429,13 +496,14 @@ BufferTest::EnsureWrittenBytes (Buffer b, uint32_t n, uint8_t array[])
* available which is the case for gcc.
* XXX
*/
#define ENSURE_WRITTEN_BYTES(buffer, n, ...) \
{ \
uint8_t bytes[] = {__VA_ARGS__}; \
if (!EnsureWrittenBytes (buffer, n , bytes)) { \
ok = false; \
} \
}
#define ENSURE_WRITTEN_BYTES(buffer, n, ...) \
{ \
uint8_t bytes[] = {__VA_ARGS__}; \
if (!EnsureWrittenBytes (buffer, n , bytes)) \
{ \
ok = false; \
} \
}
bool
BufferTest::RunTests (void)
@@ -485,9 +553,10 @@ BufferTest::RunTests (void)
i.Prev (2);
i.WriteHtonU16 (0xff00);
i.Prev (2);
if (i.ReadNtohU16 () != 0xff00) {
if (i.ReadNtohU16 () != 0xff00)
{
ok = false;
}
}
i.Prev (2);
i.WriteU16 (saved);
ENSURE_WRITTEN_BYTES (buffer, 5, 0xff, 0x69, 0xde, 0xad, 0xff);
@@ -574,9 +643,10 @@ BufferTest::RunTests (void)
buffer.Begin ().WriteU8 (0x21);
ENSURE_WRITTEN_BYTES (buffer, 6, 0x21, 0, 0, 0, 0xab, 0xcd);
buffer.RemoveAtEnd (8);
if (buffer.GetSize () != 0) {
if (buffer.GetSize () != 0)
{
ok = false;
}
}

34
src/common/buffer.h
View File

@@ -371,9 +371,10 @@ Buffer::Buffer ()
m_start (m_maxTotalAddStart),
m_size (0)
{
if (m_start > m_data->m_size) {
if (m_start > m_data->m_size)
{
m_start = 0;
}
}
assert (m_start <= m_data->m_size);
}
@@ -383,9 +384,10 @@ Buffer::Buffer (uint32_t dataSize)
m_start (m_maxTotalAddStart),
m_size (0)
{
if (m_start > m_data->m_size) {
if (m_start > m_data->m_size)
{
m_start = 0;
}
}
assert (m_start <= m_data->m_size);
}
@@ -403,15 +405,17 @@ Buffer::Buffer (Buffer const&o)
Buffer &
Buffer::operator = (Buffer const&o)
{
if (m_data != o.m_data) {
if (m_data != o.m_data)
{
// not assignment to self.
m_data->m_count--;
if (m_data->m_count == 0) {
if (m_data->m_count == 0)
{
Recycle (m_data);
}
}
m_data = o.m_data;
m_data->m_count++;
}
}
m_zeroAreaSize = o.m_zeroAreaSize;
m_start = o.m_start;
m_size = o.m_size;
@@ -422,9 +426,10 @@ Buffer::operator = (Buffer const&o)
Buffer::~Buffer ()
{
m_data->m_count--;
if (m_data->m_count == 0) {
if (m_data->m_count == 0)
{
Recycle (m_data);
}
}
}
@@ -520,11 +525,14 @@ Buffer::Iterator::GetIndex (uint32_t n)
(m_current >= m_zeroEnd))
);
uint32_t index;
if (m_current < m_zeroStart) {
if (m_current < m_zeroStart)
{
index = m_current;
} else {
}
else
{
index = m_current - (m_zeroEnd-m_zeroStart);
}
}
return index;
}

30
src/common/callback-tracer.h
View File

@@ -45,34 +45,40 @@ public:
m_callback = callback;
}
void operator() (void) {
if (!m_callback.IsNull ()) {
if (!m_callback.IsNull ())
{
m_callback ();
}
}
}
void operator() (T1 a1) {
if (!m_callback.IsNull ()) {
if (!m_callback.IsNull ())
{
m_callback (a1);
}
}
}
void operator() (T1 a1, T2 a2) {
if (!m_callback.IsNull ()) {
if (!m_callback.IsNull ())
{
m_callback (a1,a2);
}
}
}
void operator() (T1 a1, T2 a2, T3 a3) {
if (!m_callback.IsNull ()) {
if (!m_callback.IsNull ())
{
m_callback (a1,a2,a3);
}
}
}
void operator() (T1 a1, T2 a2, T3 a3, T4 a4) {
if (!m_callback.IsNull ()) {
if (!m_callback.IsNull ())
{
m_callback (a1,a2,a3,a4);
}
}
}
void operator() (T1 a1, T2 a2, T3 a3, T4 a4,T5 a5) {
if (!m_callback.IsNull ()) {
if (!m_callback.IsNull ())
{
m_callback (a1,a2,a3,a4,a5);
}
}
}
private:

10
src/common/data-writer.cc
View File

@@ -81,19 +81,21 @@ DataWriterPrivate::Open (char const *filename)
void
DataWriterPrivate::Write (uint8_t *buffer, uint32_t size)
{
while (size > 0) {
while (size > 0)
{
uint32_t toCopy = min (BUFFER_SIZE - m_current, size);
memcpy (m_data + m_current, buffer, toCopy);
size -= toCopy;
m_current += toCopy;
buffer += toCopy;
if (m_current == BUFFER_SIZE) {
if (m_current == BUFFER_SIZE)
{
ssize_t written = 0;
written = ::Write (m_fd, m_data, BUFFER_SIZE);
assert (written == BUFFER_SIZE);
m_current = 0;
}
}
}
}
}
DataWriter::DataWriter ()

5
src/common/pcap-writer.cc
View File

@@ -67,7 +67,8 @@ PcapWriter::WriteHeaderEthernet (void)
void
PcapWriter::WritePacket (Packet const packet)
{
if (m_writer != 0) {
if (m_writer != 0)
{
uint64_t current = Simulator::Now ().Us ();
uint64_t s = current / 1000000;
uint64_t us = current % 1000000;
@@ -76,7 +77,7 @@ PcapWriter::WritePacket (Packet const packet)
Write32 (packet.GetSize ());
Write32 (packet.GetSize ());
m_writer->Write (packet.PeekData (), packet.GetSize ());
}
}
}
void

5
src/common/si-variable-tracer.h
View File

@@ -44,9 +44,10 @@ public:
}
protected:
void Notify (int64_t oldVal, int64_t newVal) {
if (oldVal != newVal && !m_callback.IsNull ()) {
if (oldVal != newVal && !m_callback.IsNull ())
{
m_callback (oldVal, newVal);
}
}
}
private:
ChangeNotifyCallback m_callback;

15
src/common/stream-tracer.h
View File

@@ -38,22 +38,25 @@ public:
: m_os (0) {}
template <typename T>
StreamTracer &operator << (T const&v) {
if (m_os != 0) {
if (m_os != 0)
{
(*m_os) << v;
}
}
return *this;
}
template <typename T>
StreamTracer &operator << (T &v) {
if (m_os != 0) {
if (m_os != 0)
{
(*m_os) << v;
}
}
return *this;
}
StreamTracer &operator << (std::ostream &(*v) (std::ostream &)) {
if (m_os != 0) {
if (m_os != 0)
{
(*m_os) << v;
}
}
return *this;
}

114
src/common/tags.cc
View File

@@ -36,18 +36,21 @@ TagRegistry::Record (std::string uuid, PrettyPrinter prettyPrinter)
uint32_t
TagRegistry::LookupUid (std::string uuid)
{
if (!m_sorted) {
if (!m_sorted)
{
std::sort (m_registry.begin (), m_registry.end ());
m_sorted = true;
}
}
assert (m_sorted);
uint32_t uid = 0;
for (TagsDataCI i = m_registry.begin (); i != m_registry.end (); i++) {
if (i->first == uuid) {
for (TagsDataCI i = m_registry.begin (); i != m_registry.end (); i++)
{
if (i->first == uuid)
{
return uid;
}
}
uid++;
}
}
// someone asked for a uid for an unregistered uuid.
assert ("You tried to use unregistered tag: make sure you create an "
"instance of type TagRegistration<YouTagType>.");
@@ -59,9 +62,10 @@ TagRegistry::PrettyPrint (uint32_t uid, uint8_t buf[Tags::SIZE], std::ostream &o
{
assert (m_registry.size () > uid);
PrettyPrinter prettyPrinter = m_registry[uid].second;
if (prettyPrinter != 0) {
if (prettyPrinter != 0)
{
prettyPrinter (buf, os);
}
}
}
@@ -74,23 +78,27 @@ struct Tags::TagData *
Tags::AllocData (void)
{
struct Tags::TagData *retval;
if (gFree != 0) {
if (gFree != 0)
{
retval = gFree;
gFree = gFree->m_next;
gN_free--;
} else {
}
else
{
retval = new struct Tags::TagData ();
}
}
return retval;
}
void
Tags::FreeData (struct TagData *data)
{
if (gN_free > 1000) {
if (gN_free > 1000)
{
delete data;
return;
}
}
gN_free++;
data->m_next = gFree;
gFree = data;
@@ -115,18 +123,23 @@ bool
Tags::Remove (uint32_t id)
{
bool found = false;
for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next) {
if (cur->m_id == id) {
for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next)
{
if (cur->m_id == id)
{
found = true;
}
}
if (!found) {
}
}
if (!found)
{
return false;
}
}
struct TagData *start = 0;
struct TagData **prevNext = &start;
for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next) {
if (cur->m_id == id) {
for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next)
{
if (cur->m_id == id)
{
/**
* XXX
* Note: I believe that we could optimize this to
@@ -134,7 +147,7 @@ Tags::Remove (uint32_t id)
* and just link the already-copied list to the next tag.
*/
continue;
}
}
struct TagData *copy = AllocData ();
copy->m_id = cur->m_id;
copy->m_count = 1;
@@ -142,7 +155,7 @@ Tags::Remove (uint32_t id)
memcpy (copy->m_data, cur->m_data, Tags::SIZE);
*prevNext = copy;
prevNext = &copy->m_next;
}
}
*prevNext = 0;
RemoveAll ();
m_next = start;
@@ -152,9 +165,10 @@ Tags::Remove (uint32_t id)
void
Tags::PrettyPrint (std::ostream &os)
{
for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next) {
for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next)
{
TagRegistry::PrettyPrint (cur->m_id, cur->m_data, os);
}
}
}
@@ -228,18 +242,20 @@ TagsTest::RunTests (void)
tags.Add (a);
a.a = 0;
tags.Peek (a);
if (a.a != 10) {
if (a.a != 10)
{
ok = false;
}
}
//tags.prettyPrint (std::cout);
struct myTagB b;
b.b = 0xff;
tags.Add (b);
b.b = 0;
tags.Peek (b);
if (b.b != 0xff) {
if (b.b != 0xff)
{
ok = false;
}
}
//tags.prettyPrint (std::cout);
// make sure copy contains copy.
@@ -249,30 +265,36 @@ TagsTest::RunTests (void)
struct myTagA oA;
oA.a = 0;
other.Peek (oA);
if (oA.a != 10) {
if (oA.a != 10)
{
ok = false;
}
}
struct myTagB oB;
other.Peek (oB);
if (oB.b != 0xff) {
if (oB.b != 0xff)
{
ok = false;
}
}
// remove data.
other.Remove (oA);
if (other.Peek (oA)) {
if (other.Peek (oA))
{
ok = false;
}
}
//other.prettyPrint (std::cout);
if (!tags.Peek (oA)) {
if (!tags.Peek (oA))
{
ok = false;
}
}
other.Remove (oB);
if (other.Peek (oB)) {
if (other.Peek (oB))
{
ok = false;
}
if (!tags.Peek (oB)) {
}
if (!tags.Peek (oB))
{
ok = false;
}
}
other = tags;
Tags another = other;
@@ -281,12 +303,14 @@ TagsTest::RunTests (void)
another.Add (c);
c.c[0] = 0;
another.Peek (c);
if (!another.Peek (c)) {
if (!another.Peek (c))
{
ok = false;
}
if (tags.Peek (c)) {
}
if (tags.Peek (c))
{
ok = false;
}
}
other = other;
//other.prettyPrint (std::cout);

50
src/common/tags.h
View File

@@ -202,9 +202,10 @@ Tags::Add (T const&tag)
assert (sizeof (T) <= Tags::SIZE);
uint8_t const*buf = reinterpret_cast<uint8_t const*> (&tag);
// ensure this id was not yet added
for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next) {
for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next)
{
assert (cur->m_id != TypeUid<T>::GetUid ());
}
}
struct TagData *newStart = AllocData ();
newStart->m_count = 1;
newStart->m_next = 0;
@@ -228,13 +229,15 @@ Tags::Peek (T &tag) const
{
assert (sizeof (T) <= Tags::SIZE);
uint8_t *buf = reinterpret_cast<uint8_t *> (&tag);
for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next) {
if (cur->m_id == TypeUid<T>::GetUid ()) {
for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next)
{
if (cur->m_id == TypeUid<T>::GetUid ())
{
/* found tag */
memcpy (buf, cur->m_data, sizeof (T));
return true;
}
}
}
}
/* no tag found */
return false;
}
@@ -246,23 +249,26 @@ Tags::Tags ()
Tags::Tags (Tags const &o)
: m_next (o.m_next)
{
if (m_next != 0) {
if (m_next != 0)
{
m_next->m_count++;
}
}
}
Tags &
Tags::operator = (Tags const &o)
{
// self assignment
if (m_next == o.m_next) {
if (m_next == o.m_next)
{
return *this;
}
}
RemoveAll ();
m_next = o.m_next;
if (m_next != 0) {
if (m_next != 0)
{
m_next->m_count++;
}
}
return *this;
}
@@ -275,19 +281,23 @@ void
Tags::RemoveAll (void)
{
struct TagData *prev = 0;
for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next) {
for (struct TagData *cur = m_next; cur != 0; cur = cur->m_next)
{
cur->m_count--;
if (cur->m_count > 0) {
if (cur->m_count > 0)
{
break;
}
if (prev != 0) {
}
if (prev != 0)
{
FreeData (prev);
}
}
prev = cur;
}
if (prev != 0) {
}
if (prev != 0)
{
FreeData (prev);
}
}
m_next = 0;
}

110
src/common/trace-container.cc
View File

@@ -38,23 +38,27 @@ TraceContainer::~TraceContainer ()
void
TraceContainer::SetUiVariableCallback (char const *name, Callback<void,uint64_t, uint64_t> callback)
{
for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++) {
if ((*i).second == name) {
for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++)
{
if ((*i).second == name)
{
(*i).first->SetCallback (callback);
return;
}
}
}
}
assert (false);
}
void
TraceContainer::SetSiVariableCallback (char const *name, Callback<void,int64_t, int64_t> callback)
{
for (SiListI i = m_siList.begin (); i != m_siList.end (); i++) {
if ((*i).second == name) {
for (SiListI i = m_siList.begin (); i != m_siList.end (); i++)
{
if ((*i).second == name)
{
(*i).first->SetCallback (callback);
return;
}
}
}
}
assert (false);
}
void
@@ -65,12 +69,14 @@ TraceContainer::SetFVariableCallback (char const *name, Callback<void,double, do
void
TraceContainer::SetStream (char const *name, std::ostream *os)
{
for (StreamTracerListI i = m_traceStreamList.begin (); i != m_traceStreamList.end (); i++) {
if ((*i).second == name) {
for (StreamTracerListI i = m_traceStreamList.begin (); i != m_traceStreamList.end (); i++)
{
if ((*i).second == name)
{
(*i).first->SetStream (os);
return;
}
}
}
}
assert (false);
}
@@ -78,24 +84,28 @@ void
TraceContainer::RegisterUiVariable (char const *name, UiVariableTracerBase *var)
{
// ensure unicity
for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++) {
if (i->second == name) {
for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++)
{
if (i->second == name)
{
m_uiList.erase (i);
break;
}
}
}
}
m_uiList.push_back (std::make_pair (var, name));
}
void
TraceContainer::RegisterSiVariable (char const *name, SiVariableTracerBase *var)
{
// ensure unicity
for (SiListI i = m_siList.begin (); i != m_siList.end (); i++) {
if (i->second == name) {
for (SiListI i = m_siList.begin (); i != m_siList.end (); i++)
{
if (i->second == name)
{
m_siList.erase (i);
break;
}
}
}
}
m_siList.push_back (std::make_pair (var, name));
}
void
@@ -108,12 +118,14 @@ void
TraceContainer::RegisterStream (char const *name, StreamTracer *stream)
{
// ensure unicity
for (StreamTracerListI i = m_traceStreamList.begin (); i != m_traceStreamList.end (); i++) {
if (i->second == name) {
for (StreamTracerListI i = m_traceStreamList.begin (); i != m_traceStreamList.end (); i++)
{
if (i->second == name)
{
m_traceStreamList.erase (i);
break;
}
}
}
}
m_traceStreamList.push_back (std::make_pair (stream,name));
}
@@ -121,12 +133,14 @@ TraceContainer::RegisterStream (char const *name, StreamTracer *stream)
void
TraceContainer::RegisterCallback (char const *name, CallbackTracerBase *tracer)
{
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++)
{
if (i->second == name)
{
m_callbackList.erase (i);
break;
}
}
}
}
m_callbackList.push_back (std::make_pair (tracer, name));
}
@@ -139,28 +153,36 @@ TraceContainer::RegisterCallback (char const *name, CallbackTracerBase *tracer)
void
ns3::TraceContainer::PrintDebug (void)
{
if (!m_uiList.empty ()) {
if (!m_uiList.empty ())
{
std::cout << "ui var: " << std::endl;
for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++) {
for (UiListI i = m_uiList.begin (); i != m_uiList.end (); i++)
{
std::cout << " \"" << (*i).second << "\""<<std::endl;
}
}
if (!m_siList.empty ()) {
}
}
if (!m_siList.empty ())
{
std::cout << "si var: " << std::endl;
for (SiListI i = m_siList.begin (); i != m_siList.end (); i++) {
for (SiListI i = m_siList.begin (); i != m_siList.end (); i++)
{
std::cout << " \"" << (*i).second << "\""<<std::endl;
}
}
if (!m_fList.empty ()) {
}
}
if (!m_fList.empty ())
{
std::cout << "f var: " << std::endl;
for (FListI i = m_fList.begin (); i != m_fList.end (); i++) {
for (FListI i = m_fList.begin (); i != m_fList.end (); i++)
{
std::cout << " \"" << (*i).second << "\""<<std::endl;
}
}
if (!m_callbackList.empty ()) {
}
}
if (!m_callbackList.empty ())
{
std::cout << "callback list: "<<std::endl;
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++)
{
std::cout << " \"" << i->second << "\""<<std::endl;
}
}
}
}
}

50
src/common/trace-container.h
View File

@@ -206,12 +206,14 @@ template <typename T1>
void
TraceContainer::SetCallback (char const *name, Callback<void,T1> callback)
{
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++)
{
if (i->second == name)
{
static_cast<CallbackTracer<T1> *> (i->first)->SetCallback (callback);
return;
}
}
}
}
#ifndef NDEBUG
assert (false);
#endif
@@ -220,12 +222,14 @@ template <typename T1, typename T2>
void
TraceContainer::SetCallback (char const *name, Callback<void,T1,T2> callback)
{
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++)
{
if (i->second == name)
{
static_cast<CallbackTracer<T1,T2> *> (i->first)->SetCallback (callback);
return;
}
}
}
}
#ifndef NDEBUG
assert (false);
#endif
@@ -234,12 +238,14 @@ template <typename T1, typename T2, typename T3>
void
TraceContainer::SetCallback (char const *name, Callback<void,T1,T2,T3> callback)
{
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++)
{
if (i->second == name)
{
static_cast<CallbackTracer<T1,T2,T3> *> (i->first)->SetCallback (callback);
return;
}
}
}
}
#ifndef NDEBUG
assert (false);
#endif
@@ -248,12 +254,14 @@ template <typename T1, typename T2, typename T3, typename T4>
void
TraceContainer::SetCallback (char const *name, Callback<void,T1,T2,T3,T4> callback)
{
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++)
{
if (i->second == name)
{
static_cast<CallbackTracer<T1,T2,T3,T4> *> (i->first)->SetCallback (callback);
return;
}
}
}
}
#ifndef NDEBUG
assert (false);
#endif
@@ -262,12 +270,14 @@ template <typename T1, typename T2, typename T3, typename T4, typename T5>
void
TraceContainer::SetCallback (char const *name, Callback<void,T1,T2,T3,T4,T5> callback)
{
for (CallbackListI i = m_callbackList.begin (); i != m_callbackList.end (); i++) {
if (i->second == name) {
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)->SetCallback (callback);
return;
}
}
}
}
#ifndef NDEBUG
assert (false);
#endif

5
src/common/ui-variable-tracer.h
View File

@@ -47,9 +47,10 @@ public:
}
protected:
void Notify (uint64_t oldVal, uint64_t newVal) {
if (oldVal != newVal && !m_callback.IsNull ()) {
if (oldVal != newVal && !m_callback.IsNull ())
{
m_callback (oldVal, newVal);
}
}
}
private:
ChangeNotifyCallback m_callback;

89
src/common/variable-tracer-test.cc
View File

@@ -51,44 +51,61 @@ VariableTracerTest::RunUnsignedTests (void)
var = 10;
ovar = var;
if (var == ovar) {
}
if (var != ovar) {
}
if (var > ovar) {
}
if (var >= ovar) {
}
if (var < ovar) {
}
if (var <= ovar) {
}
if (var == ovar)
{
}
if (var != ovar)
{
}
if (var > ovar)
{
}
if (var >= ovar)
{
}
if (var < ovar)
{
}
if (var <= ovar)
if (var == 1) {
}
if (var != 1) {
}
if (var > 1) {
}
if (var >= 1) {
}
if (var < 1) {
}
if (var <= 1) {
}
if (var == 1)
{
}
if (var != 1)
{
}
if (var > 1)
{
}
if (var >= 1)
{
}
if (var < 1)
{
}
if (var <= 1)
{
}
if (1 == ovar) {
}
if (1 != ovar) {
}
if (1 > ovar) {
}
if (1 >= ovar) {
}
if (1 < ovar) {
}
if (1 <= ovar) {
}
if (1 == ovar)
{
}
if (1 != ovar)
{
}
if (1 > ovar)
{
}
if (1 >= ovar)
{
}
if (1 < ovar)
{
}
if (1 <= ovar)
{
}
var++;
++var;