// 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