diff -r f5050f1da672 -r 04becd199f91 javacommons/comms/src/commsmessage.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javacommons/comms/src/commsmessage.cpp Tue Apr 27 16:30:29 2010 +0300 @@ -0,0 +1,373 @@ +/* +* 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: This class provides container for message. +* +*/ + +#include + +#include "javacommonutils.h" +#include "exceptionbase.h" + +#include "commsmessage.h" +#include "logger.h" +#include "javauid.h" + + +namespace java +{ +namespace comms +{ +using namespace std; +using namespace java::util; + + +OS_EXPORT CommsMessage::CommsMessage() + : mStream(ios::in | ios::out | ios::binary), mArray(0) +{ + memset(&mHeader, 0, sizeof(mHeader)); +} + + +OS_EXPORT CommsMessage::CommsMessage(const ipcMessage_t* aMessage) + : mStream(ios::in | ios::out | ios::binary), mArray(0) +{ + mHeader = aMessage->ipcHeader; + + mStream.clear(); + mStream.str(""); //reset + mStream.write(aMessage->data, aMessage->ipcHeader.length-sizeof(aMessage->ipcHeader)); + +} + + +OS_EXPORT CommsMessage::CommsMessage(const CommsMessage& aMessage) + : mStream(ios::in | ios::out | ios::binary), mArray(0) +{ + *this = aMessage; +} + + +OS_EXPORT CommsMessage& CommsMessage::operator=(const CommsMessage& aMessage) +{ + if (this != &aMessage) + { + mHeader = aMessage.mHeader; + + mStream.clear(); + mStream.str(""); //reset + mStream << aMessage.toString(); + } + return *this; +} + + +OS_EXPORT CommsMessage::~CommsMessage() +{ + delete[] mArray; +} + + +OS_EXPORT void CommsMessage::setMessageId(int aMessageId) +{ + mHeader.messageId = aMessageId; +} + + +OS_EXPORT void CommsMessage::setModuleId(int aModuleId) +{ + mHeader.moduleId = aModuleId; +} + + +OS_EXPORT void CommsMessage::setReceiver(int aReceiver) +{ + mHeader.receiver = aReceiver; +} + + +OS_EXPORT void CommsMessage::setSender(int aSender) +{ + mHeader.sender = aSender; +} + + +OS_EXPORT void CommsMessage::setMessageRef(int aMessageRef) +{ + mHeader.messageRef = aMessageRef; +} + + +OS_EXPORT int CommsMessage::getMessageId() const +{ + return mHeader.messageId; +} + + +OS_EXPORT int CommsMessage::getModuleId() const +{ + return mHeader.moduleId; +} + + +OS_EXPORT int CommsMessage::getReceiver() const +{ + return mHeader.receiver; +} + + +OS_EXPORT int CommsMessage::getSender() const +{ + return mHeader.sender; +} + + +OS_EXPORT bool CommsMessage::hasPermission(const CommsPermission& aPermission) const +{ + return (mHeader.permissions & aPermission) == aPermission; +} + + +OS_EXPORT int CommsMessage::getMessageRef() const +{ + return mHeader.messageRef; +} + + +OS_EXPORT void CommsMessage::replyTo(const CommsMessage& aMessage) +{ + setModuleId(aMessage.getModuleId()); + setMessageId(aMessage.getMessageId()); + setMessageRef(aMessage.getMessageRef()); + setReceiver(aMessage.getSender()); + setSender(aMessage.getReceiver()); +} + + +OS_EXPORT CommsMessage& CommsMessage::operator << (const std::string& aStr) +{ + mStream << aStr.size() << " " << aStr; + return *this; +} + + +OS_EXPORT CommsMessage& CommsMessage::operator << (const std::wstring& aStr) +{ + string str; + try + { + char* utf8 = JavaCommonUtils::wstringToUtf8(aStr); + str.assign(utf8); + delete[] utf8; + } + catch (ExceptionBase& e) + { + ELOG2(EJavaComms, "%s: wstringToUtf8 failed: %s", __PRETTY_FUNCTION__, e.toString().c_str()); + } + + (*this) << str; + + return *this; +} + + +OS_EXPORT CommsMessage& CommsMessage::operator << (const int& aInt) +{ + (*this) << JavaCommonUtils::intToString(aInt); + return *this; +} + + +OS_EXPORT CommsMessage& CommsMessage::operator << (const long long& aLong) +{ + (*this) << JavaCommonUtils::longLongToString(aLong); + return *this; +} + + +OS_EXPORT CommsMessage& CommsMessage::operator << (const java::util::Uid& aUid) +{ + (*this) << aUid.toString(); + return *this; +} + + +OS_EXPORT CommsMessage& CommsMessage::operator >> (std::wstring& aStr) +{ + string str; + (*this) >> str; + + try + { + aStr = JavaCommonUtils::utf8ToWstring(str.c_str()); + } + catch (ExceptionBase& e) + { + ELOG2(EJavaComms, "%s: utf8ToWstring failed: %s", __PRETTY_FUNCTION__, e.toString().c_str()); + aStr = L""; + } + + return *this; +} + + +OS_EXPORT CommsMessage& CommsMessage::operator >> (std::string& aStr) +{ + aStr.clear(); + int length = 0; + + if (mStream >> length) + { + //Below is skipped space character. + if (!(mStream.get())) + { + ELOG2(EJavaComms, "ios::badbit - no space after length, invalid stream? - msgId=%d - moduleId=%d", + getMessageId(), getModuleId()); + mStream.setstate(ios::badbit); + return *this; + } + + char* retPtr = new char[length]; + if (!(mStream.read(retPtr,length))) + { + ELOG2(EJavaComms, "ios::badbit - unable read all, invalid stream? - msgId=%d - moduleId=%d", + getMessageId(), getModuleId()); + mStream.setstate(ios::badbit); + delete [] retPtr; + return *this; + } + aStr.append(retPtr, length); + delete [] retPtr; + } + else + { + LOG2(EJavaComms, EInfo, "ios::badbit - nothing to read - msgId=%d - moduleId=%d", + getMessageId(), getModuleId()); + mStream.setstate(ios::badbit); + } + return *this; +} + + +OS_EXPORT CommsMessage& CommsMessage::operator >> (int& aInt) +{ + string str; + (*this) >> str; + try + { + aInt = JavaCommonUtils::stringToInt(str); + } + catch (ExceptionBase& e) + { + aInt = 0; + LOG3(EJavaComms, EInfo, "CommsMessage::operator >> (int& aInt) failed: %s - msgId=%d - moduleId=%d", + e.toString().c_str(), getMessageId(), getModuleId()); + } + return *this; +} + + +OS_EXPORT CommsMessage& CommsMessage::operator >> (long long& aLong) +{ + string str; + (*this) >> str; + try + { + aLong = JavaCommonUtils::stringToLongLong(str); + } + catch (ExceptionBase& e) + { + aLong = 0LL; + LOG3(EJavaComms, EInfo, "CommsMessage::operator >> (long long& aLong) failed: %s - msgId=%d - moduleId=%d", + e.toString().c_str(), getMessageId(), getModuleId()); + } + return *this; +} + + +OS_EXPORT CommsMessage& CommsMessage::operator >> (java::util::Uid& aUid) +{ + std::wstring str; + (*this) >> str; + java::util::Uid uid(str); + aUid = uid; + return *this; +} + + +OS_EXPORT bool CommsMessage::operator !() const +{ + if ((mStream.fail()) || (mStream.bad())) + return true; + return false; +} + + +OS_EXPORT CommsMessage::operator void*() const +{ + if ((mStream.fail()) || (mStream.bad())) + return 0; + return const_cast(this); +} + + +OS_EXPORT std::string CommsMessage::toString() const +{ + return mStream.str(); +} + + +OS_EXPORT char* CommsMessage::toByteArray() +{ + // get size + mStream.seekg(0, ios::end); + int size = mStream.tellg(); + mStream.seekg(0, ios::beg); + + if (size < 0) + { + // S60 STL implementation sets error flag on and return size -1 if stream is empty + size = 0; + mStream.clear(); + } + + delete[] mArray; + + mArray = new char[size + sizeof(ipcHeader_t)]; + ipcMessage_t* msg = reinterpret_cast(mArray); + + // get content + mStream.read(msg->data, size); + + msg->ipcHeader = mHeader; + msg->ipcHeader.length = size + sizeof(ipcHeader_t); + + return mArray; +} + + +OS_EXPORT void CommsMessage::begin() +{ + mStream.seekg(0, ios::beg); +} + + +OS_EXPORT void CommsMessage::reset() +{ + CommsMessage empty; + *this = empty; +} + +} // namespace comms +} // namespace java