41 Storage::Storage(
const unsigned char packet[],
int length)
44 if (length == -1) length =
sizeof(packet) /
sizeof(
unsigned char);
46 store.reserve(length);
48 for(
int i = 0; i < length; ++i) store.push_back(packet[i]);
58 iter_ = store.begin();
61 unsigned char *p_a =
reinterpret_cast<unsigned char*
>(&a);
62 bigEndian_ = (p_a[0] == 0x01);
72 bool Storage::valid_pos()
74 return (iter_ != store.end());
79 unsigned int Storage::position()
const
83 return static_cast<unsigned int>(std::distance(store.begin(), iter_));
91 iter_ = store.begin();
100 unsigned char Storage::readChar() throw(std::invalid_argument)
104 throw std::invalid_argument(
"Storage::readChar(): invalid position");
106 return readCharUnsafe();
114 void Storage::writeChar(
unsigned char value)
throw()
116 store.push_back(value);
117 iter_ = store.begin();
126 int Storage::readByte() throw(std::invalid_argument)
128 int i =
static_cast<int>(readChar());
129 if (i < 128)
return i;
130 else return (i - 256);
138 void Storage::writeByte(
int value)
throw(std::invalid_argument)
140 if (value < -128 || value > 127)
142 throw std::invalid_argument(
"Storage::writeByte(): Invalid value, not in [-128, 127]");
144 writeChar( static_cast<unsigned char>( (value+256) % 256 ) );
153 int Storage::readUnsignedByte() throw(std::invalid_argument)
155 return static_cast<int>(readChar());
163 void Storage::writeUnsignedByte(
int value)
throw(std::invalid_argument)
165 if (value < 0 || value > 255)
167 throw std::invalid_argument(
"Storage::writeUnsignedByte(): Invalid value, not in [0, 255]");
169 writeChar( static_cast<unsigned char>( value ));
178 std::string Storage::readString() throw(std::invalid_argument)
182 StorageType::const_iterator end = iter_;
183 std::advance(end, len);
184 const string tmp(iter_, end);
195 void Storage::writeString(
const std::string &s)
throw()
197 writeInt(static_cast<int>(s.length()));
199 store.insert(store.end(), s.begin(), s.end());
200 iter_ = store.begin();
209 std::vector<std::string> Storage::readStringList() throw(std::invalid_argument)
211 std::vector<std::string> tmp;
212 const int len = readInt();
214 for (
int i = 0; i < len; i++)
216 tmp.push_back(readString());
227 void Storage::writeStringList(
const std::vector<std::string> &s)
throw()
229 writeInt(static_cast<int>(s.size()));
230 for (std::vector<std::string>::const_iterator it = s.begin(); it!=s.end() ; it++)
245 int Storage::readShort() throw(std::invalid_argument)
248 unsigned char *p_value =
reinterpret_cast<unsigned char*
>(&value);
249 readByEndianess(p_value, 2);
255 void Storage::writeShort(
int value )
throw(std::invalid_argument)
257 if (value < -32768 || value > 32767)
259 throw std::invalid_argument(
"Storage::writeShort(): Invalid value, not in [-32768, 32767]");
262 short svalue =
static_cast<short>(value);
263 unsigned char *p_svalue =
reinterpret_cast<unsigned char*
>(&svalue);
264 writeByEndianess(p_svalue, 2);
276 int Storage::readInt() throw(std::invalid_argument)
279 unsigned char *p_value =
reinterpret_cast<unsigned char*
>(&value);
280 readByEndianess(p_value, 4);
286 void Storage::writeInt(
int value )
throw()
288 unsigned char *p_value =
reinterpret_cast<unsigned char*
>(&value);
289 writeByEndianess(p_value, 4);
301 float Storage::readFloat() throw(std::invalid_argument)
304 unsigned char *p_value =
reinterpret_cast<unsigned char*
>(&value);
305 readByEndianess(p_value, 4);
311 void Storage::writeFloat(
float value )
throw()
313 unsigned char *p_value =
reinterpret_cast<unsigned char*
>(&value);
314 writeByEndianess(p_value, 4);
319 void Storage::writeDouble(
double value )
throw ()
321 unsigned char *p_value =
reinterpret_cast<unsigned char*
>(&value);
322 writeByEndianess(p_value, 8);
327 double Storage::readDouble( ) throw (std::invalid_argument)
330 unsigned char *p_value =
reinterpret_cast<unsigned char*
>(&value);
331 readByEndianess(p_value, 8);
337 void Storage::writePacket(
unsigned char* packet,
int length)
339 store.insert(store.end(), &(packet[0]), &(packet[length]));
340 iter_ = store.begin();
345 void Storage::writePacket(
const std::vector<unsigned char> &packet)
347 std::copy(packet.begin(), packet.end(), std::back_inserter(store));
348 iter_ = store.begin();
356 store.insert<StorageType::const_iterator>(store.end(), other.
iter_, other.
store.end());
357 iter_ = store.begin();
362 void Storage::checkReadSafe(
unsigned int num)
const throw(std::invalid_argument)
364 if (std::distance(iter_, store.end()) < static_cast<int>(num))
366 std::ostringstream msg;
367 msg <<
"tcpip::Storage::readIsSafe: want to read " << num <<
" bytes from Storage, "
368 <<
"but only " << std::distance(iter_, store.end()) <<
" remaining";
369 throw std::invalid_argument(msg.str());
375 unsigned char Storage::readCharUnsafe()
384 void Storage::writeByEndianess(
const unsigned char * begin,
unsigned int size)
386 const unsigned char * end = &(begin[size]);
388 store.insert(store.end(), begin, end);
390 store.insert(store.end(), std::reverse_iterator<const unsigned char *>(end), std::reverse_iterator<const unsigned char *>(begin));
391 iter_ = store.begin();
396 void Storage::readByEndianess(
unsigned char * array,
int size)
401 for (
int i = 0; i < size; ++i)
402 array[i] = readCharUnsafe();
406 for (
int i = size - 1; i >= 0; --i)
407 array[i] = readCharUnsafe();
413 std::string Storage::hexDump()
const
415 static const int width = 2;
417 std::ostringstream dump;
420 dump.setf(std::ostream::hex | std::ostream::showbase | std::ostream::internal);
423 for(StorageType::const_iterator it = store.begin(); it != store.end(); ++it)
426 if (it != store.begin())
428 dump << std::setw(width) << static_cast<int>(*it);
436 #endif // BUILD_TCPIP