+ utf8 to/from utf16 implementation

Conflicts:
	include/mapnik/utils.hpp

include/mapnik/utils.hpp

@@ -29,6 +29,7 @@
 #endif
 
 // stl
+#include <string>
 #include <stdexcept>
 #include <cstdlib>
 #include <limits>
@@ -38,6 +39,7 @@
 
 namespace mapnik
 {
+
 #ifdef MAPNIK_THREADSAFE
 using boost::mutex;
 #endif
@@ -89,81 +91,108 @@ public:
 };
 
 #ifdef __GNUC__
-template <typename T,
+    template <typename T,
-          template <typename U> class CreatePolicy=CreateStatic> class MAPNIK_DECL singleton
+              template <typename U> class CreatePolicy=CreateStatic> class MAPNIK_DECL singleton
-{
+    {
 #else
-template <typename T,
+    template <typename T,
-          template <typename U> class CreatePolicy=CreateStatic> class singleton
+              template <typename U> class CreatePolicy=CreateStatic> class singleton
-{
+    {
 #endif
+        friend class CreatePolicy<T>;
+        static T* pInstance_;
+        static bool destroyed_;
+        singleton(const singleton &rhs);
+        singleton& operator=(const singleton&);
 
-#ifdef __SUNPRO_CC
+        static void onDeadReference()
-    /* Sun's C++ compiler will issue the following errors if CreatePolicy<T> is used:
-       Error: A class template name was expected instead of mapnik::CreatePolicy<mapnik::T>
-       Error: A "friend" declaration must specify a class or function.
-    */
-    friend class CreatePolicy;
-#else
-    friend class CreatePolicy<T>;
-    static T* pInstance_;
-    static bool destroyed_;
-    singleton(const singleton &rhs);
-    singleton& operator=(const singleton&);
-
-    static void onDeadReference()
-    {
-        throw std::runtime_error("dead reference!");
-    }
-
-    static void DestroySingleton()
-    {
-        CreatePolicy<T>::destroy(pInstance_);
-        pInstance_ = 0;
-        destroyed_ = true;
-    }
-
-protected:
-#ifdef MAPNIK_THREADSAFE
-    static mutex mutex_;
-#endif
-    singleton() {}
-public:
-    static T& instance()
-    {
-        if (! pInstance_)
         {
+            throw std::runtime_error("dead reference!");
+        }
+
+        static void DestroySingleton()
+        {
+            CreatePolicy<T>::destroy(pInstance_);
+            pInstance_ = 0;
+            destroyed_ = true;
+        }
+
+    protected:
 #ifdef MAPNIK_THREADSAFE
-            mutex::scoped_lock lock(mutex_);
+        static mutex mutex_;
 #endif
+        singleton() {}
+    public:
+        static T& instance()
+        {
             if (! pInstance_)
             {
-                if (destroyed_)
+#ifdef MAPNIK_THREADSAFE
+                mutex::scoped_lock lock(mutex_);
+#endif
+                if (! pInstance_)
                 {
-                    destroyed_ = false;
+                    if (destroyed_)
-                    onDeadReference();
+                    {
-                }
+                        destroyed_ = false;
-                else
+                        onDeadReference();
-                {
+                    }
-                    pInstance_ = CreatePolicy<T>::create();
+                    else
+                    {
+                        pInstance_ = CreatePolicy<T>::create();
 
-                    // register destruction
+                        // register destruction
-                    std::atexit(&DestroySingleton);
+                        std::atexit(&DestroySingleton);
+                    }
                 }
             }
+            return *pInstance_;
         }
-        return *pInstance_;
+    };
-    }
-};
 #ifdef MAPNIK_THREADSAFE
-template <typename T,
+    template <typename T,
-          template <typename U> class CreatePolicy> mutex singleton<T,CreatePolicy>::mutex_;
+              template <typename U> class CreatePolicy> mutex singleton<T,CreatePolicy>::mutex_;
 #endif
 
-template <typename T,
+    template <typename T,
-          template <typename U> class CreatePolicy> T* singleton<T,CreatePolicy>::pInstance_=0;
+              template <typename U> class CreatePolicy> T* singleton<T,CreatePolicy>::pInstance_=0;
-template <typename T,
+    template <typename T,
-          template <typename U> class CreatePolicy> bool singleton<T,CreatePolicy>::destroyed_=false;
+              template <typename U> class CreatePolicy> bool singleton<T,CreatePolicy>::destroyed_=false;
+
+
+#ifdef _WINDOWS
+
+#include <windows.h>
+
+    // UTF8 <--> UTF16 conversion routines
+
+    std::string utf16_to_utf8(std::wstring const& wstr)
+    {
+        std::string str;
+        int size = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, 0, 0, 0, 0);
+        if(size > 0)
+        {
+            std::vector<char> buffer(size);
+            WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, &buffer[0], size, 0, 0);
+            str.assign(buffer.begin(), buffer.end() - 1);
+        }
+        return str;
+    }
+
+    std::wstring utf8_to_utf16 (std::string const& str)
+    {
+        std::wstring wstr;
+        int size = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, 0, 0);
+        if (size > 0)
+        {
+            std::vector<wchar_t> buffer(size);
+            MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, &buffer[0], size);
+            wstr.assign(buffer.begin(), buffer.end() - 1);
+        }
+        return wstr;
+    }
+
+#endif  // _WINDOWS
 
 }