/*

* Copyright (c) 2004-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: 

* Note: This file may contain code to generate corrupt files for test purposes.

* Such code is excluded from production builds by use of compiler defines;

* it is recommended that such code should be removed if this code is ever published publicly.

* base class for all types found in sis files. Defines all virtual functions.

* fieldroot <- field <- container <- [array, sequence, structure] <- most SIS types

* fieldroot <- field <- [string, compressed, blob]

* fieldroot <- numeric

* fieldroot <- header

*

*/

/**

 @file 

 @internalComponent

 @released

*/

#ifndef __FIELDROOT_H__

#define __FIELDROOT_H__

#include <assert.h>

#include "basefile.h"

#ifdef GENERATE_ERRORS

#ifndef _DEBUG

#error GENERATE_ERRORS requires _DEBUG

			// or change the code to rewrite TLV sizes in array and structure

#endif

#endif

class CSISFieldRoot

	{

public:

	typedef TUint64 TFieldSize;		// in BYTES

	typedef enum

		{

		ESISUndefined,

		ESISString,

		ESISArray,

		ESISCompressed,

		ESISVersion,

		ESISVersionRange, 

		ESISDate,

		ESISTime,

		ESISDateTime,

		ESISUid,

		ESISUnused1,

		ESISLanguage,

		ESISContents,

		ESISController,

		ESISInfo,

		ESISSupportedLanguages,

		ESISSupportedOptions,

		ESISPrerequisites,

		ESISDependency,

		ESISProperties,

		ESISProperty,

		ESISSignatures,

		ESISCertificateChain,

		ESISLogo,

		ESISFileDescription,

		ESISHash,

		ESISIf,

		ESISElseIf,

		ESISInstallBlock,

		ESISExpression,

		ESISData,

		ESISDataUnit,

		ESISFileData,

		ESISSupportedOption,

		ESISControllerChecksum,

		ESISDataChecksum,

		ESISSignature,

		ESISBlob,

		ESISSignatureAlgorithm,

		ESISSignatureCertificateChain,

		ESISDataIndex,

		ESISCapabilities,

			// insert new fields here

		ESISUnknown

		} TFieldType;

	typedef enum

		{

		EDbgDefault				= 0,

		EDbgDataChecksum		= 0x01,

		EDbgControllerChecksum	= 0x02,

		EDbgCompress			= 0x04,

		EDbgNoCompress			= 0x08,

		} TDbgFlag;

#ifdef GENERATE_ERRORS

	typedef enum

		{

		EBugDefault			= 0,

		EBugCRCError		= 0x0001,

		EBugInvalidLength	= 0x0002,

		EBugMissingField  	= 0x0004,

		EBugUnexpectedField	= 0x0008,

		EBugBigEndian	  	= 0x0010,

		EBugDuffFieldType 	= 0x0020,

		EBugInvalidValues  	= 0x0040,

		EBugHashError	 	= 0x0080,

		EBugNegativeLength	= 0x0100,

		EBugInsaneString	= 0x0200,

		EBugInsaneBlob		= 0x0400,

		EBugArrayCount		= 0x0800,

		EBug32As64			= 0x1000,

		EBugUnknownField	= 0x2000,

		EBugEmptyCaps       = 0x4000,

		EBugUnknownData		= 0x8000,

		} TBug;

#endif // GENERATE_ERRORS

	typedef enum

		{

		EOptDefault				= 0,

		EOptIsUnicode			= 1<<0,

		EOptIsDistributable		= 1<<1,

		EOptIsCompareToMajor	= 1<<2,

		EOptNoCompress			= 1<<3,

		EOptShutdownApps		= 1<<4,

		EOptNonRemovable		= 1<<5,

		EOptROMUpgrade			= 1<<6,

		} THeadOpt;

public:

	CSISFieldRoot ();

	virtual ~CSISFieldRoot ();

public:

	/**

	 * Internalize the class

	 * @param aFile File stream from where data needs to be read.

	 * @param aContainerSize size of the content to be read.

	 * @param aArrayType Type of the array 

	 */

	virtual void Read (TSISStream& aFile, const TFieldSize& aContainerSize, const TFieldType aArrayType = ESISUndefined) = 0;

	/**

	 * Skip the file reading for this field. Read pointer will be moved to the

	 * next field to be read.

	 * @param aFile stream for which the data read should be skipped.

	 * @param aContainerSize size of the data to be skipped. 

	 */

	virtual void Skip (TSISStream& aFile, const TFieldSize& aContainerSize) const = 0;

	/**

	 * Externalize the class

	 * @param aFile File stream to which the data needs to be written.

	 * @param aIsArrayElement whether the structure is part of an array or not. 

	 */

	virtual void Write (TSISStream& aFile, const bool aIsArrayElement) const = 0;

	/**

	 * This function verifies the structure. If verification of object fails, throw an exception

	 * aLanguages >= 1

	 * @param aLanguages - language

	 */ 

	virtual void Verify (const TUint32 aLanguages) const;

	/**

	 * if object not acceptable, modify it. Assumes, once modified, will not need modifying again

	 */

	virtual void MakeNeat ();

	/**

	 * @return 	if true, don't bother writing this record to disc

	 * 			if false, when reading, it'd better be there

	 */

	virtual bool WasteOfSpace () const;

	/**

	 * Retrieves the size of the structure excluding the header.

	 * @param aInsideArray - whether the structure is part of an array or not. 

	 * @return byte count.

	 */

	virtual TFieldSize ByteCount (const bool aInsideArray) const = 0;

	/**

	 * Retrieves the in-stream size of data in BYTES of the structure with the header.

	 * @param aInsideArray - whether the structure is part of an array or not. 

	 * @return byte count.

	 */

	virtual TFieldSize ByteCountWithHeader (const bool aInsideArray) const;	

	/**

	 * Sets the size of the structure. 

	 * either 	a) set variable size field, or

	 *			b) ensure fixed size field is expected size

	 * @param size - size of the structure. 

	 */

	virtual void SetByteCount (const TFieldSize aSize);

	/**

	 * Dump the entire content in hex format into the stream

	 */

	virtual void Dump (std::ostream& aStream, const int aLevel) const = 0;

	/**

	 * Adds the write the package details into the stream.

	 * @param aStream - Stream in which the package entries need to be written.

	 * @param aVerbose - If this option is set then detail description of pkg

	 * 			will be written into the stream.

	 */

	/**

	 * Class name

	 */

	virtual std::string Name () const;

	/**

	 * Calculates CRC of the content

	 * @param aCRC CRC value of the content

	 * @param aIsArrayElement whether the structure is part of an array or not. 

	 */ 

	virtual void CalculateCrc (TCRC& aCRC, const bool aIsArrayElement) const = 0 ;

#ifdef GENERATE_ERRORS

	virtual void CreateDefects ();

#endif // GENERATE_ERRORS

	virtual void SkipOldWriteNew (TSISStream& aFile) const;

	/**

	 * stream offset before the header

	 */

	virtual TSISStream::pos_type PreHeaderPos () const;

	/**

	 * stream offset after the header

	 */

	virtual TSISStream::pos_type PostHeaderPos () const;

	/**

	 * Calculates CRC of the content

	 * @param aIsArrayElement whether the structure is part of an array or not. 

	 * @return CRC value of the content

	 */ 

	TCRC Crc (const bool aIsArrayElement = false) const;

	std::string NoteIfOptional () const;

	/**

	 * Set Debug options

	 */

	static void SetDebugOption (const TDbgFlag aDbgFlag);

	/**

	 * Check if a particular debug option is set or not.

	 */

	static bool IsDebugOptionSet (const TDbgFlag aDbgFlag);

	/**

	 * Set file header option

	 */

	static void SetHeaderOption (const THeadOpt aHeaderOption);

	/**

	 * Check if a particular file header option is set or not.

	 */

	static bool IsHeaderOptionSet (const THeadOpt aHeaderOption);

#ifdef GENERATE_ERRORS

	static void SetBug (const TBug aBug);

	static bool IsBugSet (const TBug aBug);

	static bool IsAnyBugSet ();

	static void SetBugStart (const unsigned aStart);

	static void SetBugRepeat (const unsigned aRepeat);

	static bool IsBugToBeCreated (const TBug aBug);

	static void AddRawDataValue (TSISStream& aFile,const unsigned aLength);

#endif // GENERATE_ERRORS

	/**

	 * Initialize the instance.

	 */

	static void InitInstance ();

protected:

	// calculates the CRC of the given data

	static void DoTheCrc (TCRC& aCRC, const TUint8* aData, const unsigned aLen);

	// calculates CRC on the given data and the padding bytes that will be required

	static void DoPaddedCrc(TCRC& aCRC, const TUint8* aData, const unsigned aLen);

	// calculate the CRC of just the padding for the given data length

	static void PaddingCrc(TCRC& aCRC, const unsigned aLength);

	static unsigned SizeOfFieldType ();

protected:

	static TDbgFlag	iDbgFlag;

	static THeadOpt	iOptions;

#ifdef GENERATE_ERRORS

	static TBug		iBug;

	static unsigned iBugStart;

	static unsigned iBugRepeat;

	static unsigned iBugRepeatCountdown;

#endif // GENERATE_ERRORS

	};

	{

	(void)aStream;

	(void)aVerbose;

	}

