00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "tag-buffer.h"
00021 #include "ns3/assert.h"
00022 #include <string.h>
00023
00024 namespace ns3 {
00025
00026 #ifndef TAG_BUFFER_USE_INLINE
00027
00028 void
00029 TagBuffer::WriteU8 (uint8_t v)
00030 {
00031 NS_ASSERT (m_current + 1 <= m_end);
00032 *m_current = v;
00033 m_current++;
00034 }
00035
00036 void
00037 TagBuffer::WriteU16 (uint16_t data)
00038 {
00039 WriteU8 ((data >> 0) & 0xff);
00040 WriteU8 ((data >> 8) & 0xff);
00041 }
00042 void
00043 TagBuffer::WriteU32 (uint32_t data)
00044 {
00045 WriteU8 ((data >> 0) & 0xff);
00046 WriteU8 ((data >> 8) & 0xff);
00047 WriteU8 ((data >> 16) & 0xff);
00048 WriteU8 ((data >> 24) & 0xff);
00049 }
00050
00051
00052 uint8_t
00053 TagBuffer::ReadU8 (void)
00054 {
00055 NS_ASSERT (m_current + 1 <= m_end);
00056 uint8_t v;
00057 v = *m_current;
00058 m_current++;
00059 return v;
00060 }
00061
00062 uint16_t
00063 TagBuffer::ReadU16 (void)
00064 {
00065 uint8_t byte0 = ReadU8 ();
00066 uint8_t byte1 = ReadU8 ();
00067 uint16_t data = byte1;
00068 data <<= 8;
00069 data |= byte0;
00070 return data;
00071 }
00072 uint32_t
00073 TagBuffer::ReadU32 (void)
00074 {
00075 uint8_t byte0 = ReadU8 ();
00076 uint8_t byte1 = ReadU8 ();
00077 uint8_t byte2 = ReadU8 ();
00078 uint8_t byte3 = ReadU8 ();
00079 uint32_t data = byte3;
00080 data <<= 8;
00081 data |= byte2;
00082 data <<= 8;
00083 data |= byte1;
00084 data <<= 8;
00085 data |= byte0;
00086 return data;
00087 }
00088
00089 #endif
00090
00091
00092 void
00093 TagBuffer::WriteU64 (uint64_t data)
00094 {
00095 WriteU8 ((data >> 0) & 0xff);
00096 WriteU8 ((data >> 8) & 0xff);
00097 WriteU8 ((data >> 16) & 0xff);
00098 WriteU8 ((data >> 24) & 0xff);
00099 WriteU8 ((data >> 32) & 0xff);
00100 WriteU8 ((data >> 40) & 0xff);
00101 WriteU8 ((data >> 48) & 0xff);
00102 WriteU8 ((data >> 54) & 0xff);
00103 }
00104 void
00105 TagBuffer::WriteDouble (double v)
00106 {
00107 uint8_t *buf = (uint8_t *)&v;
00108 for (uint32_t i = 0; i < sizeof (double); ++i, ++buf)
00109 {
00110 WriteU8 (*buf);
00111 }
00112 }
00113 void
00114 TagBuffer::Write (const uint8_t *buffer, uint32_t size)
00115 {
00116 for (uint32_t i = 0; i < size; ++i, ++buffer)
00117 {
00118 WriteU8 (*buffer);
00119 }
00120 }
00121 uint64_t
00122 TagBuffer::ReadU64 (void)
00123 {
00124 uint8_t byte0 = ReadU8 ();
00125 uint8_t byte1 = ReadU8 ();
00126 uint8_t byte2 = ReadU8 ();
00127 uint8_t byte3 = ReadU8 ();
00128 uint8_t byte4 = ReadU8 ();
00129 uint8_t byte5 = ReadU8 ();
00130 uint8_t byte6 = ReadU8 ();
00131 uint8_t byte7 = ReadU8 ();
00132 uint32_t data = byte7;
00133 data <<= 8;
00134 data |= byte6;
00135 data <<= 8;
00136 data |= byte5;
00137 data <<= 8;
00138 data |= byte4;
00139 data <<= 8;
00140 data |= byte3;
00141 data <<= 8;
00142 data |= byte2;
00143 data <<= 8;
00144 data |= byte1;
00145 data <<= 8;
00146 data |= byte0;
00147
00148 return data;
00149 }
00150 double
00151 TagBuffer::ReadDouble (void)
00152 {
00153 double v;
00154 uint8_t *buf = (uint8_t *)&v;
00155 for (uint32_t i = 0; i < sizeof (double); ++i, ++buf)
00156 {
00157 *buf = ReadU8 ();
00158 }
00159 return v;
00160 }
00161 void
00162 TagBuffer::Read (uint8_t *buffer, uint32_t size)
00163 {
00164 for (uint32_t i = 0; i < size; ++i, ++buffer)
00165 {
00166 *buffer = ReadU8 ();
00167 }
00168 }
00169 TagBuffer::TagBuffer (uint8_t *start, uint8_t *end)
00170 : m_current (start),
00171 m_end (end)
00172 {}
00173
00174 void
00175 TagBuffer::TrimAtEnd (uint32_t trim)
00176 {
00177 NS_ASSERT (m_current <= (m_end - trim));
00178 m_end -= trim;
00179 }
00180
00181 void
00182 TagBuffer::CopyFrom (TagBuffer o)
00183 {
00184 NS_ASSERT (o.m_end >= o.m_current);
00185 NS_ASSERT (m_end >= m_current);
00186 uintptr_t size = o.m_end - o.m_current;
00187 NS_ASSERT (size <= (uintptr_t)(m_end - m_current));
00188 memcpy (m_current, o.m_current, size);
00189 m_current += size;
00190 }
00191
00192 }
00193