/*
* Copyright (c) 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:  ?Description
*
*/


#include "mderelation.h"

#include "mdcitem.h"
#include "mdcserializationbuffer.h"
#include "mderelationdef.h"
#include "mdenamespacedef.h"


//----------------------------------------------------------
//               TMdERelation
//----------------------------------------------------------

TMdERelation::TMdERelation()
	: iId( KNoId ), iLeftObjectId( KNoId ),
	  iRightObjectId( KNoId ), iDef( NULL )
	{
	}

EXPORT_C TItemId TMdERelation::Id() const
	{
	return iId;
	}

EXPORT_C CMdERelationDef& TMdERelation::DefL() const
	{
	if ( !iDef )
		{
		User::Leave( KErrNotFound );
		}
	return *iDef;
	}

EXPORT_C TItemId TMdERelation::LeftObjectId() const
	{
	return iLeftObjectId;
	}

EXPORT_C TItemId TMdERelation::RightObjectId() const
	{
	return iRightObjectId;
	}

TUint32 TMdERelation::RequiredBufferSize() const
	{
	return sizeof(TMdCRelation);
	}

void TMdERelation::DeSerializeL(CMdCSerializationBuffer& aBuffer, CMdENamespaceDef& aNamespaceDef)
	{
	const TMdCRelation& relation = TMdCRelation::GetFromBufferL( aBuffer );
	iId = relation.iId;
	iLeftObjectId = relation.iLeftObjectId;
	iRightObjectId = relation.iRightObjectId;
	if (iId == KNoId || iLeftObjectId == KNoId || iRightObjectId == KNoId)
		{
		User::Leave(KErrNotFound);
		}
	if(iLeftObjectId == iRightObjectId )
		{
		User::Leave( KErrArgument );
		}
	iDef = aNamespaceDef.GetRelationDefL( relation.iDefId );
	}

//----------------------------------------------------------
//               CMdERelation
//----------------------------------------------------------

CMdERelation::CMdERelation(CMdESession* aSession, TItemId aId, 
						   CMdERelationDef& aDef, TItemId aLeftObjectId, 
						   TItemId aRightObjectId, TInt32 aParameter)
		: CMdEInstanceItem(aSession, aId), iDef(aDef),
		  iLeftObjectId(aLeftObjectId), iRightObjectId(aRightObjectId), 
		  iParameter(aParameter), iGuidHigh( 0 ), iGuidLow( 0 ), iLastModifiedDate( 0 )
	{
	}


void CMdERelation::ConstructL()
	{
	// Same object cannot be on both side of the relation
	if(iLeftObjectId == iRightObjectId )
		{
		User::Leave( KErrArgument );
		}

	InstanceItemBaseConstruct();
	}


CMdERelation::~CMdERelation()
	{
	}

CMdERelation* CMdERelation::NewL(CMdERelationDef& aDef, TItemId aLeftObjectId, 
		 TItemId aRightObjectId, TInt32 aParameter)
	{
	CMdERelation* ret = CMdERelation::NewLC( aDef, aLeftObjectId, aRightObjectId, aParameter );
	CleanupStack::Pop( ret );
	return ret;
	}

CMdERelation* CMdERelation::NewLC(CMdERelationDef& aDef, TItemId aLeftObjectId, 
		 TItemId aRightObjectId, TInt32 aParameter)
	{
	CMdERelation* ret = new (ELeave) CMdERelation( NULL, KNoId, aDef, aLeftObjectId, aRightObjectId, aParameter );
	CleanupStack::PushL( ret );
	ret->ConstructL();
	return ret;
	}

CMdERelation* CMdERelation::NewL(CMdESession* aSession, CMdCSerializationBuffer& aBuffer, CMdENamespaceDef& aNamespaceDef)
	{
	CMdERelation* ret = CMdERelation::NewLC( aSession, aBuffer, aNamespaceDef );
	CleanupStack::Pop( ret );
	return ret;
	}

