diff -r 000000000000 -r 72b543305e3a email/pop3andsmtpmtm/clientmtms/inc/OFFOP.H --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/email/pop3andsmtpmtm/clientmtms/inc/OFFOP.H Thu Dec 17 08:44:11 2009 +0200 @@ -0,0 +1,272 @@ +// Copyright (c) 1998-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: +// + +#if !defined(__OFFOP_H__) +#define __OFFOP_H__ + +#if !defined (__MSVIDS_H__) +#include +#endif + +#if !defined (__MSVUIDS_H__) +#include +#endif + +#if !defined(__MSVSTORE_H__) +#include +#endif + +#include + +const TInt KCurrentOfflineOperationArrayVersion = 2; +_LIT(KImcmPanic, "IMCM"); + +class CMsvEntry; + +// +// CImOffLineOperation container for cached off line operation, to be performed +// on next connection to remote server. +class CImOffLineOperation : public CBase +/** +@internalTechnology +@released +*/ + { + public: + enum TOffLineOpType + { + EOffLineOpNone = 0x0000, +// + EOffLineOpCopyToLocal = 0x0001, + EOffLineOpCopyFromLocal, + EOffLineOpCopyWithinService, +// + EOffLineOpMoveToLocal = 0x0010, + EOffLineOpMoveFromLocal, + EOffLineOpMoveWithinService, +// + EOffLineOpDelete = 0x0020, +// + EOffLineOpChange = 0x0030, + EOffLineOpCreate, +// + EOffLineOpMtmSpecific = 0x0100, + }; + + public: // Constructor of a null operation + IMPORT_C CImOffLineOperation(); + IMPORT_C ~CImOffLineOperation(); + public: // Set this operation to a specific type. + inline void SetCopyToLocal(TMsvId aMessageId, TMsvId aTargetFolderId); + inline void SetCopyFromLocal(TMsvId aMessageId, TMsvId aTargetFolderId); + inline void SetCopyWithinService(TMsvId aMessageId, TMsvId aTargetFolderId); +// + inline void SetMoveToLocal(TMsvId aMessageId, TMsvId aTargetFolderId); + inline void SetMoveFromLocal(TMsvId aMessageId, TMsvId aTargetFolderId); + inline void SetMoveWithinService(TMsvId aMessageId, TMsvId aTargetFolderId); + + inline void SetDelete(TMsvId aMessageId); + inline void SetChange(TMsvId aMessageId); + inline void SetCreate(TMsvId aMessageId); + IMPORT_C void SetMtmSpecificCommandL(TMsvId aMessageId, TMsvId aTargetFolderId, TInt aMtmFunctionId, const TDesC8& aParameters); + public: // Access to parameters of operation + inline TOffLineOpType OpType()const ; + inline TMsvId MessageId()const ; + inline TMsvId TargetMessageId()const ; + inline TInt MtmFunctionId() const ; + inline TPtrC8 MtmParameters() const ; + + public: + IMPORT_C void DetachMtmParameters() ; + // Need this detach because the copy constructor will not be called when appending this class to an array! + IMPORT_C void DeleteBuffer(); + // Need this because destructor will not be called when item is removed from an array + public: + IMPORT_C TBool Equals(const CImOffLineOperation& aOperation) const; + IMPORT_C void CopyL(const CImOffLineOperation& aOperation); + // Copy-constructor that can leave + public: + IMPORT_C void ExternalizeL( RMsvWriteStream& aWriteStream ) const; + IMPORT_C void InternalizeL( RMsvReadStream& aReadStream ); + public: + IMPORT_C int operator ==(const CImOffLineOperation& otherOperation) const; + private: + IMPORT_C void SetOperation(TOffLineOpType aOpType, TMsvId aMessageId, TMsvId aTargetFolderId, TInt aMtmFunctionId, HBufC8* aParameters); + IMPORT_C void SetOperation(TOffLineOpType aOpType, TMsvId aMessageId, TMsvId aTargetFolderId); + private: + TOffLineOpType iOpType; + TMsvId iMessageId; + TMsvId iTargetMessageId; + TInt iMtmFunctionId; + HBufC8* iMtmParameters; // Mtm-specifics + }; + +// +// MOffLineOperationArray : generic mixin for accessing arrays of Off line operations. +class MImOffLineOperationArray +/** +@internalTechnology +@released +*/ + { + public: + virtual TInt CountOperations() const = 0; + virtual const CImOffLineOperation& Operation(TInt aIndex) const = 0; + virtual void AppendOperationL(const CImOffLineOperation& aOperation) = 0; + virtual void Delete(TInt aIndex) = 0; + }; + +// +// CImOffLineArrayStore : storing and restoring MImOffLineOperationArray +// derived classes +class CImOffLineArrayStore : public CBase +/** +@internalTechnology +@released +*/ + { + public: + inline CImOffLineArrayStore(MImOffLineOperationArray& aArray); + inline void SetVersion(TUint16 aVersion); + inline TUint16 Version(); + IMPORT_C void StoreL(CMsvStore& aMsvStore) const; + IMPORT_C void RestoreL(const CMsvStore& aMessageStore ); + IMPORT_C void ExternalizeL(RMsvWriteStream& aWriteStream) const; + IMPORT_C void InternalizeL(RMsvReadStream& aReadStream); + private: + TUint16 iVersion; + MImOffLineOperationArray* iArray; + }; + +// +// CImOffLineOperationArray : implementation of MImOffLineOperationArray +class CImOffLineOperationArray : public CBase, public MImOffLineOperationArray +/** +@internalTechnology +@released +*/ + { + public: + IMPORT_C static CImOffLineOperationArray* NewL(); + IMPORT_C virtual ~CImOffLineOperationArray(); + public: // derived from MImOffLineOperationArray + TInt CountOperations() const; + const CImOffLineOperation& Operation(TInt aIndex) const; + void AppendOperationL(const CImOffLineOperation& aOperation); + void Delete(TInt aIndex); + public: // Not derived from MImOffLineOperationArray + IMPORT_C void InsertOperationL(CImOffLineOperation& aOperation, TInt aPosition); + protected: + CImOffLineOperationArray(); + IMPORT_C void ConstructL(); + protected: + CArrayFixFlat *iArray; + }; + + +class TQueuedOperation +/** +@internalComponent +@released +*/ + { + public: + IMPORT_C static TQueuedOperation* NewL(TMsvId aFolderId,TInt aOperationIndex, const CImOffLineOperation& aStoredOperation); + IMPORT_C TQueuedOperation(); + IMPORT_C TBool operator!=(const TQueuedOperation& aOp); + inline TMsvId FolderId() const; + inline TInt OperationIndex() const; + inline CImOffLineOperation& Operation() ; + IMPORT_C void CopyL(const TQueuedOperation& aOperation); + private: + TQueuedOperation(TMsvId aFolderId,TInt aOperationIndex); + private: + TMsvId iFolderId; + TInt iOperationIndex; + CImOffLineOperation iStoredOperation; + }; + +class CImQueuedList : public CBase, public MImOffLineOperationArray +/** +@internalComponent +@released +*/ + { + public: + IMPORT_C static CImQueuedList* NewL(); + IMPORT_C virtual ~CImQueuedList() ; + IMPORT_C void SetFolder(TMsvId aFolderId); + IMPORT_C void ResetLineCounter(); + IMPORT_C TQueuedOperation& operator[](TInt anIndex); + IMPORT_C void Delete(TInt aIndex); + IMPORT_C void Reset(); + IMPORT_C void AppendL(TQueuedOperation& aOperation); + public: // From MOffLineOperationArrayStore + IMPORT_C virtual TInt CountOperations() const; + IMPORT_C virtual const CImOffLineOperation& Operation(TInt aIndex) const; + IMPORT_C virtual void AppendOperationL(const CImOffLineOperation& aOperation); + private: + CImQueuedList() ; + private: + TMsvId iFolderId; + TInt iLine; + CArrayFixFlat *iArray; + }; + +class MImUndoOffLineOperation +/** +@internalTechnology +@released +*/ + { + public: + virtual void UndoOffLineChangesL(const CImOffLineOperation& aDeleted, TMsvId aFolderId) = 0; + }; + +class CImOperationQueueList : public CBase +/** +@internalComponent +@released +*/ + { + public: + IMPORT_C static CImOperationQueueList* NewL(CMsvEntry& aServiceEntry, MImUndoOffLineOperation *aImUndoOffLineOperation); + // Create new list of queued operations for service entry aServiceEntry is set to. + IMPORT_C ~CImOperationQueueList(); + inline const TInt Count() const; + // Current number of queued operations in list + inline TQueuedOperation& operator[](TInt anIndex); + // Access to array of queued operations. + IMPORT_C void DeleteL(TInt aLine); + // Remove operation from list of queued operations locally. + IMPORT_C void ExpungeDeletedOperationsL(); + // Enforce removal of queued operations from the stores of the folders. + protected: + void ConstructL(); + CImOperationQueueList(CMsvEntry& aServiceEntry,MImUndoOffLineOperation *aImUndoOffLineOperation); + void RestoreQueuedListL(CImQueuedList &/*aList*/); + void StoreQueuedListL(CImQueuedList &/*aList*/); + void ProcessFoldersL(); + private: + CImQueuedList *iQueuedList; + CImQueuedList *iDeletedList; + CMsvEntry* iServiceEntry; + TMsvId iServiceId; + MImUndoOffLineOperation *iUndoOffline; + }; + +#include + +#endif