// 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 
 @internalTechnology
*/

#include <ecom/ecom.h>
#include <elements/metadata.h>
#include <elements/metatype.h>
#include <elements/metaiterator.h>


#ifdef _DEBUG
// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module
// (if it could happen through user error then you should give it an explicit, documented, category + code)
_LIT(KSpecAssert_ElemNetMetaMtDt, "ElemNetMetaMtDt.");
#endif

// Maximum size of the MMetaType based object in terms of sizeof(TAny*).
// KMMetaTypeMaxSize * sizeof(TAny*) is the size of the memory reserved
// on the stack for the in-place instantiation.
const TInt KMMetaTypeMaxSize = 10;


using namespace Meta;

#ifdef SYMBIAN_NETWORKING_CFTRANSPORT
EXPORT_C STypeId STypeId::CreateSTypeId(TPtrC8& aDes)
	{
	// check no padding, so no alignment worries in copying single block
	STypeId id;
	__ASSERT_COMPILE(sizeof(STypeId) == sizeof(id.iUid) + sizeof(id.iType));

	Mem::Copy(&id, aDes.Ptr(), sizeof(STypeId));
	
	// trim typeid from front of store
	aDes.Set(aDes.Ptr() + sizeof(STypeId), aDes.Length() - sizeof(STypeId));
	return id;
	}
#endif

EXPORT_C TInt STypeId::Check( TPtrC8& aDes ) const
	{
	if (aDes.Length() < (TInt)sizeof(STypeId))
		{
		return KErrArgument;
		}
	STypeId typeId;
	Mem::Copy(&typeId, aDes.Ptr(), sizeof(STypeId));
	TInt error = KErrArgument;
	if ( *this == typeId )
		{//update pointer (type) only if the type matches
		aDes.Set(aDes.Ptr()+sizeof(STypeId),aDes.Length()-sizeof(STypeId));
		error = KErrNone;
		}
	return  error;
	}

EXPORT_C SMetaData::SMetaData()
/**
 * Protected and explicit constructor
 */
    {
    }

EXPORT_C SMetaData::~SMetaData()
/**
 * Virtual destructor
 */
	{
	}

EXPORT_C TInt SMetaData::CheckTypeOf( TPtrC8& aDes ) const
	{
	if (aDes.Length() < (TInt)sizeof(STypeId))
		{
		return KErrArgument;
		}
	STypeId typeId;
	Mem::Copy(&typeId, aDes.Ptr(), sizeof(STypeId));
	TInt error = KErrArgument;
	if ( IsTypeOf(typeId) )
		{//update pointer (type) only if the type matches
		aDes.Set(aDes.Ptr()+sizeof(STypeId),aDes.Length()-sizeof(STypeId));
		error = KErrNone;
		}
	return  error;
	}

EXPORT_C STypeId SMetaData::GetTypeId() const
	{
	const SVDataTableEntry* entry = GetVDataTable();
	__ASSERT_DEBUG( entry , User::Panic(KSpecAssert_ElemNetMetaMtDt, 1));
	return STypeId::CreateSTypeId( entry->iOffset, reinterpret_cast<TInt32>(entry->iMetaNewL) );
	}

EXPORT_C TInt SMetaData::IsTypeOf( const STypeId& aTypeId ) const
	{
	const SVDataTableEntry* entry = GetVDataTable();
	__ASSERT_DEBUG( entry , User::Panic(KSpecAssert_ElemNetMetaMtDt, 2));
	for(;;)
		{
		STypeId typeId = { entry->iOffset, reinterpret_cast<TInt32>(entry->iMetaNewL) };
		if ( typeId == aTypeId )
			{
			return 1;
			}
		//move through the table
		while ( (++entry)->iMetaNewL ) {;}
		if ( !entry->iOffset )
			{
			break;
			}
		typedef SVDataTableEntry* (*TMetaBaseTableNewL)();
		entry = reinterpret_cast<TMetaBaseTableNewL>(entry->iOffset)();
		}
	return 0;
	}

EXPORT_C void SMetaData::Copy(const SMetaData& aSource)
/**
 * Copies values of a SMetaData object's properties into properties of *this.
 * Both meta objects are of the same type.
 */
    {
    __ASSERT_DEBUG(GetTypeId()==aSource.GetTypeId(),User::Panic(_L("SMetaData"),KErrArgument));

    TAny* mem[KMMetaTypeMaxSize];
    TMetaVTableIterator attribIter(this);
    SVDataTableEntry const* entry;
    while ((entry = attribIter++) != NULL)
        {
        MMetaType* metaType = entry->iMetaNewL(mem,GetAttribPtr(entry->iOffset));
        metaType->Copy(aSource.GetAttribPtr(entry->iOffset));
        }
    }

EXPORT_C TInt SMetaData::Store(TDes8& aDes) const
/**
 * Stores the meta object into a descriptor
 */
    {
	const STypeId& typeId = GetTypeId();
	TInt len = Length();

	if ((aDes.MaxLength()-aDes.Length()) < len)
		{
		return KErrOverflow;
		}

	aDes.Append((TUint8*)&typeId,sizeof(STypeId)); //store TID
	aDes.Append((TUint8*)&len,sizeof(TInt32)); //store length

    TAny* mem[KMMetaTypeMaxSize];
    TMetaVTableIterator attribIter(this);
    SVDataTableEntry const* entry;
    while ((entry = attribIter++) != NULL)
        {
        MMetaType* metaType = entry->iMetaNewL(mem,GetAttribPtr(entry->iOffset));
		TInt ret = metaType->Store(aDes);
		if (ret != KErrNone)
			{
			return ret;
			}
        }
	return KErrNone;
    }

