/*

* 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: 

* CScrXmlParser - Used to retrieve details from xml files for creating database and 

* Software environment updates.

*

*/

/**

 @file 

 @released

 @internalTechnology

*/

#ifndef XMLPARSER_H

#define XMLPARSER_H

#pragma warning(disable: 4786)

#pragma warning(disable: 4291)

#include <vector>

#include <string>

#include <xercesc/parsers/XercesDOMParser.hpp>

#include <xercesc/sax/ErrorHandler.hpp>

#include <xercesc/dom/DOM.hpp>

#include "toolsconf.h"

/**

* This template is used to cleanup memory by calling a function as pointed 

* by the first parameter as a function parameter. It can be used only used

* with functions which take a pointer to a pointer as an argument. This is 

* currently a limitation as the xerces library takes the same to release 

* its own memory.

*/

template <typename tFnPtr, typename tPtr> class fn_auto_ptr 

	{

	public:

		explicit fn_auto_ptr(tFnPtr aFnPtr, tPtr* aPtr)

			: iFnPtr(aFnPtr),

			iPtr(aPtr)

		{}

		~fn_auto_ptr() { iFnPtr(&iPtr); }

		tPtr *get() const throw()

			{

			return (iPtr); 

			}

	private:

		tFnPtr iFnPtr;

		tPtr* iPtr;

	};

template <typename tFnPtr, typename tPtr> class mem_fn_auto_ptr 

	{

	public:

		explicit mem_fn_auto_ptr(tFnPtr aFnPtr, tPtr aPtr)

			: iFnPtr(aFnPtr),

			iPtr(aPtr)

			{}

		~mem_fn_auto_ptr() { (iPtr->*iFnPtr)(); }

		tPtr operator->() const throw()

			{

			return (get()); 

			}

		tPtr get() const throw()

			{

			return (iPtr); 

			}

	private:

		tFnPtr iFnPtr;

		tPtr iPtr;

	};

template <typename tFnPtr> class static_fn_auto_ptr 

	{

	public:

		explicit static_fn_auto_ptr(tFnPtr aFnPtr)

			: iFnPtr(aFnPtr)

			{}

		~static_fn_auto_ptr() { &iFnPtr; }

	private:

		tFnPtr iFnPtr;

	};

namespace XmlDetails

{

	struct TScrEnvironmentDetails

			{

		public:

			TScrEnvironmentDetails()

			{}

			class TLocalizedSoftwareTypeName

				{

			public:

				TLocalizedSoftwareTypeName()

				:iLocale(0)

				{}

				int iLocale;

				std::wstring iName;

				};

			std::wstring iUniqueSoftwareTypeName;

			std::vector<TLocalizedSoftwareTypeName> iLocalizedSoftwareTypeNames;

			int iSifPluginUid;

			std::vector<std::wstring> iMIMEDetails;

	class TScrPreProvisionDetail

		{

	public:

		TScrPreProvisionDetail()

		{}

		class TComponentLocalizable

			{

		public:

			TComponentLocalizable()

			:iLocale(0)

			{}

			int iLocale;

			std::wstring iName;

			std::wstring iVendor;

		class TComponentProperty

			{

		public:

			TComponentProperty()

			:iLocale(0),

			iIsIntValue(false),

			iIsStr8Bit(false)

			{}

			std::wstring iName;

			int iLocale;

			std::wstring iValue;

			bool iIsIntValue;

			int iIsStr8Bit;

		class TComponentDependency

			{

		public:

			class TComponentDependencyDetail

				{

					std::wstring iSupplierId;

					std::wstring iFromVersion;

					std::wstring iToVersion;

				std::wstring iDependentId;

				std::vector<TComponentDependencyDetail>	iComponentDependencyList;

		class TComponentFile

			{

			public:

			TComponentFile()

			{}

			struct TFileProperty

				{	

			public:

				TFileProperty()

				:iIsIntValue(false)

				{}

				std::wstring iName;

				std::wstring iValue;

				bool iIsIntValue;

			std::wstring iLocation;

			std::vector<TFileProperty> iFileProperties;

		class TComponentDetails

			{

			public:

			TComponentDetails()

			iSize(0),

			iScomoState(1),

			iOriginVerified(1),

			iIsHidden(0)

			{}

			class TVersion

