// Copyright (c) 2001-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:
// The implementation of the accessor class upon the CTransition
// 
//

// ______________________________________________________________________________
//
_LIT(KTTransition_DumpName,"C:\\System\\Data\\Logs\\TTransition_StateDump.bin");

inline TInt TTransition_StateAccessor::InvariantTest(TAny* aTestObject)
	{
	if(aTestObject)
		{
		CTransition* theTransition = REINTERPRET_CAST(CTransition*, aTestObject);
		if(theTransition->iTransitionId.Length() == 0)
			return KErrArgument;
		}
	return KErrNone;
	}

inline TInt TTransition_StateAccessor::Internalize(TAny* aTestObject)
	{
	TInt error = KErrNone;
	if(aTestObject != NULL)
		{
		CTransition* theTransition = REINTERPRET_CAST(CTransition*, aTestObject);
		TRAP(error,InternalizeL(theTransition));
		}
	return error;
	}

inline TInt TTransition_StateAccessor::Externalize(TAny* aTestObject)
	{
	TInt error = KErrNone;
	if(aTestObject != NULL)
		{
		CTransition* theTransition = REINTERPRET_CAST(CTransition*, aTestObject);
		TRAP(error,ExternalizeL(theTransition));
		}
	return error;
	}

inline TBool TTransition_StateAccessor::IsRepeated(TAny* aTestObject) const
	{
	if(aTestObject != NULL)
		{
		CTransition* theTransition = REINTERPRET_CAST(CTransition*, aTestObject);
		return theTransition->iRepeatThis;
		}
	return EFalse;
	}

inline const TDesC* TTransition_StateAccessor::TransitionId(TAny* aTestObject) const
	{
	if(aTestObject != NULL)
		{
		CTransition* theTransition = REINTERPRET_CAST(CTransition*, aTestObject);
		return &(theTransition->iTransitionId);
		}
	return NULL;
	}

inline const TTransitionInfo* TTransition_StateAccessor::TransitionInfo(TAny* aTestObject) const
	{
	if(aTestObject != NULL)
		{
		CTransition* theTransition = REINTERPRET_CAST(CTransition*, aTestObject);
		return &(theTransition->iTransitionInfo);
		}
	return NULL;
	}

inline TBool TTransition_StateAccessor::BlockingFlag(TAny* aTestObject) const
	{
	if(aTestObject != NULL)
		{
		CTransition* theTransition = REINTERPRET_CAST(CTransition*, aTestObject);
		return theTransition->iBlockingTransition;
		}
	return EFalse;
	}

inline TInt TTransition_StateAccessor::ErrorCode(TAny* aTestObject) const
	{
	if(aTestObject != NULL)
		{
		CTransition* theTransition = REINTERPRET_CAST(CTransition*, aTestObject);
		return theTransition->iLeaveError;
		}
	return EFalse;
	}

inline TRequestStatus TTransition_StateAccessor::Status(const TAny* aTestObject) const
	{
	TRequestStatus status;
	Mem::FillZ(&status, sizeof(status));
	if(aTestObject != NULL)
		{
		status = (reinterpret_cast <const CTransition*> (aTestObject))->iStatus;
		}
	return status;
	}

inline void TTransition_StateAccessor::InternalizeL(RFileReadStream& aStream, CTransition* aTransition)
	{
	aTransition->iRepeatThis				= aStream.ReadInt32L();
	aTransition->iTransitionFinished		= aStream.ReadInt32L();
	aTransition->iLeaveError				= aStream.ReadInt32L();
	aTransition->iBlockingTransition		= aStream.ReadInt32L();
	TPckg<TTransitionInfo> info(aTransition->iTransitionInfo);
	aStream.ReadL(info);
	}

inline void TTransition_StateAccessor::ExternalizeL(RFileWriteStream& aStream, CTransition* aTransition)
	{
	aStream.WriteInt32L(aTransition->iRepeatThis);
	aStream.WriteInt32L(aTransition->iTransitionFinished);
	aStream.WriteInt32L(aTransition->iLeaveError);
	aStream.WriteInt32L(aTransition->iBlockingTransition);
	TPckg<TTransitionInfo> info(aTransition->iTransitionInfo);
	aStream.WriteL(info);
	}

// internal helpers
inline void TTransition_StateAccessor::InternalizeL(CTransition* aTransition)
	{
	// Read in the dumped data
	RFs fs;
	User::LeaveIfError(fs.Connect());
	CleanupClosePushL(fs);
	// Read the object dump
	TParse filename;
	filename.Set(KTTransition_DumpName(),NULL,NULL);
	RFileReadStream stream;
	User::LeaveIfError(stream.Open(fs,filename.FullName(), EFileRead));
	CleanupClosePushL(stream);
	InternalizeL(stream, aTransition);
	CleanupStack::PopAndDestroy(2);		// stream & fs
	}

inline void TTransition_StateAccessor::ExternalizeL(CTransition* aTransition)
	{
	RFs fs;
	User::LeaveIfError(fs.Connect());
	CleanupClosePushL(fs);
	// Write out the object dump
	TParse filename;
	filename.Set(KTTransition_DumpName(),NULL,NULL);
	RFileWriteStream stream;
	User::LeaveIfError(stream.Replace(fs,filename.FullName(), EFileWrite));
	CleanupClosePushL(stream);
	ExternalizeL(stream, aTransition);
	stream.CommitL();
	CleanupStack::PopAndDestroy(2);		// stream & fs
	}