/**

* Copyright (c) 2004-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

*/

#if (!defined METADATA_H)

#define METADATA_H

#include <e32base.h>

#include <e32std.h>

#include <elements/cftransportmacro.h>

#include <elements/h_tdeallocator.h>

/**

Macro used to declare virtual functions from MMetaData interface and the virtual data table

*/

#define TYPEID_TABLE \

 /** @internalComponent */ \

 static inline const Meta::STypeId TypeId() { const Meta::SVDataTableEntry* entry = GetVDataTableStatic(); return Meta::STypeId::CreateSTypeId(entry->iOffset,reinterpret_cast<TInt32>(entry->iMetaNewL)); } \

 /** @internalComponent */ \

 static const Meta::SVDataTableEntry* GetVDataTableStatic(); \

 /** @internalComponent */ \

 static const Meta::SVDataTableEntry iVDataTable[];

#define EXPORT_TYPEID_TABLE \

 /** @internalComponent */ \

 static inline const Meta::STypeId TypeId() { const Meta::SVDataTableEntry* entry = GetVDataTableStatic(); return Meta::STypeId::CreateSTypeId(entry->iOffset,reinterpret_cast<TInt32>(entry->iMetaNewL)); } \

 /** @internalComponent */ \

 IMPORT_C static const Meta::SVDataTableEntry* GetVDataTableStatic(); \

 /** @internalComponent */ \

 static const Meta::SVDataTableEntry iVDataTable[];

#define DATA_VTABLE \

 /** @internalComponent */ \

 static inline const Meta::STypeId TypeId() { const Meta::SVDataTableEntry* entry = GetVDataTableStatic(); return Meta::STypeId::CreateSTypeId(entry->iOffset,reinterpret_cast<TInt32>(entry->iMetaNewL)); } \

 /** @internalComponent */ \

 virtual Meta::SVDataTableEntry const* GetVDataTable() const;	\

 /** @internalComponent */ \

 virtual TUint8* GetAttribPtr(const TInt aOffset) const;	\

 /** @internalComponent */ \

 static const Meta::SVDataTableEntry* GetVDataTableStatic(); \

 /** @internalComponent */ \

 static const Meta::SVDataTableEntry iVDataTable[];

#define EXPORT_DATA_VTABLE \

 /** @internalComponent */ \

 static inline const Meta::STypeId TypeId() { const Meta::SVDataTableEntry* entry = GetVDataTableStatic(); return Meta::STypeId::CreateSTypeId(entry->iOffset,reinterpret_cast<TInt32>(entry->iMetaNewL)); } \

 /** @internalComponent */ \

 virtual Meta::SVDataTableEntry const* GetVDataTable() const;	\

 /** @internalComponent */ \

 virtual TUint8* GetAttribPtr(const TInt aOffset) const;	\

 /** @internalComponent */ \

 IMPORT_C static const Meta::SVDataTableEntry* GetVDataTableStatic(); \

 /** @internalComponent */ \

 static const Meta::SVDataTableEntry iVDataTable[];

#define EXPORT_DATA_VTABLE_AND_FN \

 /** @internalComponent */ \

 static inline const Meta::STypeId TypeId() { const Meta::SVDataTableEntry* entry = GetVDataTableStatic(); return Meta::STypeId::CreateSTypeId(entry->iOffset,reinterpret_cast<TInt32>(entry->iMetaNewL)); } \

 /** @internalComponent */ \

 IMPORT_C virtual Meta::SVDataTableEntry const* GetVDataTable() const;	\

 /** @internalComponent */ \

 IMPORT_C virtual TUint8* GetAttribPtr(const TInt aOffset) const;	\

 /** @internalComponent */ \

 IMPORT_C static const Meta::SVDataTableEntry* GetVDataTableStatic(); \

 /** @internalComponent */ \

 static const Meta::SVDataTableEntry iVDataTable[];

/**

Macros used to implement virtual functions from MMetaData interface and construct the v data table

*/

