src/shared/ByteBuffer.h

   1 /*
   2  * Copyright (C) 2005,2006,2007 MaNGOS <http://www.mangosproject.org/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   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
  19 #ifndef _BYTEBUFFER_H
  20 #define _BYTEBUFFER_H
  21
  22 #include "Common.h"
  23 #include "Errors.h"
  24
  25 class ByteBuffer
  26 {
  27     public:
  28         class error
  29         {
  30         };
  31
  32         const static size_t DEFAULT_SIZE = 0x1000;
  33
  34         // constructor
  35         ByteBuffer(): _rpos(0), _wpos(0)
  36         {
  37             _storage.reserve(DEFAULT_SIZE);
  38         }
  39         // constructor
  40         ByteBuffer(size_t res): _rpos(0), _wpos(0)
  41         {
  42             _storage.reserve(res);
  43         }
  44         // copy constructor
  45         ByteBuffer(const ByteBuffer &buf): _rpos(buf._rpos), _wpos(buf._wpos), _storage(buf._storage) { }
  46
  47         void clear()
  48         {
  49             _storage.clear();
  50             _rpos = _wpos = 0;
  51         }
  52
  53         template <typename T> void append(T value)
  54         {
  55             append((uint8 *)&value, sizeof(value));
  56         }
  57         template <typename T> void put(size_t pos,T value)
  58         {
  59             put(pos,(uint8 *)&value,sizeof(value));
  60         }
  61
  62         ByteBuffer &operator<<(bool value)
  63         {
  64             append<char>((char)value);
  65             return *this;
  66         }
  67         ByteBuffer &operator<<(uint8 value)
  68         {
  69             append<uint8>(value);
  70             return *this;
  71         }
  72         ByteBuffer &operator<<(uint16 value)
  73         {
  74             append<uint16>(value);
  75             return *this;
  76         }
  77         ByteBuffer &operator<<(uint32 value)
  78         {
  79             append<uint32>(value);
  80             return *this;
  81         }
  82         ByteBuffer &operator<<(uint64 value)
  83         {
  84             append<uint64>(value);
  85             return *this;
  86         }
  87
  88         // signed as in 2e complement
  89         ByteBuffer &operator<<(int8 value)
  90         {
  91             append<int8>(value);
  92             return *this;
  93         }
  94         ByteBuffer &operator<<(int16 value)
  95         {
  96             append<int16>(value);
  97             return *this;
  98         }
  99         ByteBuffer &operator<<(int32 value)
 100         {
 101             append<int32>(value);
 102             return *this;
 103         }
 104         ByteBuffer &operator<<(int64 value)
 105         {
 106             append<int64>(value);
 107             return *this;
 108         }
 109
 110         // floating points
 111         ByteBuffer &operator<<(float value)
 112         {
 113             append<float>(value);
 114             return *this;
 115         }
 116         ByteBuffer &operator<<(double value)
 117         {
 118             append<double>(value);
 119             return *this;
 120         }
 121         ByteBuffer &operator<<(const std::string &value)
 122         {
 123             append((uint8 *)value.c_str(), value.length());
 124             append((uint8)0);
 125             return *this;
 126         }
 127         ByteBuffer &operator<<(const char *str)
 128         {
 129             append((uint8 *)str, str ? strlen(str) : 0);
 130             append((uint8)0);
 131             return *this;
 132         }
 133
 134         ByteBuffer &operator>>(bool &value)
 135         {
 136             value = read<char>() > 0 ? true : false;
 137             return *this;
 138         }
 139         ByteBuffer &operator>>(uint8 &value)
 140         {
 141             value = read<uint8>();
 142             return *this;
 143         }
 144         ByteBuffer &operator>>(uint16 &value)
 145         {
 146             value = read<uint16>();
 147             return *this;
 148         }
 149         ByteBuffer &operator>>(uint32 &value)
 150         {
 151             value = read<uint32>();
 152             return *this;
 153         }
 154         ByteBuffer &operator>>(uint64 &value)
 155         {
 156             value = read<uint64>();
 157             return *this;
 158         }
 159
 160         //signed as in 2e complement
 161         ByteBuffer &operator>>(int8 &value)
 162         {
 163             value = read<int8>();
 164             return *this;
 165         }
 166         ByteBuffer &operator>>(int16 &value)
 167         {
 168             value = read<int16>();
 169             return *this;
 170         }
 171         ByteBuffer &operator>>(int32 &value)
 172         {
 173             value = read<int32>();
 174             return *this;
 175         }
 176         ByteBuffer &operator>>(int64 &value)
 177         {
 178             value = read<int64>();
 179             return *this;
 180         }
 181
 182         ByteBuffer &operator>>(float &value)
 183         {
 184             value = read<float>();
 185             return *this;
 186         }
 187         ByteBuffer &operator>>(double &value)
 188         {
 189             value = read<double>();
 190             return *this;
 191         }
 192         ByteBuffer &operator>>(std::string& value)
 193         {
 194             value.clear();
 195             while (rpos() < size())                         // prevent crash at wrong string format in packet
 196             {
 197                 char c=read<char>();
 198                 if (c==0)
 199                     break;
 200                 value+=c;
 201             }
 202             return *this;
 203         }
 204
 205         uint8 operator[](size_t pos)
 206         {
 207             return read<uint8>(pos);
 208         }
 209
 210         size_t rpos()
 211         {
 212             return _rpos;
 213         };
 214
 215         size_t rpos(size_t rpos)
 216         {
 217             _rpos = rpos;
 218             return _rpos;
 219         };
 220
 221         size_t wpos()
 222         {
 223             return _wpos;
 224         }
 225
 226         size_t wpos(size_t wpos)
 227         {
 228             _wpos = wpos;
 229             return _wpos;
 230         }
 231
 232         template <typename T> T read()
 233         {
 234             T r=read<T>(_rpos);
 235             _rpos += sizeof(T);
 236             return r;
 237         };
 238         template <typename T> T read(size_t pos) const
 239         {
 240             ASSERT(pos + sizeof(T) <= size() || PrintPosError(false,pos,sizeof(T)));
 241             return *((T*)&_storage[pos]);
 242         }
 243
 244         void read(uint8 *dest, size_t len)
 245         {
 246             ASSERT(_rpos  + len  <= size() || PrintPosError(false,_rpos,len));
 247             memcpy(dest, &_storage[_rpos], len);
 248             _rpos += len;
 249         }
 250
 251         const uint8 *contents() const { return &_storage[0]; };
 252
 253         inline size_t size() const { return _storage.size(); };
 254
 255         void resize(size_t newsize)
 256         {
 257             _storage.resize(newsize);
 258             _rpos = 0;
 259             _wpos = size();
 260         };
 261         void reserve(size_t ressize)
 262         {
 263             if (ressize > size()) _storage.reserve(ressize);
 264         };
 265
 266         void append(const std::string& str)
 267         {
 268             append((uint8 *)str.c_str(),str.size() + 1);
 269         }
 270         void append(const char *src, size_t cnt)
 271         {
 272             return append((const uint8 *)src, cnt);
 273         }
 274         void append(const uint8 *src, size_t cnt)
 275         {
 276             if (!cnt) return;
 277
 278             ASSERT(size() < 10000000);
 279
 280             if (_storage.size() < _wpos + cnt)
 281                 _storage.resize(_wpos + cnt);
 282             memcpy(&_storage[_wpos], src, cnt);
 283             _wpos += cnt;
 284         }
 285         void append(const ByteBuffer& buffer)
 286         {
 287             if(buffer.size()) append(buffer.contents(),buffer.size());
 288         }
 289
 290         void put(size_t pos, const uint8 *src, size_t cnt)
 291         {
 292             ASSERT(pos + cnt <= size() || PrintPosError(true,pos,cnt));
 293             memcpy(&_storage[pos], src, cnt);
 294         }
 295         void print_storage()
 296         {
 297             printf("STORAGE_SIZE: %u\n", size() );
 298             for(uint32 i = 0; i < size(); i++)
 299                 printf("%u - ", read<uint8>(i) );
 300             printf("\n");
 301         }
 302
 303         void textlike()
 304         {
 305             printf("STORAGE_SIZE: %u\n", size() );
 306             for(uint32 i = 0; i < size(); i++)
 307                 printf("%c", read<uint8>(i) );
 308             printf("\n");
 309         }
 310
 311         void hexlike()
 312         {
 313
 314             uint32 j = 1, k = 1;
 315             printf("STORAGE_SIZE: %u\n", size() );
 316             for(uint32 i = 0; i < size(); i++)
 317             {
 318                 if ((i == (j*8)) && ((i != (k*16))))
 319                 {
 320                     if (read<uint8>(i) < 0x0F)
 321                     {
 322                         printf("| 0%X ", read<uint8>(i) );
 323                     }
 324                     else
 325                     {
 326                         printf("| %X ", read<uint8>(i) );
 327                     }
 328                     j++;
 329                 }
 330                 else if (i == (k*16))
 331                 {
 332                     if (read<uint8>(i) < 0x0F)
 333                     {
 334                         printf("\n0%X ", read<uint8>(i) );
 335                     }
 336                     else
 337                     {
 338                         printf("\n%X ", read<uint8>(i) );
 339                     }
 340
 341                     k++;
 342                     j++;
 343                 }
 344                 else
 345                 {
 346                     if (read<uint8>(i) < 0x0F)
 347                     {
 348                         printf("0%X ", read<uint8>(i) );
 349                     }
 350                     else
 351                     {
 352                         printf("%X ", read<uint8>(i) );
 353                     }
 354                 }
 355             }
 356             printf("\n");
 357         }
 358
 359     protected:
 360         bool PrintPosError(bool add, size_t pos, size_t esize) const
 361         {
 362             printf("ERROR: Attempt %s in ByteBuffer (pos: %u size: %u) value with size: %u",(add ? "put" : "get"),pos, size(), esize);
 363
 364             // assert must fail after function call
 365             return false;
 366         }
 367
 368         size_t _rpos, _wpos;
 369         std::vector<uint8> _storage;
 370 };
 371
 372 template <typename T> ByteBuffer &operator<<(ByteBuffer &b, std::vector<T> v)
 373 {
 374     b << (uint32)v.size();
 375     for (typename std::vector<T>::iterator i = v.begin(); i != v.end(); i++)
 376     {
 377         b << *i;
 378     }
 379     return b;
 380 }
 381
 382 template <typename T> ByteBuffer &operator>>(ByteBuffer &b, std::vector<T> &v)
 383 {
 384     uint32 vsize;
 385     b >> vsize;
 386     v.clear();
 387     while(vsize--)
 388     {
 389         T t;
 390         b >> t;
 391         v.push_back(t);
 392     }
 393     return b;
 394 }
 395
 396 template <typename T> ByteBuffer &operator<<(ByteBuffer &b, std::list<T> v)
 397 {
 398     b << (uint32)v.size();
 399     for (typename std::list<T>::iterator i = v.begin(); i != v.end(); i++)
 400     {
 401         b << *i;
 402     }
 403     return b;
 404 }
 405
 406 template <typename T> ByteBuffer &operator>>(ByteBuffer &b, std::list<T> &v)
 407 {
 408     uint32 vsize;
 409     b >> vsize;
 410     v.clear();
 411     while(vsize--)
 412     {
 413         T t;
 414         b >> t;
 415         v.push_back(t);
 416     }
 417     return b;
 418 }
 419
 420 template <typename K, typename V> ByteBuffer &operator<<(ByteBuffer &b, std::map<K, V> &m)
 421 {
 422     b << (uint32)m.size();
 423     for (typename std::map<K, V>::iterator i = m.begin(); i != m.end(); i++)
 424     {
 425         b << i->first << i->second;
 426     }
 427     return b;
 428 }
 429
 430 template <typename K, typename V> ByteBuffer &operator>>(ByteBuffer &b, std::map<K, V> &m)
 431 {
 432     uint32 msize;
 433     b >> msize;
 434     m.clear();
 435     while(msize--)
 436     {
 437         K k;
 438         V v;
 439         b >> k >> v;
 440         m.insert(make_pair(k, v));
 441     }
 442     return b;
 443 }
 444 #endif