				{

			public:

				TVersion()

				{}

			public:

				std::wstring iMajor;

				std::wstring iMinor;

				std::wstring iBuild;

			int iIsRemovable;

			int iScomoState;

			std::wstring iGlobalId;

			TVersion iVersion;

			int iOriginVerified;

			int iIsHidden;

			};

		class TComponent

			{

			public:

			TComponent()

			:iComponentDetails()

			{}

			std::vector<TComponentLocalizable>	iComponentLocalizables;

			std::vector<TComponentProperty>		iComponentProperties;

			std::vector<TComponentFile>			iComponentFiles;

			TComponentDependency iComponentDependency;

			TComponentDetails iComponentDetails;

		std::wstring iSoftwareTypeName;

		std::vector<TComponent> iComponents;

}

class CScrXmlParser

	{

	public:

		/**

		 * Initializes the xml parser and logging feature based on supplied logging parameters.

		 */

		DllExport CScrXmlParser();

		/**

		 * Frees allocated memory.

		 */

		DllExport ~CScrXmlParser();

		/**

		 * Retrieves the database schema for database creation, from the supplied database file. 

		 */

		DllExport std::vector<std::string>* ParseDbSchema(const std::string& aDbFile);

		/**

		 * Retrieves software environment details, from the supplied xml file. 

		 */

		DllExport std::vector<XmlDetails::TScrEnvironmentDetails>* GetEnvironmentDetails(const std::string aEnvDetailFile );

		XmlDetails::TScrPreProvisionDetail GetPreProvisionDetails( const std::string aPreProvisionFile );

	private:

		/**

		 * Called while retrieving s/w environment details. 

		 */

		XmlDetails::TScrEnvironmentDetails GetEnvironmentData( const XERCES_CPP_NAMESPACE::DOMElement* aDOMElement);

		XmlDetails::TScrPreProvisionDetail::TComponent GetPreProvisionData( const XERCES_CPP_NAMESPACE::DOMElement* aDOMElement);

		XmlDetails::TScrPreProvisionDetail::TComponentLocalizable GetComponentLocalizable( const XERCES_CPP_NAMESPACE::DOMElement* aDOMElement);

		XmlDetails::TScrPreProvisionDetail::TComponentProperty GetComponentProperty( const XERCES_CPP_NAMESPACE::DOMElement* aDOMElement);

		XmlDetails::TScrPreProvisionDetail::TComponentFile GetComponentFile( const XERCES_CPP_NAMESPACE::DOMElement* aDOMElement);

		XmlDetails::TScrPreProvisionDetail::TComponentDependency GetComponentDependency( const XERCES_CPP_NAMESPACE::DOMElement* aDOMElement);

		XmlDetails::TScrPreProvisionDetail::TComponentFile::TFileProperty GetFileProperty( const XERCES_CPP_NAMESPACE::DOMElement* aDOMElement);

		XmlDetails::TScrPreProvisionDetail::TComponentDetails GetComponentDetails( const XERCES_CPP_NAMESPACE::DOMElement* aDOMElement);

		XmlDetails::TScrEnvironmentDetails::TLocalizedSoftwareTypeName GetLocalizedSoftwareTypeName( const XERCES_CPP_NAMESPACE::DOMElement* aDOMElement);

		void ConfigDomParser(xercesc::XercesDOMParser& aDomParser);

	};

XERCES_CPP_NAMESPACE_BEGIN

/**

 * 

 * SchemaErrorHandler - Implementation of the error handler for xml schema validation.

 *						The parser used, implements this customized error handling interface.

 *						This has been registered with the xml parser in the constructor. The parser 

 *						reports all errors and warnings through this interface.

 */

class SchemaErrorHandler : public ErrorHandler

	{

	public:

		/**

		 * Handles all warnings received while xml parsing. 

		 */

		void warning (const SAXParseException &exc);

		/**

		 * Handles all errors received while xml parsing. 

		 */

		void error (const SAXParseException &exc);

		/**

		 * Handles all fatal errors received while xml parsing. 

		 */

		void fatalError (const SAXParseException &exc);

		/**

		 * Called if an error occurs while reintializing the current xml handler. 

		 */

		void resetErrors ();

	};

XERCES_CPP_NAMESPACE_END

#endif // _XMLPARSER_H