*Massive cleanup (\n\n -> \n, *\n -> \n, cleanup for(...) to for (...), and some other cleanups by hand)

*Fix a possible crash in Spell::DoAllEffectOnTarget

--HG--
branch : trunk

1 files changed, 0 insertions, 88 deletions

diff --git a/src/shared/ByteBuffer.h b/src/shared/ByteBuffer.h
index b22dbdee729..9f454425327 100644
--- a/src/shared/ByteBuffer.h
+++ b/src/shared/ByteBuffer.h
@@ -17,15 +17,12 @@
  * 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:
@@ -34,7 +31,6 @@ class ByteBufferException
         {
             PrintPosError();
         }
-
         void PrintPosError() const
         {
             sLog.outError("ERROR: Attempted to %s in ByteBuffer (pos: " SIZEFMTD " size: "SIZEFMTD") value with size: " SIZEFMTD,
@@ -46,188 +42,157 @@ 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();
@@ -240,45 +205,36 @@ 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())
@@ -287,7 +243,6 @@ class ByteBuffer
             EndianConvert(val);
             return val;
         }
-
         void read(uint8 *dest, size_t len)
         {
             if(_rpos  + len > size())
@@ -295,85 +250,67 @@ 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)
         {
@@ -383,12 +320,10 @@ 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)
@@ -398,48 +333,39 @@ 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))))
@@ -459,16 +385,13 @@ 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;
                 }
@@ -486,12 +409,10 @@ 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)
 {
@@ -502,7 +423,6 @@ inline ByteBuffer &operator<<(ByteBuffer &b, std::vector<T> v)
     }
     return b;
 }
-
 template <typename T>
 inline ByteBuffer &operator>>(ByteBuffer &b, std::vector<T> &v)
 {
@@ -517,7 +437,6 @@ inline ByteBuffer &operator>>(ByteBuffer &b, std::vector<T> &v)
     }
     return b;
 }
-
 template <typename T>
 inline ByteBuffer &operator<<(ByteBuffer &b, std::list<T> v)
 {
@@ -528,7 +447,6 @@ inline ByteBuffer &operator<<(ByteBuffer &b, std::list<T> v)
     }
     return b;
 }
-
 template <typename T>
 inline ByteBuffer &operator>>(ByteBuffer &b, std::list<T> &v)
 {
@@ -543,7 +461,6 @@ 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)
 {
@@ -554,7 +471,6 @@ 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)
 {
@@ -570,7 +486,6 @@ 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>()
 {
@@ -578,20 +493,17 @@ 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>()
 {