Updated nativeToUTF8 and UTF8ToNative for consistency with stringToWstring/wstringToString

15 files changed, 187 insertions, 183 deletions

diff --git a/cpp/src/Freeze/EvictorI.cpp b/cpp/src/Freeze/EvictorI.cpp
index c7caa0b9f1d..626fbd47231 100644
--- a/cpp/src/Freeze/EvictorI.cpp
+++ b/cpp/src/Freeze/EvictorI.cpp
@@ -321,7 +321,7 @@ Freeze::EvictorIBase::allDbs() const
         //
         // Berkeley DB expects file paths to be UTF8 encoded.
         //
-        db.open(0, nativeToUTF8(IceUtil::getProcessStringConverter(), _filename).c_str(), 0, DB_UNKNOWN, 
+        db.open(0, nativeToUTF8(_filename, IceUtil::getProcessStringConverter()).c_str(), 0, DB_UNKNOWN, 
                 DB_RDONLY, 0);
 
         Dbc* dbc = 0;
diff --git a/cpp/src/Freeze/IndexI.cpp b/cpp/src/Freeze/IndexI.cpp
index 21231e707ca..9b1cb2c9b7f 100644
--- a/cpp/src/Freeze/IndexI.cpp
+++ b/cpp/src/Freeze/IndexI.cpp
@@ -387,7 +387,7 @@ Freeze::IndexI::associate(ObjectStoreBase* store, DbTxn* txn,
     // with deployed databases.
     //
     _db->open(txn, 
-              IceUtil::nativeToUTF8(IceUtil::getProcessStringConverter(), store->evictor()->filename()).c_str(),
+              IceUtil::nativeToUTF8(store->evictor()->filename(), IceUtil::getProcessStringConverter()).c_str(),
               _dbName.c_str(), DB_BTREE, flags, FREEZE_DB_MODE);
 
     flags = 0;
diff --git a/cpp/src/Freeze/MapDb.cpp b/cpp/src/Freeze/MapDb.cpp
index cb06a456596..897813d4148 100644
--- a/cpp/src/Freeze/MapDb.cpp
+++ b/cpp/src/Freeze/MapDb.cpp
@@ -188,7 +188,7 @@ Freeze::MapDb::MapDb(const ConnectionIPtr& connection,
             //
             // Berkeley DB expects file paths to be UTF8 encoded.
             //
-            open(txn, nativeToUTF8(getProcessStringConverter(), _dbName).c_str(), 0, DB_BTREE,
+            open(txn, nativeToUTF8(_dbName, getProcessStringConverter()).c_str(), 0, DB_BTREE,
                  flags, FREEZE_DB_MODE);
             
             StringSeq oldIndices;
@@ -442,7 +442,7 @@ Freeze::MapDb::MapDb(const Ice::CommunicatorPtr& communicator,
         //
         // Berkeley DB expects file paths to be UTF8 encoded.
         //
-        open(0, nativeToUTF8(getProcessStringConverter(), _dbName).c_str(), 0, DB_BTREE, flags,
+        open(0, nativeToUTF8(_dbName, getProcessStringConverter()).c_str(), 0, DB_BTREE, flags,
              FREEZE_DB_MODE);
     }
     catch(const ::DbException& dx)
diff --git a/cpp/src/Freeze/MapI.cpp b/cpp/src/Freeze/MapI.cpp
index 15e24028837..effaa167982 100644
--- a/cpp/src/Freeze/MapI.cpp
+++ b/cpp/src/Freeze/MapI.cpp
@@ -205,7 +205,7 @@ Freeze::MapHelper::recreate(const Freeze::ConnectionPtr& connection,
                 // Berkeley DB expects file paths to be UTF8 encoded.
                 //
                 oldDb.open(txn, 
-                           IceUtil::nativeToUTF8(IceUtil::getProcessStringConverter(), oldDbName).c_str(),
+                           IceUtil::nativeToUTF8(oldDbName, IceUtil::getProcessStringConverter()).c_str(),
                            0, DB_BTREE, DB_THREAD, FREEZE_DB_MODE);
                     
                 IceUtil::UniquePtr<MapDb> newDb(new MapDb(connectionI, dbName, key, value, keyCompare, indices, true));
@@ -1780,7 +1780,7 @@ Freeze::MapIndexI::MapIndexI(const ConnectionIPtr& connection, MapDb& db,
     // Berkeley DB expects file paths to be UTF8 encoded.
     //
     _db->open(txn, 
-              IceUtil::nativeToUTF8(IceUtil::getProcessStringConverter(), _dbName).c_str(),
+              IceUtil::nativeToUTF8(_dbName, IceUtil::getProcessStringConverter()).c_str(),
               0, DB_BTREE, flags, FREEZE_DB_MODE);
 
     //
diff --git a/cpp/src/Freeze/ObjectStore.cpp b/cpp/src/Freeze/ObjectStore.cpp
index 90756adba5e..1eaea6e2c92 100644
--- a/cpp/src/Freeze/ObjectStore.cpp
+++ b/cpp/src/Freeze/ObjectStore.cpp
@@ -139,7 +139,7 @@ Freeze::ObjectStoreBase::ObjectStoreBase(const string& facet, const string& face
         // with deployed databases.
         //
         _db->open(txn, 
-                  IceUtil::nativeToUTF8(IceUtil::getProcessStringConverter(), evictor->filename()).c_str(),
+                  IceUtil::nativeToUTF8(evictor->filename(), IceUtil::getProcessStringConverter()).c_str(),
                   _dbName.c_str(), DB_BTREE, flags, FREEZE_DB_MODE);
 
         for(size_t i = 0; i < _indices.size(); ++i)
diff --git a/cpp/src/Freeze/SharedDbEnv.cpp b/cpp/src/Freeze/SharedDbEnv.cpp
index 394d03b850d..85bd743c290 100644
--- a/cpp/src/Freeze/SharedDbEnv.cpp
+++ b/cpp/src/Freeze/SharedDbEnv.cpp
@@ -594,7 +594,7 @@ Freeze::SharedDbEnv::SharedDbEnv(const std::string& envName,
             //
             // Berkeley DB expects file paths to be UTF8 encoded.
             //
-            _env->open(nativeToUTF8(getProcessStringConverter(), dbHome).c_str(), flags, FREEZE_DB_MODE);
+            _env->open(nativeToUTF8(dbHome, getProcessStringConverter()).c_str(), flags, FREEZE_DB_MODE);
        
             //
             // Default checkpoint period is every 120 seconds
diff --git a/cpp/src/Ice/Instance.cpp b/cpp/src/Ice/Instance.cpp
index 20744535880..aa9f8247e3b 100644
--- a/cpp/src/Ice/Instance.cpp
+++ b/cpp/src/Ice/Instance.cpp
@@ -513,8 +513,8 @@ IceInternal::Instance::stringToIdentity(const string& s) const
         }
     }
 
-    ident.name = UTF8ToNative(_stringConverter, ident.name);
-    ident.category = UTF8ToNative(_stringConverter, ident.category);
+    ident.name = UTF8ToNative(ident.name, _stringConverter);
+    ident.category = UTF8ToNative(ident.category, _stringConverter);
 
     return ident;
 }
@@ -526,8 +526,8 @@ IceInternal::Instance::identityToString(const Identity& ident) const
     // This method returns the stringified identity. The returned string only
     // contains printable ascii. It can contain UTF8 in the escaped form.
     //
-    string name = nativeToUTF8(_stringConverter, ident.name);
-    string category = nativeToUTF8(_stringConverter, ident.category);
+    string name = nativeToUTF8(ident.name, _stringConverter);
+    string category = nativeToUTF8(ident.category, _stringConverter);
 
     if(category.empty())
     {
diff --git a/cpp/src/Ice/LoggerI.cpp b/cpp/src/Ice/LoggerI.cpp
index f0215401657..430d9fd49f6 100644
--- a/cpp/src/Ice/LoggerI.cpp
+++ b/cpp/src/Ice/LoggerI.cpp
@@ -154,9 +154,9 @@ Ice::LoggerI::write(const string& message, bool indent)
             //
             // Use fprintf_s to avoid encoding conversion when stderr is connected
             // to Windows console. When _convert is set to false we always output
-            // UTF8 encoded messages.
+            // UTF-8 encoded messages.
             //
-            fprintf_s(stderr, "%s\n", IceUtil::nativeToUTF8(_converter, s).c_str());
+            fprintf_s(stderr, "%s\n", IceUtil::nativeToUTF8(s, _converter).c_str());
             fflush(stderr);
         }
         else
@@ -164,7 +164,7 @@ Ice::LoggerI::write(const string& message, bool indent)
             try
             {
                 // Convert message to UTF-8
-                string u8s = IceUtil::nativeToUTF8(_converter, s);
+                string u8s = IceUtil::nativeToUTF8(s, _converter);
                 
                 // Then from UTF-8 to console CP
                 string consoleString;
diff --git a/cpp/src/Ice/Makefile b/cpp/src/Ice/Makefile
index 8e2835b9545..a3f34cbb0c5 100644
--- a/cpp/src/Ice/Makefile
+++ b/cpp/src/Ice/Makefile
@@ -31,6 +31,7 @@ OBJS		= Acceptor.o \
 		  Connector.o \
 		  Current.o \
 		  DefaultsAndOverrides.o \
+                  DeprecatedStringConverter.o \
 		  Direct.o \
                   DispatchInterceptor.o \
 		  DynamicLibrary.o \
diff --git a/cpp/src/Ice/Makefile.mak b/cpp/src/Ice/Makefile.mak
index f20352780c7..ad6e5e9afb5 100644
--- a/cpp/src/Ice/Makefile.mak
+++ b/cpp/src/Ice/Makefile.mak
@@ -31,6 +31,7 @@ OBJS		= Acceptor.obj \
 		  ConnectionRequestHandler.obj \
 		  Current.obj \
 		  DefaultsAndOverrides.obj \
+                  DeprecatedStringConverter.obj \
 		  Direct.obj \
                   DispatchInterceptor.obj \
 		  DLLMain.obj \
diff --git a/cpp/src/Ice/PropertiesI.cpp b/cpp/src/Ice/PropertiesI.cpp
index b466a2cf105..121e6ed8889 100644
--- a/cpp/src/Ice/PropertiesI.cpp
+++ b/cpp/src/Ice/PropertiesI.cpp
@@ -702,8 +702,8 @@ Ice::PropertiesI::parseLine(const string& line, const IceUtil::StringConverterPt
         return;
     }
 
-    key = IceUtil::UTF8ToNative(converter, key);
-    value = IceUtil::UTF8ToNative(converter, value);
+    key = IceUtil::UTF8ToNative(key, converter);
+    value = IceUtil::UTF8ToNative(value, converter);
 
     setProperty(key, value);
 }
diff --git a/cpp/src/Ice/Reference.cpp b/cpp/src/Ice/Reference.cpp
index be40f3f0df9..a80de29ed09 100644
--- a/cpp/src/Ice/Reference.cpp
+++ b/cpp/src/Ice/Reference.cpp
@@ -238,7 +238,7 @@ IceInternal::Reference::toString() const
         // the reference parser uses as separators, then we enclose
         // the facet string in quotes.
         //
-        string fs = nativeToUTF8(_instance->getStringConverter(), _facet);
+        string fs = nativeToUTF8(_facet, _instance->getStringConverter());
         fs = IceUtilInternal::escapeString(fs, "");
         if(fs.find_first_of(" :@") != string::npos)
         {
@@ -1207,7 +1207,7 @@ IceInternal::RoutableReference::toString() const
         // reference parser uses as separators, then we enclose the
         // adapter id string in quotes.
         //
-        string a = nativeToUTF8(getInstance()->getStringConverter(), _adapterId);
+        string a = nativeToUTF8(_adapterId, getInstance()->getStringConverter());
         a = IceUtilInternal::escapeString(a, "");
         if(a.find_first_of(" :@") != string::npos)
         {
diff --git a/cpp/src/Ice/ReferenceFactory.cpp b/cpp/src/Ice/ReferenceFactory.cpp
index a96fd7630cd..37c061a4296 100644
--- a/cpp/src/Ice/ReferenceFactory.cpp
+++ b/cpp/src/Ice/ReferenceFactory.cpp
@@ -288,7 +288,7 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
                     throw ex;
                 }
 
-                facet = UTF8ToNative(_instance->getStringConverter(), facet);
+                facet = UTF8ToNative(facet, _instance->getStringConverter());
                 break;
             }
 
@@ -569,7 +569,7 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP
                 throw ex;
             }
 
-            adapter = UTF8ToNative(_instance->getStringConverter(), adapter);
+            adapter = UTF8ToNative(adapter, _instance->getStringConverter());
 
             return create(ident, facet, mode, secure, protocol, encoding, endpoints, adapter, propertyPrefix);
             break;
diff --git a/cpp/src/Ice/ServantManager.cpp b/cpp/src/Ice/ServantManager.cpp
index 45f9e8dbb76..e4e50a7375f 100644
--- a/cpp/src/Ice/ServantManager.cpp
+++ b/cpp/src/Ice/ServantManager.cpp
@@ -47,7 +47,7 @@ IceInternal::ServantManager::addServant(const ObjectPtr& object, const Identity&
             ex.id = _instance->identityToString(ident);
             if(!facet.empty())
             {
-                string fs = nativeToUTF8(_instance->getStringConverter(), facet);
+                string fs = nativeToUTF8(facet, _instance->getStringConverter());
                 ex.id += " -f " + IceUtilInternal::escapeString(fs, "");
             }
             throw ex;
@@ -107,7 +107,7 @@ IceInternal::ServantManager::removeServant(const Identity& ident, const string&
         ex.id = _instance->identityToString(ident);
         if(!facet.empty())
         {
-            string fs = nativeToUTF8(_instance->getStringConverter(), facet);
+            string fs = nativeToUTF8(facet, _instance->getStringConverter());
             ex.id += " -f " + IceUtilInternal::escapeString(fs, "");
         }
         throw ex;
diff --git a/cpp/src/IceUtil/StringConverter.cpp b/cpp/src/IceUtil/StringConverter.cpp
index c76a636ac17..1a6fe6e8405 100644
--- a/cpp/src/IceUtil/StringConverter.cpp
+++ b/cpp/src/IceUtil/StringConverter.cpp
@@ -37,7 +37,6 @@ Init init;
 
 }
 
-
 namespace
 {
 
@@ -96,166 +95,7 @@ private:
 
 }
 
-StringConverterPtr
-IceUtil::getProcessStringConverter()
-{
-    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(processStringConverterMutex);
-    return processStringConverter;
-}
-
-void
-IceUtil::setProcessStringConverter(const StringConverterPtr& converter)
-{
-   IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(processStringConverterMutex);
-   processStringConverter = converter;
-}
-
-WstringConverterPtr
-IceUtil::getProcessWstringConverter()
-{
-    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(processStringConverterMutex);
-    return processWstringConverter;
-}
-
-void
-IceUtil::setProcessWstringConverter(const WstringConverterPtr& converter)
-{
-   IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(processStringConverterMutex);
-   processWstringConverter = converter;
-}
-
-string
-IceUtil::nativeToUTF8(const IceUtil::StringConverterPtr& converter, const string& str)
-{
-    if(!converter || str.empty())
-    {
-        return str;
-    }    
-    UTF8BufferI buffer;
-    Byte* last = converter->toUTF8(str.data(), str.data() + str.size(), buffer);
-    return string(reinterpret_cast<const char*>(buffer.getBuffer()), last - buffer.getBuffer());
-}
-
-string
-IceUtil::UTF8ToNative(const IceUtil::StringConverterPtr& converter, const string& str)
-{
-    if(!converter || str.empty())
-    {
-        return str;
-    }
-    string tmp;
-    converter->fromUTF8(reinterpret_cast<const Byte*>(str.data()),
-                        reinterpret_cast<const Byte*>(str.data() + str.size()), tmp);
-    return tmp;
-}
-
-string
-IceUtil::wstringToString(const wstring& v, const StringConverterPtr& converter, const WstringConverterPtr& wConverter,
-                         IceUtil::ConversionFlags flags)
-{
-    string target;
-    if(!v.empty())
-    {
-        //
-        // First convert to UTF8 narrow string.
-        //
-        if(wConverter)
-        {
-            UTF8BufferI buffer;
-            Byte* last = wConverter->toUTF8(v.data(), v.data() + v.size(), buffer);
-            target = string(reinterpret_cast<const char*>(buffer.getBuffer()), last - buffer.getBuffer());
-        }
-        else
-        {
-            size_t size = v.size() * 4 * sizeof(char);
 
-            Byte* outBuf = new Byte[size];
-            Byte* targetStart = outBuf; 
-            Byte* targetEnd = outBuf + size;
-
-            const wchar_t* sourceStart = v.data();
-  
-            ConversionResult cr = 
-                convertUTFWstringToUTF8(
-                    sourceStart, sourceStart + v.size(), 
-                    targetStart, targetEnd, flags);
-                
-            if(cr != conversionOK)
-            {
-                delete[] outBuf;
-                assert(cr == sourceExhausted || cr == sourceIllegal);
-                throw IllegalConversionException(__FILE__, __LINE__, 
-                                                 cr == sourceExhausted ? "partial character" : "bad encoding");
-            }
-            
-            target = string(reinterpret_cast<char*>(outBuf), static_cast<size_t>(targetStart - outBuf));
-            delete[] outBuf;
-        }
-
-        //
-        // If narrow string converter is present convert to the native narrow string encoding, otherwise 
-        // native narrow string encoding is UTF8 and we are done.
-        //
-        if(converter)
-        {
-            string tmp;
-            converter->fromUTF8(reinterpret_cast<const Byte*>(target.data()), 
-                                reinterpret_cast<const Byte*>(target.data() + target.size()), tmp);
-            tmp.swap(target);
-        }
-    }
-    return target;
-}
-
-wstring
-IceUtil::stringToWstring(const string& v, const StringConverterPtr& converter, 
-                         const WstringConverterPtr& wConverter, IceUtil::ConversionFlags flags)
-{
-    wstring target;
-    if(!v.empty())
-    {
-        //
-        // If there is a narrow string converter use it to convert to UTF8, otherwise the narrow
-        // string is already UTF8 encoded.
-        //
-        string tmp;
-        if(converter)
-        {
-            UTF8BufferI buffer;
-            Byte* last = converter->toUTF8(v.data(), v.data() + v.size(), buffer);
-            tmp = string(reinterpret_cast<const char*>(buffer.getBuffer()), last - buffer.getBuffer());
-        }
-        else
-        {
-            tmp = v;
-        }
-
-        //
-        // If there is a wide string converter use fromUTF8 to convert to the wide string native encoding.
-        //
-        if(wConverter)
-        {
-            wConverter->fromUTF8(reinterpret_cast<const Byte*>(tmp.data()), 
-                                 reinterpret_cast<const Byte*>(tmp.data() + tmp.size()), target);
-        }
-        else
-        {
-            const Byte* sourceStart = reinterpret_cast<const Byte*>(tmp.data());
-            
-            ConversionResult cr = 
-                convertUTF8ToUTFWstring(sourceStart, sourceStart + tmp.size(), target, flags);
-
-            if(cr != conversionOK)
-            {
-                assert(cr == sourceExhausted || cr == sourceIllegal);
-
-                throw IllegalConversionException(__FILE__, __LINE__,
-                                                 cr == sourceExhausted ? "partial character" : "bad encoding");
-            }
-        }
-    }
-    return target;
-}
 
 UnicodeWstringConverter::UnicodeWstringConverter(ConversionFlags flags) :
     _conversionFlags(flags)
@@ -438,3 +278,165 @@ WindowsStringConverter::fromUTF8(const Byte* sourceStart, const Byte* sourceEnd,
 }
 
 #endif
+
+
+StringConverterPtr
+IceUtil::getProcessStringConverter()
+{
+    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(processStringConverterMutex);
+    return processStringConverter;
+}
+
+void
+IceUtil::setProcessStringConverter(const StringConverterPtr& converter)
+{
+   IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(processStringConverterMutex);
+   processStringConverter = converter;
+}
+
+WstringConverterPtr
+IceUtil::getProcessWstringConverter()
+{
+    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(processStringConverterMutex);
+    return processWstringConverter;
+}
+
+void
+IceUtil::setProcessWstringConverter(const WstringConverterPtr& converter)
+{
+   IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(processStringConverterMutex);
+   processWstringConverter = converter;
+}
+
+string
+IceUtil::wstringToString(const wstring& v, const StringConverterPtr& converter, const WstringConverterPtr& wConverter,
+                         IceUtil::ConversionFlags flags)
+{
+    string target;
+    if(!v.empty())
+    {
+        //
+        // First convert to UTF8 narrow string.
+        //
+        if(wConverter)
+        {
+            UTF8BufferI buffer;
+            Byte* last = wConverter->toUTF8(v.data(), v.data() + v.size(), buffer);
+            target = string(reinterpret_cast<const char*>(buffer.getBuffer()), last - buffer.getBuffer());
+        }
+        else
+        {
+            size_t size = v.size() * 4 * sizeof(char);
+
+            Byte* outBuf = new Byte[size];
+            Byte* targetStart = outBuf; 
+            Byte* targetEnd = outBuf + size;
+
+            const wchar_t* sourceStart = v.data();
+  
+            ConversionResult cr = 
+                convertUTFWstringToUTF8(
+                    sourceStart, sourceStart + v.size(), 
+                    targetStart, targetEnd, flags);
+                
+            if(cr != conversionOK)
+            {
+                delete[] outBuf;
+                assert(cr == sourceExhausted || cr == sourceIllegal);
+                throw IllegalConversionException(__FILE__, __LINE__, 
+                                                 cr == sourceExhausted ? "partial character" : "bad encoding");
+            }
+            
+            target = string(reinterpret_cast<char*>(outBuf), static_cast<size_t>(targetStart - outBuf));
+            delete[] outBuf;
+        }
+
+        //
+        // If narrow string converter is present convert to the native narrow string encoding, otherwise 
+        // native narrow string encoding is UTF8 and we are done.
+        //
+        if(converter)
+        {
+            string tmp;
+            converter->fromUTF8(reinterpret_cast<const Byte*>(target.data()), 
+                                reinterpret_cast<const Byte*>(target.data() + target.size()), tmp);
+            tmp.swap(target);
+        }
+    }
+    return target;
+}
+
+wstring
+IceUtil::stringToWstring(const string& v, const StringConverterPtr& converter, 
+                         const WstringConverterPtr& wConverter, IceUtil::ConversionFlags flags)
+{
+    wstring target;
+    if(!v.empty())
+    {
+        //
+        // If there is a narrow string converter use it to convert to UTF8, otherwise the narrow
+        // string is already UTF8 encoded.
+        //
+        string tmp;
+        if(converter)
+        {
+            UTF8BufferI buffer;
+            Byte* last = converter->toUTF8(v.data(), v.data() + v.size(), buffer);
+            tmp = string(reinterpret_cast<const char*>(buffer.getBuffer()), last - buffer.getBuffer());
+        }
+        else
+        {
+            tmp = v;
+        }
+
+        //
+        // If there is a wide string converter use fromUTF8 to convert to the wide string native encoding.
+        //
+        if(wConverter)
+        {
+            wConverter->fromUTF8(reinterpret_cast<const Byte*>(tmp.data()), 
+                                 reinterpret_cast<const Byte*>(tmp.data() + tmp.size()), target);
+        }
+        else
+        {
+            const Byte* sourceStart = reinterpret_cast<const Byte*>(tmp.data());
+            
+            ConversionResult cr = 
+                convertUTF8ToUTFWstring(sourceStart, sourceStart + tmp.size(), target, flags);
+
+            if(cr != conversionOK)
+            {
+                assert(cr == sourceExhausted || cr == sourceIllegal);
+
+                throw IllegalConversionException(__FILE__, __LINE__,
+                                                 cr == sourceExhausted ? "partial character" : "bad encoding");
+            }
+        }
+    }
+    return target;
+}
+
+string
+IceUtil::nativeToUTF8(const string& str, const IceUtil::StringConverterPtr& converter)
+{
+    if(!converter || str.empty())
+    {
+        return str;
+    }    
+    UTF8BufferI buffer;
+    Byte* last = converter->toUTF8(str.data(), str.data() + str.size(), buffer);
+    return string(reinterpret_cast<const char*>(buffer.getBuffer()), last - buffer.getBuffer());
+}
+
+string
+IceUtil::UTF8ToNative(const string& str, const IceUtil::StringConverterPtr& converter)
+{
+    if(!converter || str.empty())
+    {
+        return str;
+    }
+    string tmp;
+    converter->fromUTF8(reinterpret_cast<const Byte*>(str.data()),
+                        reinterpret_cast<const Byte*>(str.data() + str.size()), tmp);
+    return tmp;
+}