/*
* Copyright (c) 2002-2005 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: provides functionality common to all server operations
*
*
*/


#ifndef CPOSLMSERVEROPERATION_H
#define CPOSLMSERVEROPERATION_H

#include <e32base.h>
#include <d32dbms.h>
#include <epos_cposlmlocaldbaccess.h>
#include <epos_cposlmdiskutilities.h>

const TReal32 KOperationDone = 1; // Operation is done when progress 1

class MPosLmServerOperationObserver;
class CPosLmServer;

/**
* Base class for server operations. Contains functionality common to all
* server operations.
*/
class CPosLmServerOperation : public CActive
    {
    public: // Data types

        struct TPosMessage
            {
            TAny*                   iSession;
            RMessage2               iMsg;
            };

    public:  // Constructors and destructor

        /**
        * Destructor.
        */
        virtual ~CPosLmServerOperation();

    public: // From CActive

        /**
        * Handles a leave occurring in the request completion event handler
        * RunL().
        *
        * @param[in] aError The leave code
        * @return Returns KErrNone.
        */
        TInt RunError( TInt aError );

        /**
        * Implements cancellation of an outstanding request.
        */
        void DoCancel();

    public: // New functions

        /*
        * Adds a message to the synchronous wait list. This message will not
        * be completed until the operation is done.
        *
        * @param[in, out] aMessage A message.
        * @param[in] aSession The session associated with the message.
        */
        void AddToSyncWaitListL(
            const RMessage2& aMessage,
            TAny* aSession );

        /*
        * Adds a message to the asynchronous wait list. This message will be
        * completed when a part of the operation is done to send back status
        * and progress to the client. It also completes if the operation is
        * done.
        *
        * @param[in, out] aMessage A message.
        * @param[in] aSession The session associated with the message.
        */
        void AddToAsyncWaitListL(
            const RMessage2& aMessage,
            TAny* aSession );

        /*
        * Cancels and removes a message from the asynchronous wait list. The
        * message sent as parameter is completed with KErrNone.
        *
        * @param[in,out] aMessage A message.
        * @param[in] aSession The session associated with the message.
        */
        void RemoveFromAsyncWaitList(
            const RMessage2& aMessage,
            TAny* aSession );

        /**
        * Removes messages associated with a specific session from the wait
        * lists.
        *
        * @param[in] aSession The session associated with the messages.
        */
        void RemoveSessionMessages( TAny* aSession );
        
        /** Returns status of this operation */
        TInt Status() const;
        
        /** Checks whether given session is a registered client
         *  of this operation */
        TBool IsRegistered( TAny* aSession ) const;        

        /** Checks whether this operation has registered clients */
        TBool HasClients() const;        

    protected:

        /**
        * C++ default constructor.
        *
        * @param[in] aServer Reference to the server
        * @param[in, out] aObserver Server operation observer.
        */
        CPosLmServerOperation(
            CPosLmServer& aServer,
            MPosLmServerOperationObserver* aObserver );

        /**
        * 2nd phase constructor for base class.
        *
        * @param[in] aUri Database URI.
        */
        void BaseConstructL( const TDesC& aUri );

        /**
        * Notifies the clients about the current state. Clients on the
        * asynchronous wait list will always be notified but clients on the
        * synchronous wait list will be notified only if progress is 100%.
        */
        void NotifyClients();

        /**
        * Completes this active object after each incremental step of the
        * operation.
        */
        void CompleteSelf();
        
        /** Checks if given session has requests in this operation */
        TBool HasRequests( TAny* aSession ) const;
        
    private:    // New functions

        /**
        * Writes status and progress to client.
        *
        * @param[in, out] aMessage Message arrived from client.
        */
        void Write( const RMessage2& aMessage );

        /*
        * Completes and removes the messages in the async wait list with
        * the error code of iStatusFlag. Progress is sent to client.
        *
        */
        void CompleteAndRemoveMessagesFromAsyncWaitList();

        /*
        * Completes and removes the messages in the sync wait list with
        * the error code of iStatusFlag.
        *
        */
        void CompleteAndRemoveMessagesFromSyncWaitList();

        /**
        * Removes messages associated with a specific session from a
        * specified wait list.
        *
        * @param[in, out] aWaitList A wait list.
        * @param[in] aSession The session associated with the message.
        */
        void RemoveFromWaitList(
            RArray<TPosMessage>& aWaitList,
            TAny* aSession );

        /**
        * Creates and returns a message struct based on the message and
        * the session associated with the message.
        *
        * @param[in] aMessage A message.
        * @param[in] aSession The session associated with the message.
        * @return A message struct.
        */
        TPosMessage Message(
            const RMessage2& aMessage,
            TAny* aSession );

    protected:    // Data

        CPosLmServer& iServer;
    
        // Server operation observer
        MPosLmServerOperationObserver* iObserver;

        // Wait list for synchronous messages
        RArray<TPosMessage> iSyncWaitList;

        // Wait list for asynchronous messages
        RArray<TPosMessage> iAsyncWaitList;

        // The current progress of the operation in percent.
        TReal32 iProgress;

        // The current status of the operation
        TInt iStatusFlag;

        // Disk utilities
        CPosLmDiskUtilities* iDiskUtilities;

        // The drive the database is on
        TChar iDbDrive;

        // Database
        CPosLmLocalDbAccess* iDb;

        // List of sessions
        RPointerArray<TUint> iClientSessions;
        
        // URI of a database
        HBufC* iDbUri;

    };

#endif      // CPOSLMSERVEROPERATION_H

// End of File