CMdERelation* CMdERelation::NewLC(CMdESession* aSession, CMdCSerializationBuffer& aBuffer, CMdENamespaceDef& aNamespaceDef)
	{
	const TMdCRelation& serializedRelation = TMdCRelation::GetFromBufferL( aBuffer );
	if (serializedRelation.iId == KNoId)
		{
		User::Leave( KErrNotFound );
		}
	if (serializedRelation.iDefId == KNoDefId)
		{
		User::Leave( KErrNotFound );
		}
	CMdERelationDef* relationDef = aNamespaceDef.GetRelationDefL( serializedRelation.iDefId );
	if ( !relationDef )
		{
		User::Leave( KErrNotFound );
		}
	if (serializedRelation.iLeftObjectId == KNoId)
		{
		User::Leave( KErrNotFound );
		}
	if (serializedRelation.iRightObjectId == KNoId)
		{
		User::Leave( KErrNotFound );
		}

	CMdERelation* relation = new (ELeave) CMdERelation( aSession, serializedRelation.iId, *relationDef,
			serializedRelation.iLeftObjectId, serializedRelation.iRightObjectId, serializedRelation.iParameter );
	CleanupStack::PushL( relation );

	relation->SetGuid( serializedRelation.iGuidHigh, serializedRelation.iGuidLow );

	relation->SetLastModifiedDate( serializedRelation.iLastModifiedDate );

	return relation;
	}

EXPORT_C CMdERelationDef& CMdERelation::Def() const
	{
	return iDef;
	}


EXPORT_C TItemId CMdERelation::LeftObjectId() const
	{
	return iLeftObjectId;
	}


EXPORT_C TItemId CMdERelation::RightObjectId() const
	{
	return iRightObjectId;
	}
	
EXPORT_C TInt32 CMdERelation::Parameter() const
	{
	return iParameter;
	}

EXPORT_C void CMdERelation::SetParameter(TInt32 aParameter)
	{
	iParameter = aParameter;
	}
	
EXPORT_C void CMdERelation::SetLeftObjectIdL( TItemId aLeftObjectId )
	{
	// Same object cannot be on both side of the relation
	if( aLeftObjectId == iRightObjectId )
		{
		User::Leave( KErrArgument );
		}

	iLeftObjectId = aLeftObjectId;
	}

EXPORT_C void CMdERelation::SetRightObjectIdL( TItemId aRightObjectId )
	{
	// Same object cannot be on both side of the relation
	if( aRightObjectId == iLeftObjectId )
		{
		User::Leave( KErrArgument );
		}

	iRightObjectId = aRightObjectId;
	}

EXPORT_C void CMdERelation::Guid(TInt64& aGuidHigh, TInt64& aGuidLow) const
	{
	aGuidHigh = iGuidHigh;
	aGuidLow = iGuidLow;
	}

EXPORT_C void CMdERelation::SetGuid(const TInt64& aGuidHigh, const TInt64& aGuidLow)
	{
	iGuidHigh = aGuidHigh;
	iGuidLow = aGuidLow;
	}

EXPORT_C TTime CMdERelation::LastModifiedDate() const
	{
	return iLastModifiedDate;
	}

EXPORT_C void CMdERelation::SetLastModifiedDate(TTime aLastModifiedDate)
	{
	iLastModifiedDate = aLastModifiedDate;
	}

TUint32 CMdERelation::RequiredBufferSize() const
	{
	return sizeof(TMdCRelation);
	}

TMdCOffset CMdERelation::SerializeL(CMdCSerializationBuffer& aBuffer, TMdCOffset aFreespaceOffset) const
	{
	TMdCRelation relation;
	relation.iId = Id();
	relation.iDefId = iDef.Id();
	relation.iLeftObjectId = iLeftObjectId;
	relation.iRightObjectId = iRightObjectId;
	relation.iParameter = iParameter;
	relation.iGuidHigh = iGuidHigh;
	relation.iGuidLow = iGuidLow;
	relation.iLastModifiedDate = iLastModifiedDate;
	
	relation.SerializeL( aBuffer );
	return aFreespaceOffset;
	}

TMdEInstanceType CMdERelation::InstanceType() const
	{
	return EMdETypeRelation;
	}