inline void CSISFieldRoot::InitInstance ()

	{

	srand (1);

		// Please consult the VC6 documentation to understand the supplied parameter value.

	}

inline void CSISFieldRoot::SetDebugOption (const TDbgFlag aDbgFlag)

	{

	iDbgFlag = static_cast <TDbgFlag> (static_cast <unsigned int> (iDbgFlag) + static_cast <unsigned int> (aDbgFlag));

	}

inline bool CSISFieldRoot::IsDebugOptionSet (const TDbgFlag aDbgFlag)

	{

	return (static_cast <unsigned int> (iDbgFlag) & static_cast <unsigned int> (aDbgFlag)) != 0;

	}

inline void CSISFieldRoot::SetHeaderOption (const THeadOpt aOptions)

	{

	iOptions = static_cast <THeadOpt> (static_cast <unsigned int> (iOptions) + static_cast <unsigned int> (aOptions));

	}

inline bool CSISFieldRoot::IsHeaderOptionSet (const THeadOpt aOptions)

	{

	return (static_cast <unsigned int> (iOptions) & static_cast <unsigned int> (aOptions)) != 0;

	}

#ifdef GENERATE_ERRORS

inline void CSISFieldRoot::SetBug (const TBug aBug)

	{

	iBug = static_cast <TBug> (static_cast <unsigned int> (iBug) + static_cast <unsigned int> (aBug));

	}

