/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

*

*/

#ifndef CDLTKUTIL_H

#define CDLTKUTIL_H

#pragma warning (disable:4786)	// disable "identifier was truncated to '255' characters in the browser information" warning

#include <string>

#include <iosfwd>

#include <vector>

#include <CdlDef.h>

namespace CdlCompilerToolkit {

class CCdlTkFileCleanup;

/**

* This is a collection of utility functions that the CDL compiler toolkit uses

* and which may be of use to other tools based on this toolkit

*/

class CdlTkUtil

	{

private:

	typedef std::pair<std::string, std::string> CReplaceTerm;

public:

	/**

    * Gives the current working drive

    * @return the drive as a "X:" string.

    */

	static std::string CurrentDrive();

	/**

    * Gives the current working directory, without drive

    * @return the current working directory

    */

	static std::string CurrentDir();

	/**

    * Gives the current output path for generated files

    * @return the output path

    */

	static std::string OutputPath();

	/**

    * Sets the curreent output path for generated files

    * @param aPath the output path for generated files

    */

	static void SetOutputPath(const std::string& aPath);

	/**

    * Gives the command line used to run the tool using this toolkit

    * @return the command line, will be empty if SetCommandLine() is not called

    */

	static std::string CommandLine();

	/**

    * Sets the command line for the tool using this toolkit.

    */

	static void SetCommandLine(int argc, char* argv[]);

	/**

    * Extract an int from the string. This function automatically detects

	* bases 8, 10 and 16.

    * @param aInt a string containing an integer

    * @return the integer value parsed

    */

	static int ParseInt(const std::string& aInt);

	/**

    * Formats an integer as a string

    * @param aInt the integer to format

    * @return a string representing the integer in base 10

    */

	static std::string IntToString(int aInt);

	/**

    * Formats an integer as a hex string

    * @param aInt the integer to format

    * @return a string representing the integer in base 16

    */

	static std::string IntToHexString(int aInt);

	/**

    * Formats a short integer as a hex string

    * @param aInt the integer to format

    * @return a string representing the integer in base 16

    */

	static std::string ShortToHexString(short aInt);

	/**

    * Formats an 8-bit integer as a hex string

    * @param aInt the integer to format

    * @return a string representing the integer in base 16

    */

	static std::string CharToHexString(char aInt);

	/**

    * Converts a string to lower case

    * @param aString the string to convert

    * @return a version of the string in lower case

    */

	static std::string ToLower(const std::string& aString);

	/**

    * Converts a string to upper case

    * @param aString the string to convert

    * @return a version of the string in upper case

    */

	static std::string ToUpper(const std::string& aString);

	/**

    * Converts a string to C++ identifier format. Characters which are not

	* valid C++ identifier characters are replaced with an underscore. If the

	* string starts with a number or is empty, an underscore is added to the start.

    * @param aString a string to convert to a C++ identifier

    * @return the converted string

    */

	static std::string ToCpp(const std::string& aString);

	/**

    * Strips white-space from the start and end of the string

    * @param aStr the string from which white space should be removed

    */

	static void StripLeadingAndTrailingWhitespace(std::string& aStr);

	/**

    * Is the character alphabetic?

    * @param aChar the character to test

    * @return true if the character is alphabetic

    */

	static bool IsAlpha(char aChar);

	/**

    * Is the character numeric?

    * @param aChar the character to test

    * @return true if the character is numeric

    */

	static bool IsNumeric(char aChar);

	/**

    * Is the character valid for a C++ identifier?

    * @param aChar the character to test

    * @return true if the character is valid for a C++ identifier

    */

	static bool IsCpp(char aChar);

    /**

     * Is the character equal to '\\' or '/' ? 

     * @param aChar the character to test

     * @return true if the character is a path separator

     */

	static bool IsPathSeparator(char aChar);

	static std::string::size_type FindFirstPathSeparator(const std::string& s);

	static std::string::size_type FindLastPathSeparator(const std::string& s);

	/**

    * This class contains a set of terms to replace in a string. It is used

	* with CdlTkUtil::MultiReplace().

    */