EXPORT_C TInt SMetaData::Check(TPtrC8& aDes) const
	{
	return GetTypeId().Check(aDes);
	}

EXPORT_C TInt SMetaData::Load(TPtrC8& aDes)
/**
 * Loads the meta object from a descriptor
 */
    {
	if (aDes.Length() < (TInt)sizeof(TInt32))
		{
		return KErrArgument;
		}

	TUint32 length;
	Mem::Copy(&length, aDes.Ptr(), sizeof(TUint32));
	aDes.Set(aDes.Ptr()+sizeof(TUint32),aDes.Length()-sizeof(TUint32)); //update pointer (type)

	if (length > aDes.Length() + sizeof(TUint32) + sizeof(STypeId))
		{
		return KErrArgument;
		}

    TAny* mem[KMMetaTypeMaxSize];
    TMetaVTableIterator attribIter(this);
    SVDataTableEntry const* entry;
    while ((entry = attribIter++) != NULL)
        {
		//xxx This isn't a leaving function! It should be New not NewL
        MMetaType* metaType = entry->iMetaNewL(mem,GetAttribPtr(entry->iOffset));
        TInt ret = metaType->Load(aDes);
		if (ret != KErrNone)
			{
			return ret;
			}
        }
	return KErrNone;
    }

EXPORT_C TInt SMetaData::Length() const
/**
 * Returns length of the object excluding TID and stored length fields
 */
	{
	TInt length = sizeof(STypeId) + sizeof(TInt32);
    TAny* mem[KMMetaTypeMaxSize];
    TMetaVTableIterator attribIter(this);
    SVDataTableEntry const* entry;
    while ((entry = attribIter++) != NULL)
        {
        MMetaType* metaType = entry->iMetaNewL(mem,GetAttribPtr(entry->iOffset));
        length += metaType->Length();
        }
	return length;
	}

using Meta::SMetaDataECom;

EXPORT_C SMetaDataECom::SMetaDataECom()
/**
 * Protected and explicit constructor
 */
	{
	iDestroyUid.iUid = 0;
	}

EXPORT_C SMetaDataECom::~SMetaDataECom()
/**
 * Destructor
 */
	{
	if ( iDestroyUid.iUid )
      {
      REComSession::DestroyedImplementation(iDestroyUid);
      }
   }

EXPORT_C SMetaDataECom* SMetaDataECom::LoadL(TPtrC8& aDes)
/**
 * Static, encapsulates instantiation and loading of a content of a meta object
 * from data contained in a descriptor.
 * This function must be provided by all meta objects that will be used as a parameter
 * to TMetaPtr<> template.
 */
	{
	if (aDes.Length() < (3 * (TInt) sizeof(TInt32)))
		{
		// Fatal error, descriptor is corrupt
		User::Leave(KErrArgument);
		}

	// Extract UID and type
#ifdef SYMBIAN_NETWORKING_CFTRANSPORT
	STypeId typeId = STypeId::CreateSTypeId(aDes);
#else
	STypeId typeId;
	Mem::Copy(&typeId.iUid, aDes.Ptr(), sizeof(TUid));
	aDes.Set(aDes.Ptr()+sizeof(TUint32),aDes.Length()-sizeof(TUint32)); //update pointer (uid)
	Mem::Copy(&typeId.iType, aDes.Ptr(), sizeof(TInt32));
	aDes.Set(aDes.Ptr()+sizeof(TUint32),aDes.Length()-sizeof(TUint32)); //update pointer (type)
#endif

	// Attempt to load the object
	SMetaDataECom* mtd = NULL;
	TRAPD(ret, mtd = NewInstanceL(typeId));

	if (ret != KErrNone)
		{
		if (ret == KErrNotFound)
			{
			// Attempt to move the pointer on
			TUint32 len;
			Mem::Copy(&len, aDes.Ptr(), sizeof(TUint32));
			if (len <= (TUint32) aDes.Length())
				{
				aDes.Set(aDes.Ptr()+len,aDes.Length()-len); //update pointer (type)
				}
			else
				{
				aDes.Set(aDes.Right(0));
				}
			}
		User::Leave(ret);
		}

	CleanupDeletePushL(mtd);

	// Ask the object to de-marshall its data
	ret = mtd->Load(aDes);
	if (ret != KErrNone)
		{
		User::Leave(ret);
		}
	CleanupStack::Pop(mtd);
    return mtd;
	}

EXPORT_C SMetaDataECom* SMetaDataECom::NewInstanceL(const STypeId& aTypeId)
/**
 * Static, instantiates a meta object based on its Type ID.
 */
    {
	TUid destroyUid;
	SMetaDataECom* obj = reinterpret_cast<SMetaDataECom*>(REComSession::CreateImplementationL(aTypeId.iUid, destroyUid, (TAny*)aTypeId.iType));
	obj->iDestroyUid = destroyUid;
	return obj;
	}