From e585187b248f48b3c6e9247b49fa07c6565d65e5 Mon Sep 17 00:00:00 2001
From: maximius <none@none>
Date: Sat, 17 Oct 2009 15:51:44 -0700
Subject: *Backed out changeset 3be01fb200a5

--HG--
branch : trunk
---
 src/shared/ByteBuffer.h | 88 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)

(limited to 'src/shared/ByteBuffer.h')

diff --git a/src/shared/ByteBuffer.h b/src/shared/ByteBuffer.h
index 9f454425327..b22dbdee729 100644
--- a/src/shared/ByteBuffer.h
+++ b/src/shared/ByteBuffer.h
@@ -17,12 +17,15 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
+
 #ifndef _BYTEBUFFER_H
 #define _BYTEBUFFER_H
+
 #include "Common.h"
 #include "Errors.h"
 #include "Log.h"
 #include "Utilities/ByteConverter.h"
+
 class ByteBufferException
 {
     public:
@@ -31,6 +34,7 @@ class ByteBufferException
         {
             PrintPosError();
         }
+
         void PrintPosError() const
         {
             sLog.outError("ERROR: Attempted to %s in ByteBuffer (pos: " SIZEFMTD " size: "SIZEFMTD") value with size: " SIZEFMTD,
@@ -42,157 +46,188 @@ class ByteBufferException
         size_t esize;
         size_t size;
 };
+
 class ByteBuffer
 {
     public:
         const static size_t DEFAULT_SIZE = 0x1000;
+
         // constructor
         ByteBuffer(): _rpos(0), _wpos(0)
         {
             _storage.reserve(DEFAULT_SIZE);
         }
+
         // constructor
         ByteBuffer(size_t res): _rpos(0), _wpos(0)
         {
             _storage.reserve(res);
         }
+
         // copy constructor
         ByteBuffer(const ByteBuffer &buf): _rpos(buf._rpos), _wpos(buf._wpos), _storage(buf._storage) { }
+
         void clear()
         {
             _storage.clear();
             _rpos = _wpos = 0;
         }
+
         template <typename T> void append(T value)
         {
             EndianConvert(value);
             append((uint8 *)&value, sizeof(value));
         }
+
         template <typename T> void put(size_t pos,T value)
         {
             EndianConvert(value);
             put(pos,(uint8 *)&value,sizeof(value));
         }
+
         ByteBuffer &operator<<(uint8 value)
         {
             append<uint8>(value);
             return *this;
         }
+
         ByteBuffer &operator<<(uint16 value)
         {
             append<uint16>(value);
             return *this;
         }
+
         ByteBuffer &operator<<(uint32 value)
         {
             append<uint32>(value);
             return *this;
         }
+
         ByteBuffer &operator<<(uint64 value)
         {
             append<uint64>(value);
             return *this;
         }
+
         // signed as in 2e complement
         ByteBuffer &operator<<(int8 value)
         {
             append<int8>(value);
             return *this;
         }
+
         ByteBuffer &operator<<(int16 value)
         {
             append<int16>(value);
             return *this;
         }
+
         ByteBuffer &operator<<(int32 value)
         {
             append<int32>(value);
             return *this;
         }
+
         ByteBuffer &operator<<(int64 value)
         {
             append<int64>(value);
             return *this;
         }
+
         // floating points
         ByteBuffer &operator<<(float value)
         {
             append<float>(value);
             return *this;
         }
+
         ByteBuffer &operator<<(double value)
         {
             append<double>(value);
             return *this;
         }
+
         ByteBuffer &operator<<(const std::string &value)
         {
             append((uint8 const *)value.c_str(), value.length());
             append((uint8)0);
             return *this;
         }
+
         ByteBuffer &operator<<(const char *str)
         {
             append((uint8 const *)str, str ? strlen(str) : 0);
             append((uint8)0);
             return *this;
         }
+
         ByteBuffer &operator>>(bool &value)
         {
             value = read<char>() > 0 ? true : false;
             return *this;
         }
+
         ByteBuffer &operator>>(uint8 &value)
         {
             value = read<uint8>();
             return *this;
         }
+
         ByteBuffer &operator>>(uint16 &value)
         {
             value = read<uint16>();
             return *this;
         }
+
         ByteBuffer &operator>>(uint32 &value)
         {
             value = read<uint32>();
             return *this;
         }
+
         ByteBuffer &operator>>(uint64 &value)
         {
             value = read<uint64>();
             return *this;
         }
+
         //signed as in 2e complement
         ByteBuffer &operator>>(int8 &value)
         {
             value = read<int8>();
             return *this;
         }
+
         ByteBuffer &operator>>(int16 &value)
         {
             value = read<int16>();
             return *this;
         }
+
         ByteBuffer &operator>>(int32 &value)
         {
             value = read<int32>();
             return *this;
         }
+
         ByteBuffer &operator>>(int64 &value)
         {
             value = read<int64>();
             return *this;
         }
+
         ByteBuffer &operator>>(float &value)
         {
             value = read<float>();
             return *this;
         }
+
         ByteBuffer &operator>>(double &value)
         {
             value = read<double>();
             return *this;
         }
+
         ByteBuffer &operator>>(std::string& value)
         {
             value.clear();
@@ -205,36 +240,45 @@ class ByteBuffer
             }
             return *this;
         }
+
         uint8 operator[](size_t pos) const
         {
             return read<uint8>(pos);
         }
+
         size_t rpos() const { return _rpos; }
+
         size_t rpos(size_t rpos_)
         {
             _rpos = rpos_;
             return _rpos;
         }
+
         size_t wpos() const { return _wpos; }
+
         size_t wpos(size_t wpos_)
         {
             _wpos = wpos_;
             return _wpos;
         }
+
         template<typename T>
         void read_skip() { read_skip(sizeof(T)); }
+
         void read_skip(size_t skip)
         {
             if(_rpos + skip > size())
                 throw ByteBufferException(false, _rpos, skip, size());
             _rpos += skip;
         }
+
         template <typename T> T read()
         {
             T r = read<T>(_rpos);
             _rpos += sizeof(T);
             return r;
         }
+
         template <typename T> T read(size_t pos) const
         {
             if(pos + sizeof(T) > size())
@@ -243,6 +287,7 @@ class ByteBuffer
             EndianConvert(val);
             return val;
         }
+
         void read(uint8 *dest, size_t len)
         {
             if(_rpos  + len > size())
@@ -250,67 +295,85 @@ class ByteBuffer
             memcpy(dest, &_storage[_rpos], len);
             _rpos += len;
         }
+
         bool readPackGUID(uint64& guid)
         {
             if(rpos() + 1 > size())
                 return false;
+
             guid = 0;
+
             uint8 guidmark = 0;
             (*this) >> guidmark;
+
             for(int i = 0; i < 8; ++i)
             {
                 if(guidmark & (uint8(1) << i))
                 {
                     if(rpos() + 1 > size())
                         return false;
+
                     uint8 bit;
                     (*this) >> bit;
                     guid |= (uint64(bit) << (i * 8));
                 }
             }
+
             return true;
         }
+
         const uint8 *contents() const { return &_storage[0]; }
+
         size_t size() const { return _storage.size(); }
         bool empty() const { return _storage.empty(); }
+
         void resize(size_t newsize)
         {
             _storage.resize(newsize);
             _rpos = 0;
             _wpos = size();
         }
+
         void reserve(size_t ressize)
         {
             if (ressize > size())
                 _storage.reserve(ressize);
         }
+
         void append(const std::string& str)
         {
             append((uint8 const*)str.c_str(), str.size() + 1);
         }
+
         void append(const char *src, size_t cnt)
         {
             return append((const uint8 *)src, cnt);
         }
+
         template<class T> void append(const T *src, size_t cnt)
         {
             return append((const uint8 *)src, cnt * sizeof(T));
         }
+
         void append(const uint8 *src, size_t cnt)
         {
             if (!cnt)
                 return;
+
             ASSERT(size() < 10000000);
+
             if (_storage.size() < _wpos + cnt)
                 _storage.resize(_wpos + cnt);
             memcpy(&_storage[_wpos], src, cnt);
             _wpos += cnt;
         }
+
         void append(const ByteBuffer& buffer)
         {
             if(buffer.wpos())
                 append(buffer.contents(), buffer.wpos());
         }
+
         // can be used in SMSG_MONSTER_MOVE opcode
         void appendPackXYZ(float x, float y, float z)
         {
@@ -320,10 +383,12 @@ class ByteBuffer
             packed |= ((int)(z / 0.25f) & 0x3FF) << 22;
             *this << packed;
         }
+
         void appendPackGUID(uint64 guid)
         {
             if (_storage.size() < _wpos + sizeof(guid) + 1)
                 _storage.resize(_wpos + sizeof(guid) + 1);
+
             size_t mask_position = wpos();
             *this << uint8(0);
             for(uint8 i = 0; i < 8; ++i)
@@ -333,39 +398,48 @@ class ByteBuffer
                     _storage[mask_position] |= uint8(1 << i);
                     *this << uint8(guid & 0xFF);
                 }
+
                 guid >>= 8;
             }
         }