#define START_ATTRIBUTE_TABLE( thisMetaClass, uid, typeId ) \

 /** @internalComponent */ \

 Meta::SVDataTableEntry const* thisMetaClass::GetVDataTable() const { return &iVDataTable[0]; };	\

 /** @internalComponent */ \

 TUint8* thisMetaClass::GetAttribPtr(const TInt aOffset) const { return (TUint8*)this + aOffset; };	\

 /** @internalComponent */ \

 const Meta::SVDataTableEntry* thisMetaClass::GetVDataTableStatic() { return &iVDataTable[0]; }; \

 /** @internalComponent */ \

 const Meta::SVDataTableEntry thisMetaClass::iVDataTable[] = { \

 { uid, reinterpret_cast<Meta::TMetaTypeNewL>(typeId) },

#define EXPORT_START_ATTRIBUTE_TABLE( thisMetaClass, uid, typeId ) \

 /** @internalComponent */ \

 Meta::SVDataTableEntry const* thisMetaClass::GetVDataTable() const { return &iVDataTable[0]; };	\

 /** @internalComponent */ \

 TUint8* thisMetaClass::GetAttribPtr(const TInt aOffset) const { return (TUint8*)this + aOffset; };	\

 /** @internalComponent */ \

 EXPORT_C const Meta::SVDataTableEntry* thisMetaClass::GetVDataTableStatic() { return &iVDataTable[0]; }; \

 /** @internalComponent */ \

 const Meta::SVDataTableEntry thisMetaClass::iVDataTable[] = { \

 { uid, reinterpret_cast<Meta::TMetaTypeNewL>(typeId) },

#define EXPORT_START_ATTRIBUTE_TABLE_AND_FN( thisMetaClass, uid, typeId ) \

 /** @internalComponent */ \

 EXPORT_C Meta::SVDataTableEntry const* thisMetaClass::GetVDataTable() const { return &iVDataTable[0]; };	\

 /** @internalComponent */ \

 EXPORT_C TUint8* thisMetaClass::GetAttribPtr(const TInt aOffset) const { return (TUint8*)this + aOffset; };	\

 /** @internalComponent */ \

 EXPORT_C const Meta::SVDataTableEntry* thisMetaClass::GetVDataTableStatic() { return &iVDataTable[0]; }; \

 /** @internalComponent */ \

 const Meta::SVDataTableEntry thisMetaClass::iVDataTable[] = { \

 { uid, reinterpret_cast<Meta::TMetaTypeNewL>(typeId) },

#define REGISTER_ATTRIBUTE( thisMetaClass, var, metaType ) \

 { _FOFF( thisMetaClass, var ), Meta::metaType::NewL },

#define END_ATTRIBUTE_TABLE() \

 { 0, NULL }};

#define END_ATTRIBUTE_TABLE_BASE( baseMetaClass, baseId ) \

 { (TInt)((TAny*)(baseMetaClass::GetVDataTableStatic)), NULL }};

#define REGISTER_TYPEID( thisMetaClass, uid, typeId ) \

 /** @internalComponent */ \

 const Meta::SVDataTableEntry* thisMetaClass::GetVDataTableStatic() { return &iVDataTable[0]; }; \

 /** @internalComponent */ \

 const Meta::SVDataTableEntry thisMetaClass::iVDataTable[] = { \

 { uid, reinterpret_cast<Meta::TMetaTypeNewL>(typeId) }, \

 { 0, NULL }};

#define EXPORT_REGISTER_TYPEID( thisMetaClass, uid, typeId ) \

 /** @internalComponent */ \

 EXPORT_C const Meta::SVDataTableEntry* thisMetaClass::GetVDataTableStatic() { return &iVDataTable[0]; }; \

 /** @internalComponent */ \

 const Meta::SVDataTableEntry thisMetaClass::iVDataTable[] = { \

 { uid, reinterpret_cast<Meta::TMetaTypeNewL>(typeId) }, \

 { 0, NULL }};

#define EXPORT_START_ATTRIBUTE_TABLE_NO_FN( thisMetaClass, uid, typeId ) \

 /** @internalComponent */ \

 EXPORT_C const Meta::SVDataTableEntry* thisMetaClass::GetVDataTableStatic() { return &iVDataTable[0]; }; \

 /** @internalComponent */ \

 const Meta::SVDataTableEntry thisMetaClass::iVDataTable[] = { \

 { uid, reinterpret_cast<Meta::TMetaTypeNewL>(typeId) },

namespace Meta

{

//Panics

_LIT (MetaPanic,"MetaDataPanic");

const TInt EBadCast = 1;

struct SMetaData;

typedef Elements::TDeAllocator<const SMetaData> TMetaDataDeAllocator;

class MMetaType;

typedef MMetaType* (*TMetaTypeNewL)(const TAny*, const TAny*);

struct SVDataTableEntry

/**

Single entry of a virtual data table

@publishedPartner

@released since v9.0 */

    {

    TInt iOffset;

    TMetaTypeNewL iMetaNewL;

    };

const TInt32 KNetMetaTypeAny = 0;

struct STypeId

/**

Used to uniquely identify the type of a (meta).object.

*/

	{

	TUid iUid;

	TInt32 iType;

	inline TBool operator==(const STypeId& obj) const { return iUid==obj.iUid && iType==obj.iType; };

	inline TBool operator!=(const STypeId& obj) const { return iUid!=obj.iUid || iType!=obj.iType; };

	static inline STypeId CreateSTypeId();

	static inline STypeId CreateSTypeId(TUint32 aUid, TUint32 aTypeId);

	IMPORT_C static STypeId CreateSTypeId(TPtrC8& aStore);

	IMPORT_C TInt Check( TPtrC8& aDes ) const;

	};

class MMetaData

/**

MetaData interface

@publishedPartner

@released since v9.0 */

	{

public:

	virtual SVDataTableEntry const* GetVDataTable() const = 0;

	virtual TUint8* GetAttribPtr(const TInt aOffset) const = 0;

	};

struct SMetaData : public MMetaData

/**

Meta object's base type

Partially implements the MMetaData interface's pure virtual functions

*/

   {

public:

	IMPORT_C virtual ~SMetaData();

	//Checks the exact type for match and advances the pointer if matched

	IMPORT_C TInt Check( TPtrC8& aDes ) const;

	//Checks the exact type and base types for match and advances the pointer if matched

	IMPORT_C TInt CheckTypeOf( TPtrC8& aDes ) const;

	IMPORT_C STypeId GetTypeId() const;

	IMPORT_C TInt IsTypeOf( const STypeId& aTypeId ) const;

	IMPORT_C void Copy(const SMetaData& aSource);

	IMPORT_C TInt Store(TDes8& aDes) const;

	IMPORT_C TInt Load(TPtrC8& aDes);

	IMPORT_C TInt Length() const;

protected:

	IMPORT_C explicit SMetaData();

   };

struct SMetaDataECom : public SMetaData

/**

Meta object based on ECom factory base type

Implements static LoadL(TPtrC8& aDes) required by templated

*/

	{

public:

	IMPORT_C static SMetaDataECom* LoadL(TPtrC8& aDes);

    IMPORT_C static SMetaDataECom* NewInstanceL(const STypeId& aTypeId);

	IMPORT_C virtual ~SMetaDataECom();

protected:

    IMPORT_C explicit SMetaDataECom();

private:

	TUid iDestroyUid;

	};

} //namespace Meta

template <class SMETADATATYPE>

SMETADATATYPE& smetadata_cast(Meta::SMetaData& aObject)

    {

    __ASSERT_DEBUG(aObject.IsTypeOf(Meta::STypeId::CreateSTypeId(SMETADATATYPE::EUid, SMETADATATYPE::ETypeId)),User::Panic(Meta::MetaPanic, Meta::EBadCast));

    return static_cast<SMETADATATYPE&>(aObject);

    }

template <class SMETADATATYPE>

const SMETADATATYPE& smetadata_cast(const Meta::SMetaData& aObject)

    {

    __ASSERT_DEBUG(aObject.IsTypeOf(Meta::STypeId::CreateSTypeId(SMETADATATYPE::EUid, SMETADATATYPE::ETypeId)),User::Panic(Meta::MetaPanic, Meta::EBadCast));

    return static_cast<const SMETADATATYPE&>(aObject);

    }

template <class SMETADATATYPE>

SMETADATATYPE* smetadata_cast(Meta::SMetaData* aObject)

    {

    __ASSERT_DEBUG(aObject,User::Panic(Meta::MetaPanic, Meta::EBadCast));

    return aObject->IsTypeOf(Meta::STypeId::CreateSTypeId(SMETADATATYPE::EUid, SMETADATATYPE::ETypeId)) ? static_cast<SMETADATATYPE*>(aObject) : NULL;

    }

template <class SMETADATATYPE>

const SMETADATATYPE* smetadata_cast(const Meta::SMetaData* aObject)

    {

    __ASSERT_DEBUG(aObject,User::Panic(Meta::MetaPanic, Meta::EBadCast));

    return aObject->IsTypeOf(Meta::STypeId::CreateSTypeId(SMETADATATYPE::EUid, SMETADATATYPE::ETypeId)) ? static_cast<const SMETADATATYPE*>(aObject) : NULL;

    }

#include <elements/metadata.inl>

#endif //METADATA_H