/*

* 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 "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 __COMMAND_LINE_H__

#define __COMMAND_LINE_H__

#include "CmdGlobals.h"

#ifdef __WIN__

#pragma warning(disable:4786)

#endif

#include <string>

#include <map>

#include <set>

using namespace std;

typedef pair<string, string> mapentry;

/**

* The class CommandLine handles the command line parsing and represents

* the options for the program in an easy way.

*/

class CommandLine {

// constructors & destructors

public:

    /**

    * Constructor

    */

    CommandLine();

    /**

    * Constructor

    * @param args commanline argument as pointer to string

    * @param argc argument count

    */

    CommandLine(char** args, int argc);

    /**

    * Destructor

    */

    ~CommandLine();

// public methods

public:

    /**

    * Returns the parameter value for a given parameter.

    *

    * @param parm parameter to get

    * @return parameter value

    * @exception throw an exception if illegal parameter is requested.

    */ 

    string getParameter(string parm);

    /**

    * Get parameters

    * @return map of parameters

    */ 

    const map <string, string>& getParameters();

    /**

    * Check if the asked parameter is given

    * @param parm parameter name

    * @return true if the asked parameter is given

    */ 

    bool parameterExists(const string& parm);

    /**

    * Validate parameters. Returns a string containing mismatching/insufficiently

    * specified parameters if there are any mismatches. Otherwise returns a string 

    * of zero length.

    * @return error string consisting of invalid parameters.

    */ 

    string  validateParameters();

    /**

    * Check if the given parameter value is valid

    * @param parm parameter to check

    * @param val parameter value to check

    */ 

    void validParamValue(string parm, string val);

// private methods

private:

    /**

    * Inserts a parameter into parameter validation lists.

    * This is *NOT* the same as storeParameter, which stores

    * the actual parameter value of a command line parm.

    *

    * Parameter to be inserted can require a specifier/no 

    * specifier, and can be optional/mandatory

    *

    * @param parmname name of the paramter to insert

    * @param specifierRequired if required, this true

    * @param optional true if parameter is optional

    */ 

    void insertParameter(string parmname, bool specifierRequired, bool optional = true);

    /**

    * Initialize  acceptable parameters list

    *

    * Define which parameters are valid and which additionally require a string 

    * after them (dir etc), and which are mandatory (ie. modal, ie. non-optional)

    * Also assign the initial values for epocroot directories.

    *

    * See documentation for exact meaning of each parameter.

    */ 

    void initializeAcceptableParametersList();

    /**

    * Stores a parameter. Actual functionality depends on parameter type

    * (was it a command-line parameter [overrides environmental variables and

    * command file variables], a command-file parameter [overrides environmental

    * variables] or an environmental variable)

    * In other words, it's not possible for a command-file parameter or

    * an environment variable to replace any parameter that has been

    * specified on command-line; respectively, command-line argument

    * will always override any other type of argument, no matter where it

    * was earlier defined.

    *

    * Throws an exception if no specifier is given to a parameter that

    * requires one (e.g. -baselinedir requires a specifier [directory],

    * whereas -recursive doesn't)

    *

    * @param parm parameter to store

    * @param val parameter value to store

    * @param parmtype commandline or commandfile

    * @exception an exeption is thrown if no specifier is given to a parameter 

    * that requires one (e.g. -baselinedir requires a specifier [directory],

    * whereas -recursive doesn't) 

    */ 

    void storeParameter(string parm, string val, int parmtype = EParmCommandLine);

    /**

    * Parses the command line parameters and stores them to public instance 

    * variables. 

    * @param params list of params

    * @param count count params

    * @param parmtype defaulttype=EParmCommandLine

    */ 

    void parse(char** params, size_t count, int parmtype = EParmCommandLine);

    /**

    * Show commandline options and exit programe

    * Not enough options are given, so options list is shown and 

    * the program is exited

    */ 

    void showCommandLineOptionsAndExit();

// Private instance variables

private:

    //! All the parameters that the program accepts

    map <string, string>    iAcceptableParameterMap;

    //! Map of parameters

    map <string, string>    iParameterMap;

    //! These command line parameters require option

    set <string>            parameterSpecifierSet;

    //! These command line parameters are required

    set <string>            requiredParametersSet;

    //! True if the parameters are valid

    int                     iParametersValid;

    //! Command line arguments

    char**                  iArgList;

    //! Count of command line arguments

    int                     iArgCount;

};

#endif