src/shared/ByteBuffer.h

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   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 #include "Log.h"
  25 #include "Utilities/ByteConverter.h"
  26
  27 class ByteBuffer
  28 {
  29     public:
  30         const static size_t DEFAULT_SIZE = 0x1000;
  31
  32         // constructor
  33         ByteBuffer(): _rpos(0), _wpos(0)
  34         {
  35             _storage.reserve(DEFAULT_SIZE);
  36         }
  37         // constructor
  38         ByteBuffer(size_t res): _rpos(0), _wpos(0)
  39         {
  40             _storage.reserve(res);
  41         }
  42         // copy constructor
  43         ByteBuffer(const ByteBuffer &buf): _rpos(buf._rpos), _wpos(buf._wpos), _storage(buf._storage) { }
  44
  45         void clear()
  46         {
  47             _storage.clear();
  48             _rpos = _wpos = 0;
  49         }
  50
  51         template <typename T> void append(T value)
  52         {
  53             EndianConvert(value);
  54             append((uint8 *)&value, sizeof(value));
  55         }
  56
  57         template <typename T> void put(size_t pos,T value)
  58         {
  59             EndianConvert(value);
  60             put(pos,(uint8 *)&value,sizeof(value));
  61         }
  62
  63         ByteBuffer &operator<<(uint8 value)
  64         {
  65             append<uint8>(value);
  66             return *this;
  67         }
  68         ByteBuffer &operator<<(uint16 value)
  69         {
  70             append<uint16>(value);
  71             return *this;
  72         }
  73         ByteBuffer &operator<<(uint32 value)
  74         {
  75             append<uint32>(value);
  76             return *this;
  77         }
  78         ByteBuffer &operator<<(uint64 value)
  79         {
  80             append<uint64>(value);
  81             return *this;
  82         }
  83
  84         // signed as in 2e complement
  85         ByteBuffer &operator<<(int8 value)
  86         {
  87             append<int8>(value);
  88             return *this;
  89         }
  90         ByteBuffer &operator<<(int16 value)
  91         {
  92             append<int16>(value);
  93             return *this;
  94         }
  95         ByteBuffer &operator<<(int32 value)
  96         {
  97             append<int32>(value);
  98             return *this;
  99         }
 100         ByteBuffer &operator<<(int64 value)
 101         {
 102             append<int64>(value);
 103             return *this;
 104         }
 105
 106         // floating points
 107         ByteBuffer &operator<<(float value)
 108         {
 109             append<float>(value);
 110             return *this;
 111         }
 112         ByteBuffer &operator<<(double value)
 113         {
 114             append<double>(value);
 115             return *this;
 116         }
 117         ByteBuffer &operator<<(const std::string &value)
 118         {
 119             append((uint8 const *)value.c_str(), value.length());
 120             append((uint8)0);
 121             return *this;
 122         }
 123         ByteBuffer &operator<<(const char *str)
 124         {
 125             append((uint8 const *)str, str ? strlen(str) : 0);
 126             append((uint8)0);
 127             return *this;
 128         }
 129
 130         ByteBuffer &operator>>(bool &value)
 131         {
 132             value = read<char>() > 0 ? true : false;
 133             return *this;
 134         }
 135
 136         ByteBuffer &operator>>(uint8 &value)
 137         {
 138             value = read<uint8>();
 139             return *this;
 140         }
 141         ByteBuffer &operator>>(uint16 &value)
 142         {
 143             value = read<uint16>();
 144             return *this;
 145         }
 146         ByteBuffer &operator>>(uint32 &value)
 147         {
 148             value = read<uint32>();
 149             return *this;
 150         }
 151         ByteBuffer &operator>>(uint64 &value)
 152         {
 153             value = read<uint64>();
 154             return *this;
 155         }
 156
 157         //signed as in 2e complement
 158         ByteBuffer &operator>>(int8 &value)
 159         {
 160             value = read<int8>();
 161             return *this;
 162         }
 163         ByteBuffer &operator>>(int16 &value)
 164         {
 165             value = read<int16>();
 166             return *this;
 167         }
 168         ByteBuffer &operator>>(int32 &value)
 169         {
 170             value = read<int32>();
 171             return *this;
 172         }
 173         ByteBuffer &operator>>(int64 &value)
 174         {
 175             value = read<int64>();
 176             return *this;
 177         }
 178
 179         ByteBuffer &operator>>(float &value)
 180         {
 181             value = read<float>();
 182             return *this;
 183         }
 184         ByteBuffer &operator>>(double &value)
 185         {
 186             value = read<double>();
 187             return *this;
 188         }
 189         ByteBuffer &operator>>(std::string& value)
 190         {
 191             value.clear();
 192             while (rpos() < size())                         // prevent crash at wrong string format in packet
 193             {
 194                 char c=read<char>();
 195                 if (c==0)
 196                     break;
 197                 value+=c;
 198             }
 199             return *this;
 200         }
 201
 202         uint8 operator[](size_t pos) const
 203         {
 204             return read<uint8>(pos);
 205         }
 206
 207         size_t rpos() const { return _rpos; }
 208
 209         size_t rpos(size_t rpos_)
 210         {
 211             _rpos = rpos_;
 212             return _rpos;
 213         };
 214
 215         size_t wpos() const { return _wpos; }
 216
 217         size_t wpos(size_t wpos_)
 218         {
 219             _wpos = wpos_;
 220             return _wpos;
 221         }
 222
 223         template <typename T> T read()
 224         {
 225             T r=read<T>(_rpos);
 226             _rpos += sizeof(T);
 227             return r;
 228         };
 229         template <typename T> T read(size_t pos) const
 230         {
 231             ASSERT(pos + sizeof(T) <= size() || PrintPosError(false,pos,sizeof(T)));
 232             T val = *((T const*)&_storage[pos]);
 233             EndianConvert(val);
 234             return val;
 235         }
 236
 237         void read(uint8 *dest, size_t len)
 238         {
 239             ASSERT(_rpos  + len  <= size() || PrintPosError(false,_rpos,len));
 240             memcpy(dest, &_storage[_rpos], len);
 241             _rpos += len;
 242         }
 243
 244         bool readPackGUID(uint64& guid)
 245         {
 246             if(rpos()+1 > size())
 247                 return false;
 248
 249             guid = 0;
 250
 251             uint8 guidmark=0;
 252             (*this) >> guidmark;
 253
 254             for(int i=0;i<8;i++)
 255             {
 256                 if(guidmark & (uint8(1) << i))
 257                 {
 258                     if(rpos()+1 > size())
 259                         return false;
 260
 261                     uint8 bit;
 262                     (*this) >> bit;
 263                     guid |= (uint64(bit) << (i*8));
 264                 }
 265             }
 266
 267             return true;
 268         }
 269
 270         const uint8 *contents() const { return &_storage[0]; }
 271
 272         size_t size() const { return _storage.size(); }
 273         bool empty() const { return _storage.empty(); }
 274
 275         void resize(size_t newsize)
 276         {
 277             _storage.resize(newsize);
 278             _rpos = 0;
 279             _wpos = size();
 280         };
 281         void reserve(size_t ressize)
 282         {
 283             if (ressize > size()) _storage.reserve(ressize);
 284         };
 285
 286         void append(const std::string& str)
 287         {
 288             append((uint8 const*)str.c_str(),str.size() + 1);
 289         }
 290         void append(const char *src, size_t cnt)
 291         {
 292             return append((const uint8 *)src, cnt);
 293         }
 294         template<class T>
 295         void append(const T *src, size_t cnt)
 296         {
 297             return append((const uint8 *)src, cnt*sizeof(T));
 298         }
 299         void append(const uint8 *src, size_t cnt)
 300         {
 301             if (!cnt) return;
 302
 303             ASSERT(size() < 10000000);
 304
 305             if (_storage.size() < _wpos + cnt)
 306                 _storage.resize(_wpos + cnt);
 307             memcpy(&_storage[_wpos], src, cnt);
 308             _wpos += cnt;
 309         }
 310         void append(const ByteBuffer& buffer)
 311         {
 312             if(buffer.size()) append(buffer.contents(),buffer.wpos());
 313         }
 314
 315         void appendPackGUID(uint64 guid)
 316         {
 317             if (_storage.size() < _wpos + sizeof(guid) + 1)
 318                 _storage.resize(_wpos + sizeof(guid) + 1);
 319
 320             size_t mask_position = wpos();
 321             *this << uint8(0);
 322             for(uint8 i = 0; i < 8; i++)
 323             {
 324                 if(guid & 0xFF)
 325                 {
 326                     _storage[mask_position] |= uint8(1<<i);
 327                     *this << uint8(guid & 0xFF);
 328                 }
 329
 330                 guid >>= 8;
 331             }
 332         }
 333
 334         void put(size_t pos, const uint8 *src, size_t cnt)
 335         {
 336             ASSERT(pos + cnt <= size() || PrintPosError(true,pos,cnt));
 337             memcpy(&_storage[pos], src, cnt);
 338         }
 339         void print_storage() const
 340         {
 341             if(!sLog.IsOutDebug())                          // optimize disabled debug output
 342                 return;
 343
 344             sLog.outDebug("STORAGE_SIZE: %lu", (unsigned long)size() );
 345             for(uint32 i = 0; i < size(); i++)
 346                 sLog.outDebugInLine("%u - ", read<uint8>(i) );
 347             sLog.outDebug(" ");
 348         }
 349
 350         void textlike() const
 351         {
 352             if(!sLog.IsOutDebug())                          // optimize disabled debug output
 353                 return;
 354
 355             sLog.outDebug("STORAGE_SIZE: %lu", (unsigned long)size() );
 356             for(uint32 i = 0; i < size(); i++)
 357                 sLog.outDebugInLine("%c", read<uint8>(i) );
 358             sLog.outDebug(" ");
 359         }
 360
 361         void hexlike() const
 362         {
 363             if(!sLog.IsOutDebug())                          // optimize disabled debug output
 364                 return;
 365
 366             uint32 j = 1, k = 1;
 367             sLog.outDebug("STORAGE_SIZE: %lu", (unsigned long)size() );
 368
 369             if(sLog.IsIncludeTime())
 370                 sLog.outDebugInLine("         ");
 371
 372             for(uint32 i = 0; i < size(); i++)
 373             {
 374                 if ((i == (j*8)) && ((i != (k*16))))
 375                 {
 376                     if (read<uint8>(i) < 0x10)
 377                     {
 378                         sLog.outDebugInLine("| 0%X ", read<uint8>(i) );
 379                     }
 380                     else
 381                     {
 382                         sLog.outDebugInLine("| %X ", read<uint8>(i) );
 383                     }
 384                     ++j;
 385                 }
 386                 else if (i == (k*16))
 387                 {
 388                     if (read<uint8>(i) < 0x10)
 389                     {
 390                         sLog.outDebugInLine("\n");
 391                         if(sLog.IsIncludeTime())
 392                             sLog.outDebugInLine("         ");
 393
 394                         sLog.outDebugInLine("0%X ", read<uint8>(i) );
 395                     }
 396                     else
 397                     {
 398                         sLog.outDebugInLine("\n");
 399                         if(sLog.IsIncludeTime())
 400                             sLog.outDebugInLine("         ");
 401
 402                         sLog.outDebugInLine("%X ", read<uint8>(i) );
 403                     }
 404
 405                     ++k;
 406                     ++j;
 407                 }
 408                 else
 409                 {
 410                     if (read<uint8>(i) < 0x10)
 411                     {
 412                         sLog.outDebugInLine("0%X ", read<uint8>(i) );
 413                     }
 414                     else
 415                     {
 416                         sLog.outDebugInLine("%X ", read<uint8>(i) );
 417                     }
 418                 }
 419             }
 420             sLog.outDebugInLine("\n");
 421         }
 422
 423     protected:
 424         bool PrintPosError(bool add, size_t pos, size_t esize) const
 425         {
 426             sLog.outError("ERROR: Attempt %s in ByteBuffer (pos: %lu size: %lu) value with size: %lu",(add ? "put" : "get"),(unsigned long)pos, (unsigned long)size(), (unsigned long)esize);
 427
 428             // assert must fail after function call
 429             return false;
 430         }
 431
 432         size_t _rpos, _wpos;
 433         std::vector<uint8> _storage;
 434 };
 435
 436 template <typename T> ByteBuffer &operator<<(ByteBuffer &b, std::vector<T> v)
 437 {
 438     b << (uint32)v.size();
 439     for (typename std::vector<T>::iterator i = v.begin(); i != v.end(); i++)
 440     {
 441         b << *i;
 442     }
 443     return b;
 444 }
 445
 446 template <typename T> ByteBuffer &operator>>(ByteBuffer &b, std::vector<T> &v)
 447 {
 448     uint32 vsize;
 449     b >> vsize;
 450     v.clear();
 451     while(vsize--)
 452     {
 453         T t;
 454         b >> t;
 455         v.push_back(t);
 456     }
 457     return b;
 458 }
 459
 460 template <typename T> ByteBuffer &operator<<(ByteBuffer &b, std::list<T> v)
 461 {
 462     b << (uint32)v.size();
 463     for (typename std::list<T>::iterator i = v.begin(); i != v.end(); i++)
 464     {
 465         b << *i;
 466     }
 467     return b;
 468 }
 469
 470 template <typename T> ByteBuffer &operator>>(ByteBuffer &b, std::list<T> &v)
 471 {
 472     uint32 vsize;
 473     b >> vsize;
 474     v.clear();
 475     while(vsize--)
 476     {
 477         T t;
 478         b >> t;
 479         v.push_back(t);
 480     }
 481     return b;
 482 }
 483
 484 template <typename K, typename V> ByteBuffer &operator<<(ByteBuffer &b, std::map<K, V> &m)
 485 {
 486     b << (uint32)m.size();
 487     for (typename std::map<K, V>::iterator i = m.begin(); i != m.end(); i++)
 488     {
 489         b << i->first << i->second;
 490     }
 491     return b;
 492 }
 493
 494 template <typename K, typename V> ByteBuffer &operator>>(ByteBuffer &b, std::map<K, V> &m)
 495 {
 496     uint32 msize;
 497     b >> msize;
 498     m.clear();
 499     while(msize--)
 500     {
 501         K k;
 502         V v;
 503         b >> k >> v;
 504         m.insert(make_pair(k, v));
 505     }
 506     return b;
 507 }
 508 #endif