ToolDefManager serialization

[oweals/minetest.git] / src / utility.h

diff --git a/src/utility.h b/src/utility.h
index f8cc3498444265da15fe88259a86d32be0a327a2..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 @@ public:
                return m_size;
        }
 private:
+       void drop()
+       {
+               if(data)
+                       delete[] data;
+       }
        T *data;
        unsigned int m_size;
 };
@@ -471,6 +509,10 @@ public:
        {
                return m_size;
        }
+       operator Buffer<T>() const
+       {
+               return Buffer<T>(data, m_size);
+       }
 private:
        void drop()
        {
@@ -810,6 +852,35 @@ inline float wrapDegrees(float f)
        return f;
 }
 
+/* Wrap to 0...360 */
+inline float wrapDegrees_0_360(float f)
+{
+       // Take examples of f=10, f=720.5, f=-0.5, f=-360.5
+       // This results in
+       // 10, 720, -1, -361
+       int i = floor(f);
+       // 0, 2, 0, -1
+       int l = i / 360;
+       // Wrap to 0...360
+       // 0, 2, -1, -2
+       if(i < 0)
+               l -= 1;
+       // 0, 720, 0, -360
+       int k = l * 360;
+       // 10, 0.5, -0.5, -0.5
+       f -= float(k);
+       return f;
+}
+
+/* Wrap to -180...180 */
+inline float wrapDegrees_180(float f)
+{
+       f += 180;
+       f = wrapDegrees_0_360(f);
+       f -= 180;
+       return f;
+}
+
 inline std::string lowercase(const std::string &s)
 {
        std::string s2;
@@ -1201,20 +1272,7 @@ int myrand(void);
 void mysrand(unsigned seed);
 #define MYRAND_MAX 32767
 
-inline int myrand_range(int min, int max)
-{
-       if(max-min > MYRAND_MAX)
-       {
-               dstream<<"WARNING: myrand_range: max-min > MYRAND_MAX"<<std::endl;
-               assert(0);
-       }
-       if(min > max)
-       {
-               assert(0);
-               return max;
-       }
-       return (myrand()%(max-min+1))+min;
-}
+int myrand_range(int min, int max);
 
 /*
        Miscellaneous functions