	class CReplaceSet : public std::vector<CReplaceTerm>

		{

	public:

		void Add(const std::string& aTarget, const std::string& aWith);

		};

	/**

    * Replace a set of targets with other text in a string and return the result.

    * @param aSet the set of pairs of targets and replacement text

	* @param aIn the string to replace text in

    * @return The result of the replacement

    */

	static std::string MultiReplace(const CReplaceSet& aSet, const std::string& aIn);

	/**

    * Replace a target in a string with some text and return the result.

    * @param aTarget the text to replace

    * @param aWith the text that replaces aTarget

    * @param aIn the string in which to replace the text

    * @return the result of the replacement

    */

	static std::string Replace(const std::string& aTarget, const std::string& aWith, const std::string& aIn);

	/**

    * Add a string to another. This function uses exponential growth of the target

	* string to reduce average runtime for long sequences of appends to O(n log(n)).

    * @param aTarget the string to which text is to be appended

	* @param aAppend the text to append

   */

	static void AppendString(std::string& aTarget, const std::string& aAppend);

	/**

    * Remove and path components from a file name and path, and return the file name.

    * @param aPath the path and filename

    * @return the filename component of the path and filename passed in.

    */

	static std::string StripPath(const std::string& aPath);

	/**

    * Resolves a filename relative to a path, and returns the resulting resolved path

    * @param aPath the path to which a relative filename is to be calculated

	* @param aFileName the filename, possibly including relative path components

	* such as . and .. which should be resolved.

    * @return the resolved path and filename

    */

	static std::string ResolvePath(const std::string& aPath, const std::string& aFileName);

	/**

    * Converts a filename and path so that first letter of file name is capitalized

	* and the rest is lower case

    * @param aString the string to convert

    * @return the converted filename and path

    */

	static std::string CapitalizeFilename(const std::string& aString);

	/**

    * Converts a filename and path to use the current standard for file name case

    * @param aString the string to convert

    * @return the converted filename and path

    */

	static std::string CorrectFilenameCase(const std::string& aString);

	/**

    * Opens a temporary output file, with a temporary file name.

	* This function is normally used in conjunction with ExportFile() to ensure

	* that files are only modified if they are changed.

    * @param aStream the output stream to open

	* @param aFile a file cleanup object which will contain the temporary file name

	* and will remove the file on destruction

    */

	static void OpenTempOutput(std::ofstream& aStream, CCdlTkFileCleanup& aFile, std::ios_base::openmode aOpenMode = std::ios_base::out);

	/**

    * Opens an output file, throwing a CdlTkFileOpenErr exception if it fails.

    * @param aStream the stream to open

	* @param aFileName the name of the file to open

    */

	static void OpenOutput(std::ofstream& aStream, const std::string& aFileName, std::ios_base::openmode aOpenMode = std::ios_base::out);

	/**

    * Opens an input file, throwing a CdlTkFileOpenErr exception if it fails.

    * @param aStream the stream to open

	* @param aFileName the name of the file to open

    */

	static void OpenInput(std::ifstream& aStream, const std::string& aFileName, std::ios_base::openmode aOpenMode = std::ios_base::in);

	/**

    * Compares the source file with the destination. If they differ,

	* it replaces the destination file with the source. The source file is removed.

	* This function will throw a CdlTkFileOpenErr if the destination file

	* is not writable. This function should be used when the destination file

	* should not be modified manually.

    * @param aSourceFile the temporary source file.

    * @param aDestinationFileName the name of the destination file.

    */

	static void ExportFile(CCdlTkFileCleanup& aSourceFile, const std::string& aDestinationFileName, std::ios_base::openmode aOpenMode = 0);

	/**

    * Compares the source file with the destination. If they differ,

	* it replaces the destination file with the source. The source file is removed.

	* This function will report an error to the standard error stream if the

	* destination file is not writable. This function should be used when the

	* destination file may be modified manually, and may be under source control.

    * @param aSourceFile the temporary source file.

    * @param aDestinationFileName the name of the destination file.

    */

