// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// e32\debug\crashMonitor\src\scmconfigitem.cpp

// 

//

/**

 @file

 @internalTechnology

*/

#include <e32def.h>

#include <e32def_private.h>

#include <scmconfigitem.h>

#include <scmdatatypes.h>

#include <scmtrace.h>

namespace Debug

	{	

/**

 * TConfigItem constructor

 */

TConfigItem::TConfigItem() 

: iDataType(ELast)

, iSizeToDump(0)

, iSpaceRequiredToDump(0)

, iPriority(0)

, iNext(NULL)

	{

	}

/**

 * TConfigItem constructor

 * @param aDataType - data type id

 * @param aSizeToDump - size of the config data 

 * @param aPriority - priority of this data type (if 0 then not used)

 */	

TConfigItem::TConfigItem(TSCMDataType aDataType,  TUint8 aPriority, TInt32 aSizeToDump)

: iDataType(aDataType)

, iSizeToDump(aSizeToDump)

, iPriority(aPriority)

, iNext(NULL)

	{	

	}

/**

 * Serialize - writes this object to the supplied byte stream

 * @param aItem -  aWriter - the TByteStreamWriter that will be written to

 * @return one of the OS wide codes

 */

TInt TConfigItem::Serialize(TByteStreamWriter& aWriter)

	{	

	TInt startPos = aWriter.CurrentPosition();

	aWriter.WriteByte((TUint8)iDataType);

	aWriter.WriteInt(iSizeToDump);

	aWriter.WriteByte(iPriority);				

	TInt sizeWritten = aWriter.CurrentPosition() - startPos;

	if(sizeWritten != GetSize())

		{

		// error between actual size & real size in data

		CLTRACE2("TConfigItem serialization size error sizeWritten %d GetSize() %d", sizeWritten, GetSize());

		return KErrCorrupt;

		}

	return KErrNone;

	}

/**

 * Deserialize - read this objects state from the supplied byte stream

 * @param aItem -  aReader - the TByteStreamReader that will be read from

 * @return One of the OS wide codes

 */

TInt TConfigItem::Deserialize(TByteStreamReader& aReader)

	{

	TInt startPos = aReader.CurrentPosition();

	iDataType = (TSCMDataType) aReader.ReadByte();	

	iSizeToDump = aReader.ReadInt();

	iPriority = aReader.ReadByte();	

	TInt sizeRead = aReader.CurrentPosition() - startPos;

	if(sizeRead != GetSize())

		{

		// error between actual size & real size in data

		CLTRACE("(TConfigItem::Deserialize) ERROR size error");

		return KErrCorrupt;

		}				

	return KErrNone;

	}

/**

 * GetDataType 

 * @return data type of this config item

 */

 TConfigItem::TSCMDataType TConfigItem::GetDataType() const

	{

	return iDataType;

	}

/**

 * GetPriority 

 * @return priority of this config item (0-255)

 */ 

TInt TConfigItem::GetPriority() const

	{

	return iPriority;

	}

/**

 * GetSize 

 * @return size to dump in bytes

 */

TInt TConfigItem::GetSizeToDump() const

	{

	return iSizeToDump;

	}

/**

 * GetSize 

 * @return size of this object when streamed in bytes

 */

TInt TConfigItem::GetSize() const

	{

	return 6;

	}

/**

 * Returns next item

 * @return Next item

 */

TConfigItem* TConfigItem::Next() const

	{

	return iNext;

	}

	/**

	 * Print - displays info about this TConfigItem 

	 * @return void

	 */

 	void TConfigItem::Print() const 

 		{

 		CLTRACE3( "(TConfigItem::Print) iDataType = %d iPriority = %d iSizeToDump = %d"

 				, iDataType, iPriority, iSizeToDump);

 		}

 	TBool TConfigItem::operator == (const TConfigItem& aOther) const

 		{

 		return (iDataType == aOther.iDataType && iSizeToDump == aOther.iSizeToDump && iPriority == aOther.iPriority);

 		}

/**

 * Sets the space required parameter for this config item

 * @param aSpaceReq Space required

 */

void TConfigItem::SetSpaceRequired(TUint aSpaceReq)

	{

	iSpaceRequiredToDump = aSpaceReq;

	}

/**

 * Gets the space required to store this config item

 * @return

 */

TUint TConfigItem::GetSpaceRequired()

	{

	return iSpaceRequiredToDump;

	}

#ifndef __KERNEL_MODE__

// human readable strings for TSCMDataType

_LIT(KExceptionStacks, "Exception Stacks");

_LIT(KTraceData, "Trace data");

_LIT(KProcessCodeSegs, "ProcessCodeSegs");

_LIT(KThreadsUsrStack, "Threads UserStack");

_LIT(KThreadsSvrStack, "Threads Supervisor Stack");

_LIT(KKernelHeap, "Kernel Heap");

_LIT(KThreadsUsrRegisters, "Threads User Registers");

_LIT(KThreadsSvrRegisters, "Threads Supervisor Registers");

_LIT(KProcessMetaData, "Process Meta Data");

_LIT(KThreadsMetaData, "Threads Meta Data");

_LIT(KCrashedProcessCodeSegs, "Crashed Process Code Segs");

_LIT(KCrashedProcessUsrStacks, "Crashed Process' User Stack's");

_LIT(KCrashedProcessSvrStacks, "Crashed Process' Supervisor Stack's");

_LIT(KCrashedProcessMetaData, "Crashed Process Meta Data");

_LIT(KCrashedThreadMetaData, "Crashed Thread Meta Data");				

_LIT(KLocks, "SCM Locks");

_LIT(KVariantSpecific, "Variant Specific Data");

_LIT(KRomInfo, "ROM Info");

_LIT(KUnknown,  "Unknown");

/**

 * helper function for converting TSCMDataType enul to human readable form

 */

 const TDesC& TConfigItem::GetSCMConfigOptionText(TConfigItem::TSCMDataType aType)

 		{

 		switch (aType)

 			{

 			case TConfigItem::EExceptionStacks:

 				return KExceptionStacks;

 			case TConfigItem::ETraceData:

 				return KTraceData;

 			case TConfigItem::EProcessCodeSegs:

 				return KProcessCodeSegs();

 			case TConfigItem::EThreadsUsrStack:

 				return KThreadsUsrStack();

 			case TConfigItem::EThreadsSvrStack:

 				return KThreadsSvrStack;

 			case TConfigItem::EThreadsUsrRegisters:

 				return KThreadsUsrRegisters();

 			case TConfigItem::EThreadsSvrRegisters:

 				return KThreadsSvrRegisters();

 			case TConfigItem::EProcessMetaData:

 				return KProcessMetaData();

 			case TConfigItem::EThreadsMetaData:

 				return KThreadsMetaData();

 			case TConfigItem::ECrashedProcessCodeSegs:

 				return KCrashedProcessCodeSegs();

 			case TConfigItem::ECrashedProcessUsrStacks:

 				return KCrashedProcessUsrStacks();

 			case TConfigItem::ECrashedProcessSvrStacks:

 				return KCrashedProcessSvrStacks();

 			case TConfigItem::ECrashedProcessMetaData:

 				return KCrashedProcessMetaData();

 			case TConfigItem::ECrashedThreadMetaData:						

 				return KCrashedThreadMetaData();

 			case TConfigItem::ELocks:						

 				return KLocks();

 			case TConfigItem::EKernelHeap:

 				return KKernelHeap();

 			case TConfigItem::EVariantSpecificData:

 				return KVariantSpecific();

 			case TConfigItem::ERomInfo:

 				return KRomInfo();	

			case TConfigItem::ELast:

 			default:

 				return KUnknown();

 			}

 		}

#endif // ! __KERNEL_MODE__

}

//eof