// Copyright (c) 2006-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:
//
/**
@file
@publishedPartner
@released
*/
#ifndef CMTPTYPECOMPOUNDBASE_H
#define CMTPTYPECOMPOUNDBASE_H
#include <e32std.h>
#include <e32base.h>
#include <mtp/mmtptype.h>
#include <mtp/mtpdatatypeconstants.h>
#include <mtp/tmtptypeflatbase.h>
/**
Defines the MTP compound data types base class. Compound data types are used
to represent MTP datasets comprising mixed sequences of simple, flat, and
complex data type elements. These elements may be either of fixed or variable
length. This class implements generic compound data type storage management
capabilities and is intended for derivation by concrete classes which implement
specific MTP datasets. Note that this class does NOT assume ownership of any
of the data elements passed to it.
@publishedPartner
@released
*/
class CMTPTypeCompoundBase : public CBase, public MMTPType
{
public:
IMPORT_C virtual ~CMTPTypeCompoundBase();
IMPORT_C virtual void GetL(TInt aElementId, MMTPType& aElement) const;
IMPORT_C virtual void SetL(TInt aElementId, const MMTPType& aElement);
IMPORT_C virtual void SetInt8L(TInt aElementId, TInt8 aData);
IMPORT_C virtual void SetInt16L(TInt aElementId, TInt16 aData);
IMPORT_C virtual void SetInt32L(TInt aElementId, TInt32 aData);
IMPORT_C virtual void SetInt64L(TInt aElementId, TInt64 aData);
IMPORT_C virtual void SetUint8L(TInt aElementId, TUint8 aData);
IMPORT_C virtual void SetUint16L(TInt aElementId, TUint16 aData);
IMPORT_C virtual void SetUint32L(TInt aElementId, TUint32 aData);
IMPORT_C virtual void SetUint64L(TInt aElementId, TUint64 aData);
IMPORT_C virtual void SetStringL(TInt aElementId, const TDesC& aString);
IMPORT_C virtual TInt8 Int8L(TInt aElementId) const;
IMPORT_C virtual TInt16 Int16L(TInt aElementId) const;
IMPORT_C virtual TInt32 Int32L(TInt aElementId) const;
IMPORT_C virtual TInt64 Int64L(TInt aElementId) const;
IMPORT_C virtual TUint8 Uint8L(TInt aElementId) const;
IMPORT_C virtual TUint16 Uint16L(TInt aElementId) const;
IMPORT_C virtual TUint32 Uint32L(TInt aElementId) const;
IMPORT_C virtual TUint64 Uint64L(TInt aElementId) const;
IMPORT_C virtual TUint8 StringNumCharsL(TInt aElementId) const;
IMPORT_C virtual const TDesC& StringCharsL(TInt aElementId) const;
public: // From MMTPType
IMPORT_C virtual TInt FirstReadChunk(TPtrC8& aChunk) const;
IMPORT_C virtual TInt NextReadChunk(TPtrC8& aChunk) const;
IMPORT_C virtual TInt FirstWriteChunk(TPtr8& aChunk);
IMPORT_C virtual TInt NextWriteChunk(TPtr8& aChunk);
IMPORT_C virtual TInt NextWriteChunk(TPtr8& aChunk, TUint aDataLength);
IMPORT_C virtual TUint64 Size() const;
IMPORT_C virtual TUint Type() const;
IMPORT_C virtual TBool CommitRequired() const;
IMPORT_C virtual MMTPType* CommitChunkL(TPtr8& aChunk);
IMPORT_C virtual TInt Validate() const;
public:
/**
Defines the MTP compound data type element meta data.
*/
struct TElementInfo
{
/**
The element's chunk identifier (sequence number).
*/
TInt iChunkId;
/**
The element's MTP type identifier.
*/
TInt iType;
/**
RMTPTypeCompoundFlatChunk element specific meta data.
*/
TMTPTypeFlatBase::TElementInfo iFlatChunkInfo;
};
/**
Initialisation value for TElementInfo data values that are non applicable
for an element, e.g. when specifying iFlatChunkInfo values for non-flat
elements such as arrays and strings.
*/
static const TInt KMTPNotApplicable = -1;
protected:
/**
Defines the MTP compound data type flat data chunk class.
@publishedPartner
@released
*/
class RMTPTypeCompoundFlatChunk : public TMTPTypeFlatBase
{
public:
IMPORT_C RMTPTypeCompoundFlatChunk(TUint aSize, CMTPTypeCompoundBase& aParent);
IMPORT_C void Close();
IMPORT_C void OpenL();
public: // From MMTPType
IMPORT_C TUint Type() const;
private: // From TMTPTypeFlatBase
const TElementInfo& ElementInfo(TInt aElementId) const;
private: // Owned.
/**
The data buffer.
*/
RBuf8 iBuffer;
/**
The flat data chunk size.
*/
TUint iSize;
private: // Not owned.
/**
The parent compound data type instance of which this flat chunk is an
element.
*/
CMTPTypeCompoundBase* iParent;
};
protected:
/**
This flag is used by derived classes to signal the use of just-in-time
techniques during construction from a write data stream.
@see CMTPTypeCompoundBase
*/
static const TBool KJustInTimeConstruction = ETrue;
/**
This flag is used by the derived class to indicate that the number of
chunks making up the compound type is variable rather than fixed (e.g. a
list of elements.)
*/
static const TUint KVariableChunkCount = 0;
friend class RMTPTypeCompoundFlatChunk;
IMPORT_C CMTPTypeCompoundBase(TBool aJustInTimeConstruction, TUint aExpectedChunkCount);
IMPORT_C void ChunkAppendL(const MMTPType& aElement);
IMPORT_C void ChunkRemove(TUint aChunkId);
IMPORT_C TUint ChunkCount() const;
IMPORT_C void Reset();
IMPORT_C void SetExpectedChunkCount(TUint aExpectedChunkCount);
/**
Provides the TElementInfo data for the specified element.
@param aElementId The identifier of the requested element.
@return The requested element's meta data.
*/
virtual const TElementInfo& ElementInfo(TInt aElementId) const = 0;
IMPORT_C virtual TBool ReadableElementL(TInt aElementId) const;
IMPORT_C virtual TBool WriteableElementL(TInt aElementId) const;
IMPORT_C virtual TInt ValidateChunkCount() const;
protected:
/**
Ordered data type element chunk table.
*/
RPointerArray<MMTPType> iChunks;
/**
The write data stream data chunk table index.
*/
TUint iWriteChunk;
/**
The write data stream state variable.
*/
TUint iWriteSequenceState;
/**
The read and write data stream states.
*/
enum TReadWriteSequenceState
{
/**
Data stream is inactive.
*/
EIdle,
/**
Streaming the first data chunk.
*/
EInProgressFirst,
/**
Streaming a subsequent data chunk.
*/
EInProgressNext,
};
private:
TInt UpdateReadState(TInt aErr) const;
TInt UpdateWriteState(TInt aErr);
private:
/**
This flag indicates the number of chunks which make up the compound type.
A value of KVariableChunkCount indicates that the type is of variable
rather than fixed length (e.g. a list of elements). If KVariableChunkCount
is specified then the derived class's @see ValidChunkCount method is invoked
by the default @see Valid implementation.
*/
TUint iExpectedChunkCount;
/**
This flag indicates that the compound data type uses just-in-time
techniques when constructing iteself from a write data stream. Typically
this is used for types whose final structure is dependant upon data
contained within the data stream itself, e.g. a dataset with an element
whose data type is determined by meta data which precedes the
element in the data stream.
*/
TBool iJustInTimeConstruction;
/**
The read data stream data chunk table index. Note that this is declared
mutable to allow state updates while processing a read data stream.
*/
mutable TUint iReadChunk;
/**
The read data stream state variable. Note that this is declared mutable
to allow state updates while processing a read data stream.
*/
mutable TUint iReadSequenceState;
/**
The write data stream error state.
*/
TInt iWriteErr;
};
#endif // CMTPTYPECOMPOUNDBASE_H