/*

* Copyright (c) 2007-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.

* generic SIS structure container, provides common functionality on members, see fieldroot.h for purpose of functions

*

*/

/**

 @file 

 @internalComponent

 @released

*/

#ifndef __STRUCTURE_H__

#define __STRUCTURE_H__

#include "container.h"

#include "fieldroot.h"

template <CSISFieldRoot::TFieldType FieldType> class CStructure : public CContainer <CSISFieldRoot, FieldType>

	{

public:

	CStructure ();

	CStructure (const bool aRequired);

	CStructure (const CStructure& s);

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

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

	virtual CSISFieldRoot::TFieldSize ByteCount (const bool aIsArray) const;

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

	TUint64 SkipRead (TSISStream& aFile, const CSISFieldRoot::TFieldSize& aContainerSize, const CSISFieldRoot::TFieldType aArrayType, const TUint32 aSkipCount, const bool aCompleteWithNormalRead);

	void RawSkipWrite (TSISStream& aFile, const bool aIsArrayElement, TUint8* aRawBuffer, const TUint64 aBufferSize, const TUint32 aSkipCount) const;

protected:

	void InsertMember (CSISFieldRoot& aMember);	

		// intended to be used by inheriting constructors *ONLY*

	};

template <CSISFieldRoot::TFieldType FieldType> inline

	CStructure <FieldType>::CStructure ()

	{

	}

template <CSISFieldRoot::TFieldType FieldType> inline

		CStructure <FieldType>::CStructure (const bool aRequired) :

			CContainer<CSISFieldRoot, FieldType> (aRequired)

	{

	}

template <CSISFieldRoot::TFieldType FieldType> inline

		CStructure <FieldType>::CStructure (const CStructure& s) :

			CContainer<CSISFieldRoot, FieldType> (s, 0)

	{ 

	}

template <CSISFieldRoot::TFieldType FieldType>

		void CStructure <FieldType>::Read (TSISStream& aFile, const CSISFieldRoot::TFieldSize& aContainerSize, const CSISFieldRoot::TFieldType aArrayType)

	{

	SetPreHeaderPos (aFile.tell ());

	CSISHeader header (aArrayType);

	if (IsDataThere (aFile, header, aArrayType))

		{

		SetByteCount (header.DataSize ());

		TSISStream::pos_type pos = aFile.tell ();

		SetPostHeaderPos (pos);

#ifdef _DEBUG

		TSISStream::pos_type expected = pos + static_cast <TSISStream::pos_type> (AlignedSize (header.DataSize ()));

#endif

		TUint64 available = aContainerSize;

		for (ContainerIter(CSISFieldRoot) iterMemb = ContainerMem(CSISFieldRoot, FieldType).begin(); 

				iterMemb != ContainerMem(CSISFieldRoot, FieldType).end(); 

				++iterMemb)

			{

			(*iterMemb) -> Read (aFile, available);

			available = aContainerSize - (aFile.tell () - pos);

			}

		ReadFiller (aFile);

#ifdef _DEBUG

		TSISStream::pos_type got = aFile.tell ();

		assert (expected == got);

#endif

		}

	}

template <CSISFieldRoot::TFieldType FieldType>

		TUint64 CStructure <FieldType>::SkipRead (TSISStream& aFile, const CSISFieldRoot::TFieldSize& aContainerSize, const CSISFieldRoot::TFieldType aArrayType, const TUint32 aSkipCount, const bool aCompleteWithNormalRead)

	{

	CSISHeader header (CSISFieldRoot::ESISUndefined);

	TUint32 skipped = 0;

	TUint64 offset = 0;

	if (IsDataThere (aFile, header, aArrayType))

		{

		SetByteCount (header.DataSize ());

		TSISStream::pos_type pos = aFile.tell ();

#ifdef _DEBUG

		TSISStream::pos_type expected = pos + static_cast <TSISStream::pos_type> (AlignedSize (header.DataSize ()));

#endif

		TUint64 available = aContainerSize;

		for (ContainerIter(CSISFieldRoot) iterMemb = ContainerMem(CSISFieldRoot,FieldType).begin (); iterMemb != ContainerMem(CSISFieldRoot, FieldType).end (); iterMemb++)

			{

			if (! aCompleteWithNormalRead || (skipped < aSkipCount))

				{

				(*iterMemb) -> Skip (aFile, available);

				if (++skipped == aSkipCount)

					{

					offset = static_cast <TUint64> (aFile.tell ()) - pos;

					assert (AlignedSize (offset) == offset);

					}

				}

			else

				{

				(*iterMemb) -> Read (aFile, available);

				}

			available = aContainerSize - (aFile.tell () - pos);

			}

		ReadFiller (aFile);

#ifdef _DEBUG

		TSISStream::pos_type got = aFile.tell ();

		assert (expected == got);

#endif

		}

	return offset;

	}

