diff -r e8e63152f320 -r 2a9601315dfc javacommons/utils/src/javacommonutils.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javacommons/utils/src/javacommonutils.cpp	Mon May 03 12:27:20 2010 +0300
@@ -0,0 +1,391 @@
+/*
+* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:  JavaCommonUtils
+*
+*/
+
+
+#include <iostream>
+#include <sstream>
+#include <vector>
+
+#include <string.h>
+
+#include <openssl/bio.h>
+#include <openssl/evp.h>
+#include <openssl/buffer.h>
+
+#include "logger.h"
+#include "javacommonutils.h"
+#include "exceptionbase.h"
+#include "convertutf.h"
+
+using namespace java::util;
+
+OS_EXPORT int JavaCommonUtils::stringToInt(const std::string& str)
+{
+//    JELOG2(EUtils);
+//    value = boost::lexical_cast<int>( str );
+    std::istringstream iss(str);
+    int value = -1;
+    if (!(iss >> value))
+    {
+        std::string errorStr = "Not able to convert to integer: ";
+        errorStr.append(str);
+        throw ExceptionBase(errorStr, __FILE__, __FUNCTION__, __LINE__);
+    }
+    return value;
+}
+
+OS_EXPORT long long JavaCommonUtils::stringToLongLong(const std::string& str)
+{
+//  JELOG2(EUtils);
+    std::istringstream iss(str);
+    long long value = -1LL;
+    if (!(iss >> value))
+    {
+        std::string errorStr = "Not able to convert to 'long long': ";
+        errorStr.append(str);
+        throw ExceptionBase(errorStr, __FILE__, __FUNCTION__, __LINE__);
+    }
+    return value;
+}
+
+OS_EXPORT std::string JavaCommonUtils::intToString(const int& value)
+{
+//    JELOG2(EUtils);
+//    str = boost::lexical_cast<std::string>( value );
+    std::ostringstream oss;
+    oss<<value;
+    return oss.str();
+}
+
+OS_EXPORT std::string JavaCommonUtils::longLongToString(const long long& value)
+{
+//  JELOG2(EUtils);
+    std::ostringstream oss;
+    oss<<value;
+    return oss.str();
+}
+
+OS_EXPORT int JavaCommonUtils::wstringToInt(const std::wstring& str)
+{
+//    JELOG2(EUtils);
+    //throw ExceptionBase("JavaCommonUtils::wstringToInt not supported yet", __FILE__, __FUNCTION__, __LINE__);
+//    value = boost::lexical_cast<int>( str );
+
+    std::wistringstream iss(str);
+    int value = -1;
+    if (!(iss >> value))
+    {
+        std::string errorStr = "Not able to convert wstring to integer";
+        throw ExceptionBase(errorStr, __FILE__, __FUNCTION__, __LINE__);
+    }
+    return value;
+}
+
+OS_EXPORT std::wstring JavaCommonUtils::intToWstring(const int& value)
+{
+//    JELOG2(EUtils);
+    //throw ExceptionBase("JavaCommonUtils::wstringToInt not supported yet", __FILE__, __FUNCTION__, __LINE__);
+//  return boost::lexical_cast<std::wstring>( value );
+    std::wostringstream oss;
+    oss<<value;
+    return oss.str();
+}
+
+OS_EXPORT std::wstring JavaCommonUtils::longLongToWstring(const long long& value)
+{
+//  JELOG2(EUtils);
+    std::wostringstream oss;
+    oss<<value;
+    return oss.str();
+}
+
+OS_EXPORT long long JavaCommonUtils::wstringToLongLong(const std::wstring& str)
+{
+//  JELOG2(EUtils);
+    std::wistringstream iss(str);
+    long long value;
+    if (!(iss >> value))
+    {
+        std::string errorStr = "Not able to convert wstring to 'long long'";
+        throw ExceptionBase(errorStr, __FILE__, __FUNCTION__, __LINE__);
+    }
+    return value;
+}
+
+OS_EXPORT std::wstring JavaCommonUtils::utf8ToWstring(const char* chr)
+{
+//    JELOG2(EUtils);
+    if (chr==0)
+    {
+        throw ExceptionBase("Null argument", __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    size_t widesize = strlen(chr);
+    if (sizeof(wchar_t) == 2)
+    {
+        wchar_t* widestringnative = new wchar_t[widesize+3];
+        const UTF8* sourcestart = reinterpret_cast<const UTF8*>(chr);
+        const UTF8* sourceend = sourcestart + widesize;
+        UTF16* targetstart = reinterpret_cast<UTF16*>(widestringnative);
+        UTF16* targetend = targetstart + widesize + 3;
+        ConversionResult res =
+            ConvertUTF8toUTF16(&sourcestart, sourceend, &targetstart, targetend, lenientConversion);
+        if (res != conversionOK)
+        {
+            delete [] widestringnative;
+            std::string errorStr = "Not able to convert utf8 to utf16 wstring";
+            throw ExceptionBase(errorStr, __FILE__, __FUNCTION__, __LINE__);
+        }
+        *targetstart = 0;  // add terminating null character
+        std::wstring resultstring(widestringnative);
+        delete [] widestringnative;
+        return resultstring;
+    }
+    else if (sizeof(wchar_t) == 4)
+    {
+        wchar_t* widestringnative = new wchar_t[widesize+3];
+        const UTF8* sourcestart = reinterpret_cast<const UTF8*>(chr);
+        const UTF8* sourceend = sourcestart + widesize;
+        UTF32* targetstart = reinterpret_cast<UTF32*>(widestringnative);
+        UTF32* targetend = targetstart + widesize + 3;
+        ConversionResult res =
+            ConvertUTF8toUTF32(&sourcestart, sourceend, &targetstart, targetend, lenientConversion);
+        if (res != conversionOK)
+        {
+            delete [] widestringnative;
+            std::string errorStr = "Not able to convert utf8 to utf32 wstring";
+            throw ExceptionBase(errorStr, __FILE__, __FUNCTION__, __LINE__);
+        }
+        *targetstart = 0; // add terminating null character
+        std::wstring resultstring(widestringnative);
+        delete [] widestringnative;
+        return resultstring;
+    }
+    else
+    {
+        int len = strlen(chr);
+        wchar_t* dest = new wchar_t[len+1];
+        int i;
+        for (i = 0; i < len; i++)
+        {
+            dest[i] = chr[i];
+        }
+        dest[i] = 0;
+        std::wstring result = std::wstring(dest);
+        delete [] dest;
+        return result;
+    }
+}
+
+OS_EXPORT char* JavaCommonUtils::wstringToUtf8(const std::wstring& str)
+{
+    size_t widesize = str.length();
+
+    if (sizeof(wchar_t) == 2)
+    {
+        size_t utf8size = 3 * widesize + 3;
+        // should be large enough to contain the conversion always
+        char* utf8stringnative = new char[utf8size];
+        const UTF16* sourcestart = reinterpret_cast<const UTF16*>(str.c_str());
+        const UTF16* sourceend = sourcestart + widesize;
+        UTF8* targetstart = reinterpret_cast<UTF8*>(utf8stringnative);
+        UTF8* targetend = targetstart + utf8size;
+        ConversionResult res =
+            ConvertUTF16toUTF8(&sourcestart, sourceend, &targetstart, targetend, lenientConversion);
+        if (res != conversionOK)
+        {
+            delete [] utf8stringnative;
+            std::string errorStr = "Not able to convert utf16 wstring to utf8";
+            throw ExceptionBase(errorStr, __FILE__, __FUNCTION__, __LINE__);
+        }
+        *targetstart = 0;
+        return utf8stringnative;
+    }
+    else if (sizeof(wchar_t) == 4)
+    {
+        size_t utf8size = 4 * widesize + 3;
+        // should be large enough to contain the conversion always
+        char* utf8stringnative = new char[utf8size];
+        const UTF32* sourcestart = reinterpret_cast<const UTF32*>(str.c_str());
+        const UTF32* sourceend = sourcestart + widesize;
+        UTF8* targetstart = reinterpret_cast<UTF8*>(utf8stringnative);
+        UTF8* targetend = targetstart + utf8size;
+        ConversionResult res =
+            ConvertUTF32toUTF8(&sourcestart, sourceend, &targetstart, targetend, lenientConversion);
+        if (res != conversionOK)
+        {
+            delete [] utf8stringnative;
+            std::string errorStr = "Not able to convert utf32 wstring to utf8";
+            throw ExceptionBase(errorStr, __FILE__, __FUNCTION__, __LINE__);
+        }
+        *targetstart = 0;
+        return utf8stringnative;
+    }
+    else
+    {
+        char* chr = new char[str.size()+1];
+        sprintf(chr,"%ls",str.c_str());
+        return chr;
+    }
+}
+
+OS_EXPORT void JavaCommonUtils::trimWstring(std::wstring& aStr,
+        const wchar_t& aStrippedChar)
+{
+    if (aStr.empty())
+        return;
+    std::string::size_type const first = aStr.find_first_not_of(aStrippedChar);
+    std::string::size_type const second = aStr.find_last_not_of(aStrippedChar);
+    aStr = aStr.substr(first,second-first+1);
+}
+
+OS_EXPORT std::string JavaCommonUtils::base64encode(const std::string& aData)
+{
+    BIO* b64  = BIO_new(BIO_f_base64());
+    if (NULL == b64)
+    {
+        return "";
+    }
+    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
+    BIO* bmem = BIO_new(BIO_s_mem());
+
+    b64 = BIO_push(b64, bmem);
+    BIO_write(b64, aData.c_str(), aData.length());
+    BIO_flush(b64);
+
+    BUF_MEM* bptr;
+    BIO_get_mem_ptr(b64, &bptr);
+
+    std::string result;
+    result.insert(0, bptr->data, bptr->length);
+    BIO_free_all(b64);
+
+    return result;
+}
+
+OS_EXPORT std::string JavaCommonUtils::base64decode(const std::string& aData)
+{
+    BIO* b64  = BIO_new(BIO_f_base64());
+    if (NULL == b64)
+    {
+        return "";
+    }
+    BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
+    BIO* bmem = BIO_new_mem_buf(
+                    const_cast<char*>(aData.c_str()), aData.length());
+
+    bmem = BIO_push(b64, bmem);
+
+    char* buf = new char[aData.length()];
+    int olen = BIO_read(bmem, buf, aData.length());
+
+    std::string result;
+    result.insert(0, buf, olen);
+
+    BIO_free_all(bmem);
+    delete[] buf;
+
+    return result;
+}
+
+OS_EXPORT std::wstring JavaCommonUtils::percentDecode(const std::wstring& str)
+{
+    const std::wstring percent(L"%");
+    std::string::size_type idx = str.find(percent);
+    std::string::size_type cur = 0;
+
+    std::wstring res;
+    std::string convBuf;
+
+    while (idx != std::string::npos)
+    {
+        // Add all characters before % sequence to final result string
+        if ((idx - cur) > 0)
+        {
+            res.append(str.substr(cur, (idx - cur)));
+        }
+
+        // Decode all percent encoded chars in this sequence.
+        do
+        {
+            char ch = decodeOnePercentSeq(str.at(idx + 1), str.at(idx + 2));
+            // Add one UTF-8 value in this sequence to the buffer that will
+            // be converter to UTF-16
+            convBuf.append(&ch, 1);
+            cur = idx + 3;
+            idx = str.find(percent, cur);
+        }
+        while (idx == cur);
+
+        // Now convert all UTF-8 values in buffer to UTF-16 and add result
+        // to the final result string
+        res.append(utf8ToWstring(convBuf.c_str()));
+        convBuf.clear();
+    }
+
+    // Add characters after last % sequence if any
+    res.append(str.substr(cur, str.length() - cur));
+
+    return res;
+}
+
+
+char JavaCommonUtils::decodeOnePercentSeq(wchar_t first, wchar_t sec)
+{
+    // Handle one encoded %XY
+    char decodedCh = 0;
+    wchar_t ch = first;
+    if ((ch >= '0') && (ch <= '9'))
+    {
+        decodedCh = (ch - '0') * 16;
+    }
+    else if ((ch >= 'A') && (ch <= 'F'))
+    {
+        decodedCh = ((ch - 'A') + 10) * 16;
+    }
+    else if ((ch >= 'a') && (ch <= 'f'))
+    {
+        decodedCh = ((ch - 'a') + 10) * 16;
+    }
+    else
+    {
+        std::string errorStr = "Illegal % encoding";
+        throw ExceptionBase(errorStr, __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    ch = sec;
+    if ((ch >= '0') && (ch <= '9'))
+    {
+        decodedCh += (ch - '0');
+    }
+    else if ((ch >= 'A') && (ch <= 'F'))
+    {
+        decodedCh += (ch - 'A') + 10;
+    }
+    else if ((ch >= 'a') && (ch <= 'f'))
+    {
+        decodedCh += (ch - 'a') + 10;
+    }
+    else
+    {
+        std::string errorStr = "Illegal % encoding";
+        throw ExceptionBase(errorStr, __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    return decodedCh;
+}
+