	static void ExportFileIfWritable(CCdlTkFileCleanup& aSourceFile, const std::string& aDestinationFileName, std::ios_base::openmode aOpenMode = 0);

	/**

    * Delete a file

    * @param aFileName the name of the file to be deleted

    */

	static void DeleteFile(const std::string& aFileName);

	/**

    * Copies a file

    * @param aSourceFileName the source file.

    * @param aDestinationFileName the destination file.

    */

	static void CopyFile(const std::string& aSourceFileName, const std::string& aDestinationFileName, std::ios_base::openmode aOpenMode = 0);

	/**

    * Checks to see if two files are identical

    * @param aLeftFileName one of the files to check

    * @param aRightFileName the other file to check

    */

	static bool FilesAreIdentical(const std::string& aLeftFileName, const std::string& aRightFileName, std::ios_base::openmode aOpenMode = std::ios_base::in);

	static void ReadFile(std::string& aContent, const std::string& aFileName);

	static void WriteFile(const std::string& aContent, const std::string& aFileName);

	template <class OutputIterator>

	inline static void Tokenize(const std::string& aString, OutputIterator pOut)

		{

		const std::string ws(" \t\r\n");

		std::string::const_iterator pChar = aString.begin();

		std::string::const_iterator pWord = pChar;

		for (; ; ++pChar)

			{

			  if (pChar == aString.end() || ws.find_first_of(*pChar) != std::string::npos)

				{

				if (pWord != pChar)

					{

					*pOut = std::string(pWord, pChar);

					pOut++;

					}

				pWord = pChar+1;

				if (pChar == aString.end())

					break;

				}

			}

		}

	};

/**

* This is the base class for all CDL Compiler Toolkit exceptions

*/

class CdlCompilerToolkitErr

	{

public:

	/**

    * destructor

    */

	virtual ~CdlCompilerToolkitErr();

	/**

    * virtual method for describing the exception on a stream

    * @param stream the output stream for the exceptions description

    */

	virtual void Show(std::ostream& stream) const = 0;

	};

/**

* This exception class is thrown for general assertions

*/

class CdlTkAssert : public CdlCompilerToolkitErr

	{

public:

	/**

    * constructor for a general assertion exception

    * @param aText the assertion description

    */

	CdlTkAssert(const std::string& aText);

	/**

    * virtual method for describing the exception on a stream

    * @param stream the output stream for the exceptions description

    */

	void Show(std::ostream& stream) const;

private:

	std::string iText;

	};

/**

* This exception class is thrown for errors in opening a file

*/

class CdlTkFileOpenErr : public CdlCompilerToolkitErr

	{

public:

	/**

    * constructor for a file open exception

    * @param aFileName the file that has failed to open

    */

	CdlTkFileOpenErr(const std::string& aFileName);

	/**

    * virtual method for describing the exception on a stream

    * @param stream the output stream for the exceptions description

    */

	void Show(std::ostream& aStream) const;

private:

	std::string iFileName;

	};

/**

* This class represents a temporary file. If an instance is destroyed, it will

* delete the filename it has been given.

*/

class CCdlTkFileCleanup

	{

public:

	/**

    * default constructor

    */

	CCdlTkFileCleanup();

	/**

    * constructor which sets the filename for the temporary file

    * @param aName the name for the file to be cleaned up

    */

	CCdlTkFileCleanup(const std::string& aName);

	/**

    * destructor

	* This will delete the temporary file, if a filename has been set.

    */

	~CCdlTkFileCleanup();

	/**

    * Set the filename of the temporary file.

    * @param aName the filename of the temporary file.

    */

	void Set(const std::string& aName);

	/**

    * Gets the filename of the temporary file.

    * @return the filename.

    */

	std::string Name() const;

	/**

    * Deletes the temporary file and resets the filename.

    */

	void Cleanup();

	/**

    * Resets the filename so that no file will be deleted.

    */

	void Release();

private:

	std::string iName;

	};

}	// end of namespace CdlCompilerToolkit

#endif