+
         void put(size_t pos, const uint8 *src, size_t cnt)
         {
             if(pos + cnt > size())
                throw ByteBufferException(true, pos, cnt, size());
             memcpy(&_storage[pos], src, cnt);
         }
+
         void print_storage() const
         {
             if(!sLog.IsOutDebug())                          // optimize disabled debug output
                 return;
+
             sLog.outDebug("STORAGE_SIZE: %lu", (unsigned long)size() );
             for(uint32 i = 0; i < size(); ++i)
                 sLog.outDebugInLine("%u - ", read<uint8>(i) );
             sLog.outDebug(" ");
         }
+
         void textlike() const
         {
             if(!sLog.IsOutDebug())                          // optimize disabled debug output
                 return;
+
             sLog.outDebug("STORAGE_SIZE: %lu", (unsigned long)size() );
             for(uint32 i = 0; i < size(); ++i)
                 sLog.outDebugInLine("%c", read<uint8>(i) );
             sLog.outDebug(" ");
         }
+
         void hexlike() const
         {
             if(!sLog.IsOutDebug())                          // optimize disabled debug output
                 return;
+
             uint32 j = 1, k = 1;
             sLog.outDebug("STORAGE_SIZE: %lu", (unsigned long)size() );
+
             for(uint32 i = 0; i < size(); ++i)
             {
                 if ((i == (j * 8)) && ((i != (k * 16))))
@@ -385,13 +459,16 @@ class ByteBuffer
                     if (read<uint8>(i) < 0x10)
                     {
                         sLog.outDebugInLine("\n");
+
                         sLog.outDebugInLine("0%X ", read<uint8>(i) );
                     }
                     else
                     {
                         sLog.outDebugInLine("\n");
+
                         sLog.outDebugInLine("%X ", read<uint8>(i) );
                     }
+
                     ++k;
                     ++j;
                 }
@@ -409,10 +486,12 @@ class ByteBuffer
             }
             sLog.outDebugInLine("\n");
         }