inline bool CSISFieldRoot::IsBugSet (const TBug aBug)

	{

	return (static_cast <unsigned int> (iBug) & static_cast <unsigned int> (aBug)) != 0;

	}

inline bool CSISFieldRoot::IsAnyBugSet ()

	{

	return iBug != EBugDefault;

	}

inline void CSISFieldRoot::SetBugStart (const unsigned aStart)

	{

	iBugStart = aStart;

	}

inline void CSISFieldRoot::SetBugRepeat (const unsigned aRepeat)

	{

	iBugRepeat = aRepeat;

	iBugRepeatCountdown = aRepeat;

	}

inline void CSISFieldRoot::CreateDefects ()

	{

	}

#endif // GENERATE_ERRORS

inline std::string CSISFieldRoot::NoteIfOptional () const

	{

	return WasteOfSpace () ? " (Dropped)" : std::string ();

	}

inline void CSISFieldRoot::Verify (const TUint32 aLanguages) const

	{ 

	}

inline bool CSISFieldRoot::WasteOfSpace () const

	{ 

	return false; 

	}

inline CSISFieldRoot::TFieldSize CSISFieldRoot::ByteCountWithHeader (const bool aInsideArray) const

	{ 

	return ByteCount (aInsideArray); 

	}

inline void CSISFieldRoot::SetByteCount (const TFieldSize aSize)

	{

	assert (aSize == ByteCount (false));

	}

inline void CSISFieldRoot::MakeNeat ()

	{ 

	}

inline std::string CSISFieldRoot::Name () const

	{

	return std::string ();

	}

inline unsigned CSISFieldRoot::SizeOfFieldType ()

	{

	return sizeof (TUint32);

	}

inline void CSISFieldRoot::SkipOldWriteNew (TSISStream& aFile) const

	{

	}

inline TSISStream::pos_type CSISFieldRoot::PreHeaderPos () const

	{

	return 0;

	}

inline TSISStream::pos_type CSISFieldRoot::PostHeaderPos () const

	{

	return 0;

	}

TSISStream& operator >> (TSISStream& aFile, CSISFieldRoot::TFieldType& aType);

TSISStream& operator << (TSISStream& aFile, const CSISFieldRoot::TFieldType aType);

#endif // __FIELDROOT_H__