Tool definition transfer to client

[minetest.git] / src / utility.h

diff --git a/src/utility.h b/src/utility.h
index c741ab0477e123ce2663ecc89cfa8e145fc75235..98fa83e8928e5a116d265b89666dfa3432fd5ec5 100644 (file)
--- a/src/utility.h
+++ b/src/utility.h
@@ -222,13 +222,13 @@ inline u16 readU16(std::istream &is)
        return readU16((u8*)buf);
 }
 
-inline void writeU32(std::ostream &os, u16 p)
+inline void writeU32(std::ostream &os, u32 p)
 {
        char buf[4];
        writeU16((u8*)buf, p);
        os.write(buf, 4);
 }
-inline u16 readU32(std::istream &is)
+inline u32 readU32(std::istream &is)
 {
        char buf[4];
        is.read(buf, 4);
@@ -343,26 +343,59 @@ template <typename T>
 class Buffer
 {
 public:
+       Buffer()
+       {
+               m_size = 0;
+               data = NULL;
+       }
        Buffer(unsigned int size)
        {
                m_size = size;
-               data = new T[size];
+               if(size != 0)
+                       data = new T[size];
+               else
+                       data = NULL;
        }
        Buffer(const Buffer &buffer)
        {
                m_size = buffer.m_size;
-               data = new T[buffer.m_size];
-               memcpy(data, buffer.data, buffer.m_size);
+               if(m_size != 0)
+               {
+                       data = new T[buffer.m_size];
+                       memcpy(data, buffer.data, buffer.m_size);
+               }
+               else
+                       data = NULL;
        }
        Buffer(T *t, unsigned int size)
        {
                m_size = size;
-               data = new T[size];
-               memcpy(data, t, size);
+               if(size != 0)
+               {
+                       data = new T[size];
+                       memcpy(data, t, size);
+               }
+               else
+                       data = NULL;
        }
        ~Buffer()
        {
-               delete[] data;
+               drop();
+       }
+       Buffer& operator=(const Buffer &buffer)
+       {
+               if(this == &buffer)
+                       return *this;
+               drop();
+               m_size = buffer.m_size;
+               if(m_size != 0)
+               {
+                       data = new T[buffer.m_size];
+                       memcpy(data, buffer.data, buffer.m_size);
+               }
+               else
+                       data = NULL;
+               return *this;
        }
        T & operator[](unsigned int i) const
        {
@@ -377,6 +410,11 @@ class Buffer
                return m_size;
        }
 private:
+       void drop()
+       {
+               if(data)
+                       delete[] data;
+       }
        T *data;
        unsigned int m_size;
 };
@@ -471,6 +509,10 @@ class SharedBuffer
        {
                return m_size;
        }
+       operator Buffer<T>() const
+       {
+               return Buffer<T>(data, m_size);
+       }
 private:
        void drop()
        {