+
     protected:
         size_t _rpos, _wpos;
         std::vector<uint8> _storage;
 };
+
 template <typename T>
 inline ByteBuffer &operator<<(ByteBuffer &b, std::vector<T> v)
 {
@@ -423,6 +502,7 @@ inline ByteBuffer &operator<<(ByteBuffer &b, std::vector<T> v)
     }
     return b;
 }
+
 template <typename T>
 inline ByteBuffer &operator>>(ByteBuffer &b, std::vector<T> &v)
 {
@@ -437,6 +517,7 @@ inline ByteBuffer &operator>>(ByteBuffer &b, std::vector<T> &v)
     }
     return b;
 }
+
 template <typename T>
 inline ByteBuffer &operator<<(ByteBuffer &b, std::list<T> v)
 {
@@ -447,6 +528,7 @@ inline ByteBuffer &operator<<(ByteBuffer &b, std::list<T> v)
     }
     return b;
 }
+
 template <typename T>
 inline ByteBuffer &operator>>(ByteBuffer &b, std::list<T> &v)
 {
@@ -461,6 +543,7 @@ inline ByteBuffer &operator>>(ByteBuffer &b, std::list<T> &v)
     }
     return b;
 }
+
 template <typename K, typename V>
 inline ByteBuffer &operator<<(ByteBuffer &b, std::map<K, V> &m)
 {
@@ -471,6 +554,7 @@ inline ByteBuffer &operator<<(ByteBuffer &b, std::map<K, V> &m)
     }
     return b;
 }
+
 template <typename K, typename V>
 inline ByteBuffer &operator>>(ByteBuffer &b, std::map<K, V> &m)
 {
@@ -486,6 +570,7 @@ inline ByteBuffer &operator>>(ByteBuffer &b, std::map<K, V> &m)
     }
     return b;
 }
+
 // TODO: Make a ByteBuffer.cpp and move all this inlining to it.
 template<> inline std::string ByteBuffer::read<std::string>()
 {
@@ -493,17 +578,20 @@ template<> inline std::string ByteBuffer::read<std::string>()
     *this >> tmp;
     return tmp;
 }
+
 template<>
 inline void ByteBuffer::read_skip<char*>()
 {
     std::string temp;
     *this >> temp;
 }
+
 template<>
 inline void ByteBuffer::read_skip<char const*>()
 {
     read_skip<char*>();
 }
+
 template<>
 inline void ByteBuffer::read_skip<std::string>()
 {
-- 
cgit v1.2.3