Arguments.h

#include <string>

namespace qtgui
{

/*
 * I go ahead and pollute my applicaton's namespace.
 * This is okay, since I am creating an application and
 * am not creating an api.  If this was an api I'd have 
 * used another inner-namespace called something like impl 
 * and then polluted that instead to keep my outter namespace
 * clean.
 */
using namespace std;

class Arguments
{
    private:

        static Arguments *m_instance;
        
        void privateSetArguments(int argc, char *args[])
        {
            /*
             * Iterate over the arguments
             * and set them 
             */
            for(int i = 1; i < argc; ++i)
            {
                //get string of the argument
                string argument(args[i]);
                
                if(m_currentArgument == NO_ARG)
                {
                    if(argument == "-aimlSchema" || 
                       argument == "-as")
                    {
                        m_currentArgument = AIML_SCHEMA;                    
                    } 
                    else if(argument == "-botSchema" ||
                            argument == "-bs")
                    {
                        m_currentArgument = BOT_SCHEMA; 
                    }
                    else if(argument == "-commonSchema" || 
                            argument == "-cs")
                    {
                        m_currentArgument = COMMON_SCHEMA;
                    }
                    else if(argument == "-configurationDirectory" || 
                            argument == "-cd")
                    {
                        m_currentArgument = CONFIGURATION;
                    }
                    else if(argument == "-aimlDirectory" || 
                            argument == "-ad")
                    {
                        m_currentArgument = AIML;   
                    }
                    else if(argument == "-resourcesDirectory" ||
                            argument == "-rd")
                    {
                        m_currentArgument = RESOURCES;
                    }
                    else if(argument == "-help" || 
                            argument == "-h" || 
                            argument == "/?" ||
                            argument == "--help")
                    {
                        /*
                         * Display help and exit
                         */
                        cout << endl << endl
                             << "[console.exe help]" << endl
                             << "------------------" << endl << endl
                             << "Available switches:" << endl << endl
                             << "[-aimlSchema or -as]" << endl 
                             << "    AIML Schema Path (default is ../../resources/schema/AIML.xsd)" << endl << endl
                             << "[-botSchema or -bs] " << endl 
                             << "    Bot Schema Path (default is ../resources/schema/bot-configuration.xsd)" << endl << endl
                             << "[-commonSchema or -cs] " << endl
                             << "    Common Schema Path (default is ../resources/schema/common-types.xsd)" << endl << endl
                             << "[-configurationDirectory or -cd] " << endl
                             << "    Configuration directory (default is ../../conf)" << endl << endl
                             << "[-aimlDirectory or -ad] " << endl
                             << "    AIML directory with *.aiml files (default is ../../aiml/annotated_alice)" << endl << endl
                             << "[-resourcesDirectory or -rd] " << endl
                             << "    AIML directory with resource files (default is ../../resources)" << endl << endl
                             << endl;
                        exit(0);
                    }
                    else
                    {
                        cout << 
                            "[Illegal argument of " +
                            string(args[i]) +
                            " found]" 
                            << endl;
                    }
                }
                else
                {
                    /*
                     * We already encountered the switch, 
                     * now we just need to set the argument
                     */
                    if(m_currentArgument == AIML)
                    {
                        m_aimlDirectory = argument;
                    }
                    else if(m_currentArgument == AIML_SCHEMA)
                    {
                        m_aimlSchemaPath = argument;
                    }
                    else if(m_currentArgument == BOT_SCHEMA)
                    {
                        m_botConfigurationSchemaPath = argument;
                    }
                    else if(m_currentArgument == COMMON_SCHEMA)
                    {
                        m_commonTypesSchemaPath = argument;
                    }
                    else if(m_currentArgument == CONFIGURATION)
                    {
                        m_configurationDirectory = argument;
                    }
                    else if(m_currentArgument == RESOURCES)
                    {
                        m_resourcesDirectory = argument;
                    }
                    else
                    {
                        cout << "Programmer error "
                                "this should not be reached"
                             << endl;
                    }

                    m_currentArgument = NO_ARG;
                }
            }
        }

        Arguments()
            : m_aimlSchemaPath("../../resources/schema/AIML.xsd"),
              m_commonTypesSchemaPath("../resources/schema/common-types.xsd"),
              m_botConfigurationSchemaPath("../resources/schema/bot-configuration.xsd"),
              m_configurationDirectory("../../conf"),
              m_aimlDirectory("../../aiml/annotated_alice"),
              m_currentArgument(NO_ARG),
              m_resourcesDirectory("../../resources")
        { }

    public:

        static void setArguments(int argc, char *args[])
        {
            if(m_instance == 0)
            {
                m_instance = new Arguments();
            }

            m_instance->privateSetArguments(argc, args); 
        }
        
        static Arguments *getInstance()
        {
            if(m_instance == 0)
            {
                m_instance = new Arguments();
            }

            return m_instance;
        }
        
        string getConfigurationDirectory() const
        {
            return m_configurationDirectory;
        }
        
        string getAimlDirectory() const
        {
            return m_aimlDirectory;
        }

        string getAimlSchemaPath() const
        {
            return m_aimlSchemaPath;
        }

        string getCommonTypesSchemaPath() const
        {
            return m_commonTypesSchemaPath;
        }

        string getBotConfigurationSchemaPath() const
        {
            return m_botConfigurationSchemaPath;
        }
        
        string getResourcesDirectory() const
        {
            return m_resourcesDirectory;
        }
        enum arguments{ NO_ARG, AIML, AIML_SCHEMA, 
                        COMMON_SCHEMA, BOT_SCHEMA,
                        RESOURCES, CONFIGURATION};
        arguments m_currentArgument;

        string m_configurationDirectory;

        string m_aimlDirectory;
        
        string m_aimlSchemaPath;

        string m_commonTypesSchemaPath;
        
        string m_botConfigurationSchemaPath;
        
        string m_resourcesDirectory;
};

} //end of qtgui namespace

---