--- /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;
+}
+