diff -r f5050f1da672 -r 04becd199f91 javacommons/javastorage/src/client/javastorageimpl.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javacommons/javastorage/src/client/javastorageimpl.cpp	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,360 @@
+/*
+* Copyright (c) 2008-2009 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:  JavaStorageImpl
+*
+*/
+
+
+#include "javacommonutils.h"
+#include "javaoslayer.h"
+#include "javastorageimpl.h"
+#include "javastorageexception.h"
+#include "javastoragenames.h"
+#include "javauid.h"
+#include "logger.h"
+#include "messagedispatcher.h"
+
+const int CLOSED = 0;
+const int OPEN = 1;
+
+using namespace java::storage;
+using namespace java::util;
+using namespace std;
+
+JavaStorageImpl::JavaStorageImpl()
+        : mConnectionStatus(CLOSED), mTransactionStatus(CLOSED)
+{
+    JELOG2(EJavaStorage);
+    mMsgDispatcher.reset(new MessageDispatcher());
+}
+
+OS_EXPORT JavaStorageImpl::~JavaStorageImpl()
+{
+    if (OPEN == mConnectionStatus)
+    {
+        close();
+    }
+}
+
+OS_EXPORT void JavaStorageImpl::open() throw(JavaStorageException)
+{
+    open(JAVA_DATABASE_NAME);
+}
+
+OS_EXPORT void JavaStorageImpl::open(const std::string& aStorageName)
+throw(JavaStorageException)
+{
+    JELOG2(EJavaStorage);
+
+    if (CLOSED == mConnectionStatus)
+    {
+        LOG1(EJavaStorage, EInfo, "Opening connection to %s ",
+             aStorageName.c_str());
+
+        if (aStorageName == "")
+        {
+            throw JavaStorageException(EInvalidStorage, "Invalid storage name",
+                                       __FILE__, __FUNCTION__, __LINE__);
+        }
+
+        mSessionID = mMsgDispatcher->createAndSendMessage(
+                         JavaStorageMessage::EOpen, "", aStorageName);
+
+        if (mSessionID == "")
+        {
+            ELOG(EJavaStorage, "No sessionID received");
+            throw JavaStorageException(EInternalError, "Internal Server Error",
+                                       __FILE__, __FUNCTION__, __LINE__);
+        }
+
+        LOG1(EJavaStorage, EInfo, "Connection sessionID %s ",
+             mSessionID.c_str());
+
+        mConnectionStatus = OPEN;
+    }
+    else
+    {
+        WLOG(EJavaStorage, "Connection already open");
+    }
+}
+
+OS_EXPORT void JavaStorageImpl::close() throw(JavaStorageException)
+{
+    JELOG2(EJavaStorage);
+
+    if (OPEN == mConnectionStatus)
+    {
+        string tempSessionId = mSessionID;
+        mSessionID = "";    // Clean in one place.
+        mConnectionStatus = CLOSED;
+        mTransactionStatus = CLOSED;
+
+        mMsgDispatcher->createAndSendMessage(JavaStorageMessage::EClose,
+                                             tempSessionId,
+                                             "");
+    }
+    else
+    {
+        WLOG(EJavaStorage, "Connection not open");
+    }
+}
+
+OS_EXPORT void JavaStorageImpl::startTransaction() throw(JavaStorageException)
+{
+    JELOG2(EJavaStorage);
+
+    if (OPEN == mConnectionStatus
+            && CLOSED == mTransactionStatus)
+    {
+        mMsgDispatcher->createAndSendMessage(
+            JavaStorageMessage::EStartTransaction, mSessionID, "");
+
+        mTransactionStatus = OPEN;
+    }
+    else
+    {
+        WLOG(EJavaStorage, "Cannot open new transaction because \
+            connection closed or already in trasaction");
+    }
+}
+
+OS_EXPORT void JavaStorageImpl::commitTransaction()
+throw(JavaStorageException)
+{
+    JELOG2(EJavaStorage);
+
+    if (OPEN == mConnectionStatus && OPEN == mTransactionStatus)
+    {
+        mTransactionStatus = CLOSED;
+
+        mMsgDispatcher->createAndSendMessage(
+            JavaStorageMessage::ECommit, mSessionID, "");
+    }
+    else
+    {
+        WLOG(EJavaStorage,
+             "Cannot commit because connection closed or not in trasaction");
+    }
+}
+
+OS_EXPORT void JavaStorageImpl::rollbackTransaction()
+throw(JavaStorageException)
+{
+    JELOG2(EJavaStorage);
+
+    if (OPEN == mConnectionStatus && OPEN == mTransactionStatus)
+    {
+        mTransactionStatus = CLOSED;
+
+        mMsgDispatcher->createAndSendMessage(
+            JavaStorageMessage::ERollback, mSessionID, "");
+    }
+    else
+    {
+        /*
+         * Transaction is reset. If connection is already closed there is no
+         * possibility to recover transaction. SQLite DB will create hot journal
+         * and create auto-rollback at some stage. To prevent that storage
+         * server does rollback if close is called while in transaction. This
+         * way server and client transactions keep in sync.
+         */
+        mTransactionStatus = CLOSED;
+        WLOG(EJavaStorage,
+             "Cannot rollback because connection closed or not in trasaction");
+    }
+}
+
+OS_EXPORT void JavaStorageImpl::read(const string& aTablename,
+                                     const Uid& aUid,
+                                     JavaStorageApplicationEntry_t& aEntries)
+throw(JavaStorageException)
+
+{
+    JELOG2(EJavaStorage);
+
+    if (OPEN != mConnectionStatus)
+    {
+        throw JavaStorageException(EInvalidConnection, "No connection",
+                                   __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    if (aTablename == "" || aUid.toString() == L"")
+    {
+        throw JavaStorageException(EInvalidArgument, "Invalid argument",
+                                   __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    JavaStorageEntry entry;
+    entry.setEntry(ID, aUid.toString());
+    aEntries.insert(entry);
+
+    mMsgDispatcher->createAndSendMessage(JavaStorageMessage::ERead,
+                                         mSessionID,
+                                         aTablename,
+                                         aEntries);
+}
+
+OS_EXPORT void JavaStorageImpl::write(
+    const string& aTablename,
+    const JavaStorageApplicationEntry_t& aEntries)
+throw(JavaStorageException)
+{
+    JELOG2(EJavaStorage);
+
+    if (OPEN != mConnectionStatus)
+    {
+        throw JavaStorageException(EInvalidConnection, "No connection",
+                                   __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    if (aTablename == "" || aEntries.size() == 0)
+    {
+        throw JavaStorageException(EInvalidArgument, "Invalid argument",
+                                   __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    mMsgDispatcher->createAndSendMessage(JavaStorageMessage::EWrite,
+                                         mSessionID,
+                                         aTablename,
+                                         aEntries);
+}
+
+OS_EXPORT void JavaStorageImpl::update(
+    const string& aTablename,
+    const JavaStorageApplicationEntry_t& aUpdateEntry,
+    const JavaStorageApplicationEntry_t& aMatchEntry)
+throw(JavaStorageException)
+{
+    JELOG2(EJavaStorage);
+
+    if (OPEN != mConnectionStatus)
+    {
+        throw JavaStorageException(EInvalidConnection, "No connection",
+                                   __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    if (aTablename == "" || aUpdateEntry.size() < 1 || aMatchEntry.size() < 1)
+    {
+        throw JavaStorageException(EInvalidArgument, "Invalid argument",
+                                   __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    mMsgDispatcher->handleUpdate(JavaStorageMessage::EUpdate,
+                                 mSessionID,
+                                 aTablename,
+                                 aUpdateEntry,
+                                 aMatchEntry);
+}
+
+OS_EXPORT void JavaStorageImpl::search(
+    const string& aTablename,
+    const JavaStorageApplicationEntry_t& aSearchPattern,
+    JavaStorageApplicationList_t& aApplicationList)
+throw(JavaStorageException)
+{
+    JELOG2(EJavaStorage);
+
+    if (OPEN != mConnectionStatus)
+    {
+        throw JavaStorageException(EInvalidConnection, "No connection",
+                                   __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    if (aTablename == "")
+    {
+        throw JavaStorageException(EInvalidArgument, "Invalid argument",
+                                   __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    mMsgDispatcher->handleSearch(JavaStorageMessage::ESearch,
+                                 mSessionID,
+                                 aTablename,
+                                 aSearchPattern,
+                                 aApplicationList);
+}
+
+OS_EXPORT int JavaStorageImpl::remove(
+    const std::string& aTablename,
+    const JavaStorageApplicationEntry_t& aRemoveQuery)
+throw(JavaStorageException)
+{
+    JELOG2(EJavaStorage);
+
+    if (aTablename == "")
+    {
+        throw JavaStorageException(EInvalidArgument, "Invalid argument",
+                                   __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    if (OPEN != mConnectionStatus)
+    {
+        throw JavaStorageException(EInvalidConnection, "No connection",
+                                   __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    return mMsgDispatcher->createAndSendMessage(JavaStorageMessage::ERemove,
+            mSessionID,
+            aTablename,
+            aRemoveQuery);
+}
+
+OS_EXPORT void JavaStorageImpl::createTable(
+    const string& aTablename,
+    const JavaStorageApplicationEntry_t& aTableColumns)
+throw(JavaStorageException)
+{
+    JELOG2(EJavaStorage);
+
+    if (OPEN != mConnectionStatus)
+    {
+        throw JavaStorageException(EInvalidConnection, "No connection",
+                                   __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    if (aTablename == "" || aTableColumns.size() < 1)
+    {
+        throw JavaStorageException(EInvalidArgument, "Invalid argument",
+                                   __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    mMsgDispatcher->createAndSendMessage(JavaStorageMessage::ECreateTable,
+                                         mSessionID,
+                                         aTablename,
+                                         aTableColumns);
+}
+
+OS_EXPORT void JavaStorageImpl::appendTable(
+    const string& aTablename,
+    const JavaStorageApplicationEntry_t& aTableColumns)
+throw(JavaStorageException)
+{
+    JELOG2(EJavaStorage);
+
+    if (OPEN != mConnectionStatus)
+    {
+        throw JavaStorageException(EInvalidConnection, "No connection",
+                                   __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    if (aTablename == "" || aTableColumns.size() < 1)
+    {
+        throw JavaStorageException(EInvalidArgument, "Invalid argument",
+                                   __FILE__, __FUNCTION__, __LINE__);
+    }
+
+    mMsgDispatcher->createAndSendMessage(JavaStorageMessage::EAppendTable,
+                                         mSessionID,
+                                         aTablename,
+                                         aTableColumns);
+}