template <CSISFieldRoot::TFieldType FieldType>

		void CStructure <FieldType>::Write (TSISStream& aFile, const bool aIsArrayElement) const

	{

#ifdef GENERATE_ERRORS

	unsigned int unknownLen = rand()%1000;

#endif // GENERATE_ERRORS

	bool writeData = ! WasteOfSpace ();

	if (writeData)

		{

#ifdef GENERATE_ERRORS

		bool unknownField = CSISFieldRoot::IsBugToBeCreated (CSISFieldRoot::EBugUnknownField);

#endif // GENERATE_ERRORS

#ifdef _DEBUG

		TSISStream::pos_type before = aFile.tell ();

#endif

		CSISHeader (

#ifdef GENERATE_ERRORS

						static_cast <const CSISFieldRoot::TFieldType> (unknownField ? 

							static_cast <TUint32> (rand () % 0x0FFF + CSISFieldRoot::EBugUnknownField) :

							FieldType),

#else // GENERATE_ERRORS

						FieldType, 

#endif // GENERATE_ERRORS

						ByteCount (false)).Write (aFile, aIsArrayElement);

#ifdef _DEBUG

		TSISStream::pos_type pos = aFile.tell ();

		TSISStream::pos_type expected = aFile.tell () + static_cast <TSISStream::pos_type> (AlignedSize (ByteCount (false)));

#endif

		for (ContainerIter(CSISFieldRoot) iterMemb = ContainerMem(CSISFieldRoot,FieldType).begin(); iterMemb != ContainerMem(CSISFieldRoot,FieldType).end(); iterMemb++)

			{

#ifdef GENERATE_ERRORS

			if (! CSISFieldRoot::IsBugToBeCreated (CSISFieldRoot::EBugMissingField))

				{

				if (CSISFieldRoot::IsBugToBeCreated (CSISFieldRoot::EBugUnexpectedField))

					{

					(*iterMemb) -> Write (aFile, false);

					}

				(*iterMemb) -> Write (aFile, false);

				}

			if (CSISFieldRoot::IsBugToBeCreated(CSISFieldRoot::EBugUnknownData))

				{

				CSISFieldRoot::AddRawDataValue(aFile,unknownLen);

				}

#else // GENERATE_ERRORS

			(*iterMemb) -> Write (aFile, false);

#endif // GENERATE_ERRORS

#ifdef _DEBUG

			TSISStream::pos_type ici = aFile.tell ();

#endif

			}

		TSISStream::pos_type beforeFiller = aFile.tell ();

		WriteFiller (aFile);

#ifdef _DEBUG

		TSISStream::pos_type actual = aFile.tell ();

#ifdef GENERATE_ERRORS

		if (! IsAnyBugSet ())

			{

			assert (expected == actual);

			}

		else 

			{	

			if (expected != actual)

				{

				aFile.seek (before);

				CSISHeader (FieldType, beforeFiller - pos).Write (aFile, aIsArrayElement);

				aFile.seek (actual);

				}

			}

#else

			assert (expected == actual);

#endif  // GENERATE_ERRORS

#endif  // DEBUG

		}

	}

template <CSISFieldRoot::TFieldType FieldType>

		void  CStructure <FieldType>::RawSkipWrite (TSISStream& aFile, const bool aIsArrayElement, TUint8* aRawBuffer, const TUint64 aBufferSize, const TUint32 aSkipCount) const

	{

	assert (! WasteOfSpace ());	// not tested

	assert ((! aBufferSize) ^ (aRawBuffer != NULL));

	TUint32 skipped = 0;

	TUint64 before = static_cast <TUint64> (aFile.tell ());

	CSISHeader (FieldType, 0).Write (aFile, aIsArrayElement);

	TUint64 after = static_cast <TUint64> (aFile.tell ());

	if (aRawBuffer)

		{

		aFile.write (aRawBuffer, aBufferSize);

		WriteFiller (aFile);

		}

	for (ContainerIter(CSISFieldRoot) iterMemb = ContainerMem(CSISFieldRoot,FieldType).begin (); iterMemb != ContainerMem(CSISFieldRoot,FieldType).end (); iterMemb++)

		{

		if (skipped++ >= aSkipCount)

			{

			(*iterMemb) -> Write (aFile, false);

			}

		else

		if (skipped == aSkipCount)

			{

			(*iterMemb) -> SkipOldWriteNew (aFile);

			}

		}

	WriteFiller (aFile);

	TUint64 actual = static_cast <TUint64> (aFile.tell ());

	CSISException::ThrowIf (CSISHeader::IsBigHeader (actual - after), 

							CSISException::EFileFormat,

							"inconsistent structure size"); // why is SISController so huge;

	aFile.seek (before); 

	CSISHeader (FieldType, actual - after).Write (aFile, aIsArrayElement);

	aFile.seek (actual);

	}

template <CSISFieldRoot::TFieldType FieldType> inline

		void CStructure <FieldType>::CalculateCrc (TCRC& aCRC, const bool aIsArrayElement) const

	{

	if(!WasteOfSpace())

		{

		CSISHeader (FieldType, ByteCount (false)).CalculateCrc (aCRC, aIsArrayElement); 

		CContainer<CSISFieldRoot, FieldType>::CalculateCrc (aCRC, false);

		}

	}

template <CSISFieldRoot::TFieldType FieldType> inline

		void CStructure <FieldType>::InsertMember (CSISFieldRoot& aMember)

	{

	ContainerMem(CSISFieldRoot,FieldType).push_back (&aMember);

	}

template <CSISFieldRoot::TFieldType FieldType> inline

		CSISFieldRoot::TFieldSize CStructure <FieldType>::ByteCount (const bool aIsArray) const

	{

	assert (! aIsArray);

	return CContainer<CSISFieldRoot, FieldType>::ByteCount (false);

	}

#endif // __STRUCTURE_H__