/*
* 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.
* Acts as layer between old MakeSIS and new SISX file format.
* Handles creation of a SISX file
*
*/


/**
 @file 
 @internalComponent
 @released
*/

#ifndef __SISWRITE_H_
#define __SISWRITE_H_

#include "siscontents.h"
#include <iostream>



class CSISXWriter
	{
public:
	CSISXWriter ();
	void WriteSIS (const std::wstring aTargetFileName);
	void Dump (std::ostream& aStream);
   	void SetVersionInfo (	const CSISUid::TUid aUID, const TVersion& aVersion,
							const TUint32 aType, const TUint32 aFlags);
	TUint32 GetNoLanguages () const;
	bool AreLanguagesSpecified () const;
	void AddLanguage (const CSISLanguage::TDialect aLan);
	void AddProperty (const CSISProperty::TKey aKey, const CSISProperty::TValue aValue);
	CSISUid::TUid UID1 () const;
	void AddName (const std::wstring& aLan);
	void AddVendorName (const std::wstring& aLan);
	void SetVendorUniqueName (const std::wstring& aVendorUniqueName);
	void AddDependencyName (const std::wstring& aName);
	void AddTargetName (const std::wstring& aName);
	void AddOptionName (const std::wstring& aName);
	void AddOption ();
	CSISFileDescription::TSISInstOption InterpretOption (const std::wstring& aOption);
	CSISInfo::TSISInstallationType InterpretType (const std::wstring& aOption);
	void SetMimeType (const std::wstring& aMimeType);
	void AddIf ();
	const CSISIf& If () const;
	CSISIf& If ();
	const CSISInstallBlock& InstallBlock () const;
	CSISInstallBlock& InstallBlock ();
	void SetLogo (const std::wstring& aFile, const std::wstring& aMime, const std::wstring& aTarget);
	void AddDependency (const CSISUid::TUid aUID, const TVersion& aFrom, const TVersion& aTo);
	void AddTarget (const CSISUid::TUid aUID, const TVersion& aFrom, const TVersion& aTo);
	void EmbedFile (const std::wstring& aFile, const CSISUid::TUid& aUid, CSISInstallBlock& aInstall);
	void EmbedPackage (CSISInstallBlock& aInstallBlock, const std::wstring& aFile, const CSISUid::TUid& aUid);
	void SetDefaultContent ();
	TUint32 LoadFile (const std::wstring& aFile, TUint64* aSize = NULL);
	TUint64 CompressedSize () const;
	TUint64 UncompressedSize () const;
	const CSISDataUnit& DataUnit () const;
	const CSISDataUnit& DataUnit (const TUint32 aUnit) const;
	CSISLanguage::TLanguage Language (const TUint32 aIndex) const;
	void AddInstallFlag(const TUint8 aFlag);
	const CSISContents& SISContent() const;

private:
	CSISContents		iContent;
	};

inline CSISXWriter::CSISXWriter ()
	{
	}

inline const CSISContents& CSISXWriter::SISContent() const	
	{
	return iContent;
	}

inline void CSISXWriter::Dump (std::ostream& aStream)
	{
	aStream <<  std::endl << iContent.Name () << std::endl << "  ";
	iContent.Dump (aStream, 2);
	aStream << std::endl;
	}

inline void CSISXWriter::SetVersionInfo (	const CSISUid::TUid aUID, const TVersion& aVersion,
											const TUint32 aType, const TUint32 aFlags)
	{
 	iContent.SetVersionInfo (aUID, aVersion, aType, aFlags);
	}

inline TUint32 CSISXWriter::GetNoLanguages () const
	{
	TUint32 count (iContent.LanguageCount ());
	return (count == 0) ? 1 : count; 
	}

inline bool CSISXWriter::AreLanguagesSpecified () const
	{
	return iContent.AreLanguagesSpecified ();
	}

inline void CSISXWriter::AddLanguage (const CSISLanguage::TDialect aLan)
	{
	iContent.AddLanguage (aLan);
	}

inline void CSISXWriter::AddProperty (const CSISProperty::TKey aKey, const CSISProperty::TValue aValue)
	{
	iContent.AddProperty (aKey, aValue);
	}

inline CSISUid::TUid CSISXWriter::UID1 () const
	{
	return iContent.UID1 (); 
	}

