/*

* 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:  Representation of single event

*

*/

#include "mdeevent.h"

#include "mdcitem.h"

#include "mdcserializationbuffer.h"

#include "mdeeventdef.h"

#include "mdenamespacedef.h"

CMdEEvent* CMdEEvent::NewL(CMdEEventDef& aDef, TItemId aObjectId, TTime aTime,

			const TDesC* aSource, const TDesC* aParticipant)

	{

	CMdEEvent* self = CMdEEvent::NewLC( aDef, aObjectId, aTime, aSource, aParticipant );

	CleanupStack::Pop( self );

	return self;

	}

CMdEEvent* CMdEEvent::NewLC(CMdEEventDef& aDef, TItemId aObjectId, TTime aTime,

		const TDesC* aSource, const TDesC* aParticipant )

	{

	CMdEEvent* self = new (ELeave) CMdEEvent( NULL, KNoId, aDef, aObjectId, aTime );

	CleanupStack::PushL( self );

	self->ConstructL( aSource, aParticipant );

	return self;

	}

CMdEEvent::CMdEEvent(CMdESession* aSession, TItemId aId, CMdEEventDef& aDef, TItemId aObjectId, TTime aTime)

		: CMdEInstanceItem(aSession, aId), iDef(aDef), iObjectId(aObjectId), iTime(aTime)

	{

	}

void CMdEEvent::ConstructL(const TDesC* aSource, const TDesC* aParticipant)

	{

	InstanceItemBaseConstruct();

	if( aSource )

		{		

		iSource = aSource->AllocL();

		}

	else

		{

		iSource = NULL;

		}

	if( aParticipant )

		{		

		iParticipant = aParticipant->AllocL();

		}

	else

		{

		iParticipant = NULL;

		}

	}

CMdEEvent::~CMdEEvent()

	{

	delete iSource;

	delete iParticipant;

	}

CMdEEvent* CMdEEvent::NewL(CMdESession* aSession, CMdCSerializationBuffer& aBuffer, CMdENamespaceDef& aNamespaceDef )

	{

	CMdEEvent* ret = CMdEEvent::NewLC( aSession, aBuffer, aNamespaceDef );

	CleanupStack::Pop( ret );

	return ret;

	}

CMdEEvent* CMdEEvent::NewLC(CMdESession* aSession, CMdCSerializationBuffer& aBuffer, CMdENamespaceDef& aNamespaceDef )

	{

	const TMdCEvent& serializedEvent = TMdCEvent::GetFromBufferL( aBuffer );

	if (serializedEvent.iId == KNoId)

		{

		User::Leave( KErrNotFound );

		}

	if (serializedEvent.iDefId == KNoDefId)

		{

		User::Leave( KErrNotFound );

		}

	CMdEEventDef* eventDef = aNamespaceDef.GetEventDefL( serializedEvent.iDefId );

	if ( !eventDef )

		{

		User::Leave( KErrNotFound );

		}

	if ( serializedEvent.iObjectId == KNoId )

		{

		User::Leave( KErrNotFound );

		}

	CMdEEvent* event = new(ELeave) CMdEEvent( aSession, serializedEvent.iId, *eventDef,

			serializedEvent.iObjectId, serializedEvent.iTime );

	CleanupStack::PushL( event );

	TPtrC16 source; 

	TPtrC16 participant;

	TPtrC16* sourcePtr = NULL;

	TPtrC16* participantPtr = NULL;

	if( serializedEvent.iSourceText.iPtr.iCount > 0 )

		{

		aBuffer.PositionL( serializedEvent.iSourceText.iPtr.iOffset );

		source.Set( aBuffer.ReceivePtr16L() );

		sourcePtr = &source;

		}

	if( serializedEvent.iParticipantText.iPtr.iCount > 0 )

		{

		aBuffer.PositionL( serializedEvent.iParticipantText.iPtr.iOffset );

		participant.Set( aBuffer.ReceivePtr16L() );

		participantPtr = &participant;

		}

	event->ConstructL( sourcePtr, participantPtr );

	return event;

	}

EXPORT_C CMdEEventDef& CMdEEvent::Def() const

	{

	return iDef;

	}

EXPORT_C TItemId CMdEEvent::ObjectId() const

	{

	return iObjectId;

	}

EXPORT_C TTime CMdEEvent::Time() const

	{

	return iTime;

	}

EXPORT_C const TDesC* CMdEEvent::Source() const

	{

	return iSource;

	}

EXPORT_C const TDesC* CMdEEvent::Participant() const

	{

	return iParticipant;

	}

TUint32 CMdEEvent::RequiredBufferSize() const

	{

	TUint32 requiredSize = sizeof(TMdCEvent);

	if( iSource )

		{

		requiredSize += CMdCSerializationBuffer::RequiredSize(*iSource);

		}

	if( iParticipant )

		{

		requiredSize += CMdCSerializationBuffer::RequiredSize(*iParticipant);

		}

	return requiredSize;

	}

TMdCOffset CMdEEvent::SerializeL(CMdCSerializationBuffer& aBuffer, TMdCOffset aFreespaceOffset) const

	{

	const TMdCOffset eventPosition = aBuffer.Position();

	TMdCEvent event;

	event.iId = Id();

	event.iDefId = iDef.Id();

	event.iObjectId = iObjectId;

	event.iTime = iTime;

	if( iSource )

		{

		event.iSourceText.iPtr.iCount = iSource->Length();

		event.iSourceText.iPtr.iOffset = aFreespaceOffset;

		aBuffer.PositionL( aFreespaceOffset );

		aFreespaceOffset = aBuffer.InsertL( *iSource );

		}

	else

		{

		event.iSourceText.iPtr.iCount = 0;

		event.iSourceText.iPtr.iOffset = KNoOffset;

		}

	if( iParticipant )

		{

		event.iParticipantText.iPtr.iCount = iParticipant->Length();

		event.iParticipantText.iPtr.iOffset = aFreespaceOffset;

		aBuffer.PositionL( aFreespaceOffset );

		aFreespaceOffset = aBuffer.InsertL( *iParticipant );

		}

	else

		{

		event.iParticipantText.iPtr.iCount = 0;

		event.iParticipantText.iPtr.iOffset = KNoOffset;

		}

	aBuffer.PositionL( eventPosition );

	event.SerializeL( aBuffer );

	return aFreespaceOffset;

	}

TMdEInstanceType CMdEEvent::InstanceType() const

	{

	return EMdETypeEvent;

	}