Use project name for mo files

[dragonfireclient.git] / src / utility.h

diff --git a/src/utility.h b/src/utility.h
index 28732a099f3a8cc77b6361530f4cde4ebe6d7d94..497f79fa0dfed76ca441ec5e11824feb5b90a4d0 100644 (file)
--- a/src/utility.h
+++ b/src/utility.h
@@ -221,6 +221,19 @@ inline u16 readU16(std::istream &is)
        return readU16((u8*)buf);
 }
 
+inline void writeU32(std::ostream &os, u16 p)
+{
+       char buf[4];
+       writeU16((u8*)buf, p);
+       os.write(buf, 4);
+}
+inline u16 readU32(std::istream &is)
+{
+       char buf[4];
+       is.read(buf, 4);
+       return readU32((u8*)buf);
+}
+
 inline void writeF1000(std::ostream &os, f32 p)
 {
        char buf[2];
@@ -231,6 +244,9 @@ inline f32 readF1000(std::istream &is)
 {
        char buf[2];
        is.read(buf, 2);
+       // TODO: verify if this gets rid of the valgrind warning
+       //if(is.gcount() != 2)
+       //      return 0;
        return readF1000((u8*)buf);
 }
 
@@ -371,10 +387,20 @@ template <typename T>
 class SharedBuffer
 {
 public:
+       SharedBuffer()
+       {
+               m_size = 0;
+               data = NULL;
+               refcount = new unsigned int;
+               (*refcount) = 1;
+       }
        SharedBuffer(unsigned int size)
        {
                m_size = size;
-               data = new T[size];
+               if(m_size != 0)
+                       data = new T[m_size];
+               else
+                       data = NULL;
                refcount = new unsigned int;
                (*refcount) = 1;
        }
@@ -404,8 +430,13 @@ class SharedBuffer
        SharedBuffer(T *t, unsigned int size)
        {
                m_size = size;
-               data = new T[size];
-               memcpy(data, t, size);
+               if(m_size != 0)
+               {
+                       data = new T[m_size];
+                       memcpy(data, t, m_size);
+               }
+               else
+                       data = NULL;
                refcount = new unsigned int;
                (*refcount) = 1;
        }
@@ -414,9 +445,14 @@ class SharedBuffer
        */
        SharedBuffer(const Buffer<T> &buffer)
        {
-               m_size = buffer.m_size;
-               data = new T[buffer.getSize()];
-               memcpy(data, *buffer, buffer.getSize());
+               m_size = buffer.getSize();
+               if(m_size != 0)
+               {
+                       data = new T[m_size];
+                       memcpy(data, *buffer, buffer.getSize());
+               }
+               else
+                       data = NULL;
                refcount = new unsigned int;
                (*refcount) = 1;
        }
@@ -426,6 +462,7 @@ class SharedBuffer
        }
        T & operator[](unsigned int i) const
        {
+               //assert(i < m_size)
                return data[i];
        }
        T * operator*() const
@@ -443,7 +480,8 @@ class SharedBuffer
                (*refcount)--;
                if(*refcount == 0)
                {
-                       delete[] data;
+                       if(data)
+                               delete[] data;
                        delete refcount;
                }
        }
@@ -809,6 +847,11 @@ inline s32 stoi(std::string s)
        return atoi(s.c_str());
 }
 
+inline s32 stoi(std::wstring s)
+{
+       return atoi(wide_to_narrow(s).c_str());
+}
+
 inline float stof(std::string s)
 {
        float f;
@@ -819,11 +862,6 @@ inline float stof(std::string s)
 
 #endif
 
-inline s32 stoi(std::wstring s)
-{
-       return atoi(wide_to_narrow(s).c_str());
-}
-
 inline std::string itos(s32 i)
 {
        std::ostringstream o;
@@ -1703,6 +1741,11 @@ void mysrand(unsigned seed);
 
 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);
@@ -1766,12 +1809,12 @@ class UniqueQueue
        core::list<Value> m_list;
 };
 
-#if 0
+#if 1
 template<typename Key, typename Value>
-class MutexedCache
+class MutexedMap
 {
 public:
-       MutexedCache()
+       MutexedMap()
        {
                m_mutex.Init();
                assert(m_mutex.IsInitialized());
@@ -1793,8 +1836,10 @@ class MutexedCache
 
                if(n == NULL)
                        return false;
-
-               *result = n->getValue();
+               
+               if(result != NULL)
+                       *result = n->getValue();
+                       
                return true;
        }
 
@@ -1947,17 +1992,23 @@ inline std::string serializeString(const std::string &plain)
        return s;
 }
 
-/*// Reads a string with the length as the first two bytes
-inline std::string deSerializeString(const std::string encoded)
+// Creates a string with the length as the first two bytes from wide string
+inline std::string serializeWideString(const std::wstring &plain)
 {
-       u16 s_size = readU16((u8*)&encoded.c_str()[0]);
-       if(s_size > encoded.length() - 2)
-               return "";
+       //assert(plain.size() <= 65535);
+       if(plain.size() > 65535)
+               throw SerializationError("String too long for serializeString");
+       char buf[2];
+       writeU16((u8*)buf, plain.size());
        std::string s;
-       s.reserve(s_size);
-       s.append(&encoded.c_str()[2], s_size);
+       s.append(buf, 2);
+       for(u32 i=0; i<plain.size(); i++)
+       {
+               writeU16((u8*)buf, plain[i]);
+               s.append(buf, 2);
+       }
        return s;
-}*/
+}
 
 // Reads a string with the length as the first two bytes
 inline std::string deSerializeString(std::istream &is)
@@ -1977,6 +2028,27 @@ inline std::string deSerializeString(std::istream &is)
        return s;
 }
 
+// Reads a wide string with the length as the first two bytes
+inline std::wstring deSerializeWideString(std::istream &is)
+{
+       char buf[2];
+       is.read(buf, 2);
+       if(is.gcount() != 2)
+               throw SerializationError("deSerializeString: size not read");
+       u16 s_size = readU16((u8*)buf);
+       if(s_size == 0)
+               return L"";
+       std::wstring s;
+       s.reserve(s_size);
+       for(u32 i=0; i<s_size; i++)
+       {
+               is.read(&buf[0], 2);
+               wchar_t c16 = readU16((u8*)buf);
+               s.append(&c16, 1);
+       }
+       return s;
+}
+
 // Creates a string with the length as the first four bytes
 inline std::string serializeLongString(const std::string &plain)
 {
@@ -1988,18 +2060,6 @@ inline std::string serializeLongString(const std::string &plain)
        return s;
 }
 
-/*// Reads a string with the length as the first four bytes
-inline std::string deSerializeLongString(const std::string encoded)
-{
-       u32 s_size = readU32((u8*)&encoded.c_str()[0]);
-       if(s_size > encoded.length() - 4)
-               return "";
-       std::string s;
-       s.reserve(s_size);
-       s.append(&encoded.c_str()[4], s_size);
-       return s;
-}*/
-
 // Reads a string with the length as the first four bytes
 inline std::string deSerializeLongString(std::istream &is)
 {
@@ -2075,6 +2135,7 @@ class IntervalLimiter
        float m_accumulator;
 };
 
+std::string translatePassword(std::string playername, std::wstring password);
 
 #endif