inline void CSISXWriter::AddName (const std::wstring& aLan)
	{
	iContent.AddName (aLan); 
	}

inline void CSISXWriter::AddVendorName (const std::wstring& aLan)
	{
	iContent.AddVendorName (aLan);
	}

inline void CSISXWriter::AddDependencyName (const std::wstring& aName)
	{
	iContent.AddDependencyName (aName);
	}

inline void CSISXWriter::AddTargetName (const std::wstring& aName)
	{
	iContent.AddTargetName (aName); 
	}

inline void CSISXWriter::AddOptionName (const std::wstring& aName)
	{
	iContent.AddOptionName (aName); 
	}

inline void CSISXWriter::AddOption ()
	{
	iContent.AddOption ();
	}

inline CSISFileDescription::TSISInstOption CSISXWriter::InterpretOption (const std::wstring& aOption)
	{
	return iContent.InterpretOption (aOption); 
	}

inline CSISInfo::TSISInstallationType CSISXWriter::InterpretType (const std::wstring& aOption)
	{
	return iContent.InterpretType (aOption); 
	}

inline void CSISXWriter::SetMimeType (const std::wstring& aMimeType)
	{
	iContent.SetMimeType (aMimeType); 
	}

inline void CSISXWriter::AddIf ()
	{
	iContent.AddIf ();
	}

inline const CSISIf& CSISXWriter::If () const
	{
	return iContent.If (); 
	}

inline CSISIf& CSISXWriter::If ()
	{
	return iContent.If (); 
	}

inline const CSISInstallBlock& CSISXWriter::InstallBlock () const
	{
	return iContent.InstallBlock (); 
	}

inline CSISInstallBlock& CSISXWriter::InstallBlock ()
	{
	return iContent.InstallBlock ();
	}

inline void CSISXWriter::SetLogo (const std::wstring& aFile, const std::wstring& aMime, const std::wstring& aTarget)
	{
	iContent.SetLogo (aMime, aTarget, aFile, DataUnit()); 
	}

inline void CSISXWriter::AddDependency (const CSISUid::TUid aUID, const TVersion& aFrom, const TVersion& aTo)
	{
	iContent.AddDependency (aUID, aFrom, aTo);
	}

inline void CSISXWriter::AddTarget (const CSISUid::TUid aUID, const TVersion& aFrom, const TVersion& aTo)
	{
	iContent.AddTarget (aUID, aFrom, aTo);
	}

inline void CSISXWriter::SetDefaultContent ()
	{
	iContent.SetDefaultContent ();
	}

inline TUint32 CSISXWriter::LoadFile (const std::wstring& aFile, TUint64* aSize)
	{
	return iContent.LoadFile (aFile, aSize);
	}

inline TUint64 CSISXWriter::CompressedSize () const
	{
	return iContent.CompressedSize ();
	}

inline TUint64 CSISXWriter::UncompressedSize () const
	{
	return iContent.UncompressedSize ();
	}

inline const CSISDataUnit& CSISXWriter::DataUnit () const
	{
	return iContent.DataUnit ();
	}

inline const CSISDataUnit& CSISXWriter::DataUnit (const TUint32 aUnit) const
	{
	return iContent.DataUnit (aUnit);
	}

inline void CSISXWriter::SetVendorUniqueName (const std::wstring& aVendorUniqueName)
	{
	iContent.SetVendorUniqueName (aVendorUniqueName);
	}

inline CSISLanguage::TLanguage CSISXWriter::Language (const TUint32 aIndex) const
	{
	return iContent.Language (aIndex);
	}

inline void CSISXWriter::EmbedFile (const std::wstring& aFile, const CSISUid::TUid& aUid, CSISInstallBlock& aInstall)
	{
	iContent.EmbedFile (aFile, aUid, aInstall);
	}

inline void CSISXWriter::EmbedPackage (CSISInstallBlock& aInstallBlock, const std::wstring& aFile, const CSISUid::TUid& aUid)
	{
	iContent.EmbedPackage (aInstallBlock, aFile, aUid);
	}

inline void CSISXWriter::WriteSIS (const std::wstring aTargetFileName)
	{
	iContent.WriteSIS (aTargetFileName);
	}

inline void CSISXWriter::AddInstallFlag(const TUint8 aFlag)
	{
	iContent.AddInstallFlag(aFlag);
	}

#endif // __SISWRITE_H_