stim/parser/arguments.h

#ifndef STIM_ARGUMENTS
#define STIM_ARGUMENTS
#include <string>
#include <vector>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <iterator>
#include <algorithm>
#ifdef _WIN32
#include <Windows.h>
#endif
namespace stim{
	class cmd_option
	{
	private:
		bool ansi;
		//argument name
		std::string name;
		//description of the argument
		std::vector<std::string> desc;
		//argument values
		std::vector<std::string> vals;
		//range or example
		std::string range;
		//flag is true when the argument is user-specified
		bool flag;
		void parse_val(const std::string &s){
			vals.clear();
			std::stringstream ss(s);
			std::string item;
			while (std::getline(ss, item, ' ')) {
				vals.push_back(item);
			}
		}
		void parse_desc(const std::string &s){
			desc.clear();
			std::stringstream ss(s);
			std::string item;
			while (std::getline(ss, item, '\n')) {
				desc.push_back(item);
			}
		}
	public:
		void set_ansi(bool b){ ansi = b; }
        //create an option with a given name, description, and default value
		cmd_option(std::string _name, std::string _desc, std::string _default = "", std::string _range = "")
		{
			name = _name;
			parse_desc(_desc);
			parse_val(_default);
			//if a default value is provided, set the flag
			if(_default != "")
                flag = true;
            else flag = false;
			range = _range;
		}
		int nargs()
		{
            return vals.size();
        }
		//return the value of a text option
		std::string as_string(unsigned int n = 0)
		{
            if(!flag)
            {
                std::cout<<"ERROR - Option requested without being set: "<<name<<std::endl;
                exit(1);
            }
            if(vals.size() > n)
                return vals[n];
            else return "";
		}
        //return the value of a floating point option
		float as_float(unsigned int n = 0)
		{
            if(!flag)
            {
                std::cout<<"ERROR - option requested without being set: "<<name<<std::endl;
                exit(1);
            }
            if(vals.size() > n)
            {
                float r;
                if ( ! (std::istringstream(vals[n]) >> r) ) r = 0;
                return r;
            }
            else return 0;
		}
		//return the value of an integer option
		int as_int(unsigned int n = 0)
		{
            if(!flag)
            {
                std::cout<<"ERROR - option requested without being set: "<<name<<std::endl;
                exit(1);
            }
            if(vals.size() > n)
            {
                int r;
                if ( ! (std::istringstream(vals[n]) >> r) ) r = 0;
                return r;
            }
            else return 0;
		}
		//get the width of the left column
		int col_width()
		{
            int n = 3;
            //add the length of the option name
            n += name.size();
            //if there are any default parameters
            if(vals.size() > 0)
            {
                //padding (parenthesis, =, etc.)
                n += 6;
                //for each default option value
                for(unsigned int v=0; v<vals.size(); v++)
                    n += vals[v].size() + 1;
            }
            //add a buffer of 4 characters
            n += 4;
            return n;
		}
		//string output
		std::string toStr(int width = 0)
		{
			std::stringstream ss;
			int color_size = 0;
			//create the left column
			std::string left_part = std::string(" --") + name;
			if(vals.size() != 0)
			{
				if(ansi)
					left_part += "\033[1;32m";
				left_part += " ( = ";
				for(unsigned int v=0; v<vals.size(); v++)
					left_part += vals[v] + std::string(" ");
				left_part += ")";
				if(ansi)
					left_part += "\033[0m";
				if(ansi)
					color_size = 11;
			}
			else
                color_size = 0;
			//if no width is passed, put 4 spaces between left and right columns
			if(width == 0) width = col_width();
			ss<<std::left<<std::setw(width + color_size)<<left_part;
			//output right column
			for(unsigned int d=0; d<desc.size(); d++)
			{
				if(d == 0)
					ss<<desc[0];
				else
					ss<<std::endl<<std::setfill(' ')<<std::setw(width)<<" "<<desc[d];
			}
			//output the range in the right column
			if(range != "" && ansi)
                ss<<std::endl<<std::setfill(' ')<<std::setw(width)<<" "<<"    "<<std::string("\033[1;36m") + range + "\033[0m";
			else if(range != "")
				ss<<std::endl<<std::setfill(' ')<<std::setw(width)<<" "<<"    "<<range;
			return ss.str();
		}
		//compare the name of the option to a string
		bool operator==(std::string rhs)
		{
            return (name == rhs);
		}
		//set the option to a given value
		void set(std::string _value)
		{
            parse_val(_value);
            //set the flag
            flag = true;
		}
		bool is_set()
		{
            return flag;
        }
	};
	struct argsection
	{
		std::string name;
		unsigned int index;
	};
    /**The arglist class implements command line arguments.
        Example:
    
        1) Create an arglist instance:
            
            stim::arglist args;
        2) Test to see if ANSI output is supported (arguments will use color if it is). Generally, Windows consoles don't support ANSI.
            #ifdef _WIN32
                args.set_ansi(false);
            #endif
        3) Add arguments:
            args.add("help", "prints this help");
            args.add("foo", "foo takes a single integer value", "", "[intval]");
            args.add("bar", "bar takes two floating point values", "", "[value1], [value2]");
        4) You generally want to immediately test for help and output available arguments:
            if(args["help"].is_set())
                std::cout<<args.str();
        5) Parse the command line:
            args.parse(argc, argv);
        6)  Retrieve values:
            int foo;
            float bar1, bar2;
            if(args["foo"])
                foo = args["foo"].as_int();
            if(args["bar"]){
                bar1 = args["bar"].as_float(0);
                bar2 = args["bar"].as_float(1);
            }
    **/
	class arglist
	{
    private:
		bool ansi;
		//vector of options
        std::vector<cmd_option> opts;
        std::vector<std::string> args;
		//column width of the longest option
        int col_width;
		//list of sections
		std::vector<argsection> sections;
    public:
        arglist(){
        	col_width = 0;
        	ansi = true;
        }
        ///Sets ANSI support (default is on), which allows colored values in the help output.
        /// @param b is a boolean value specifying ANSI support (true is on, false is off)
		void set_ansi(bool b)
		{
			ansi = b;
			for(unsigned int i=0; i<opts.size(); i++)
				opts[i].set_ansi(ansi);
		}
        ///Add a supported command line argument.
        /// @param _name is the name of the command line argument (supplied as --name)
        /// @param _desc is a text description of the argument
        /// @param _default is the default value of the argument
        /// @param _range is the supported range of values, list of values, etc. It will be displayed to the user.
        void add(std::string _name, std::string _desc, std::string _default = "", std::string _range = "")
        {
            cmd_option opt(_name, _desc, _default, _range);
			opt.set_ansi(ansi);
            opts.push_back(opt);
            col_width = std::max<int>(col_width, opt.col_width());
        }
        ///Specifies a section name that can be used to organize parameters in the output.
        /// @param _name is the name of the section, which will be displayed to the user
		void section(std::string _name)
		{
			argsection s;
			s.name = _name;
			s.index = opts.size();
			sections.push_back(s);
		}
        ///Outputs supported arguments. If ANSI support is available, they will be color-coded. Generally this is called in response to "--help"
        std::string str()
        {
            std::stringstream ss;
            int si = -1;
            if(sections.size() > 0)
                si = 0;
            //for each option
            for(unsigned int a=0; a<opts.size(); a++)
            {
                if(si != -1 && a == sections[si].index)
                {
					if(ansi)
						ss<<std::endl<<std::left<<std::setfill('=')<<std::setw(col_width)<<std::string("\033[1;31m") + sections[si].name<<"\033[0m"<<std::endl;
					else
						ss<<std::endl<<std::left<<std::setfill('=')<<std::setw(col_width)<<sections[si].name<<std::endl;
                    si++;
                    if(si == (int)sections.size()) si = -1;
                }
                ss<<opts[a].toStr(col_width)<<std::endl;
            }
            return ss.str();
        }
        ///Retrieves the index for a supported argument, given that argument's name.
        /// @param _name is the name of the requested argument
        int index(std::string _name)
        {
        	unsigned int i = find(opts.begin(), opts.end(), _name) - opts.begin();
            if(i >= opts.size())
                return -1;
            return (int)i;
        }
        ///Sets an argument to a specified value
        /// @param _name is the name of the argument to be set
        /// @param _value is the value that it is given
        void set(std::string _name, std::string _value)
        {
            int i = index(_name);
            if(i != -1)
            {
            	opts[i].set(_value);
                //adjust the column width if necessary
                col_width = (std::max)(col_width, opts[i].col_width());
            }
            else
                std::cout<<"ERROR - option not recognized: "<<_name<<std::endl;
        }
        ///Parses the command line
        /// @param argc is the number of command line arguments (provided by the OS)
        /// @param argv[] is the list of command line arguments (provided by the OS)
        void parse(int argc, char* argv[])
        {
            //if the number of options is 1, we're done
            if(argc <= 1) return;
            std::string name;
            std::string params;
            bool args_done = false;		//create a flag that turns true when the first option is encountered
            for(int i=1; i<argc; i++)
            {
                //if the argument is an option
                if(argv[i][0] == '-' && argv[i][1] == '-')
                {
                	args_done = true;				//arguments for the executable are done, all options now
                    //add any previous options
                    if(name != "")
                        set(name, params);
                    //set the current option to this name
                    name = argv[i]+2;
                    //clear the parameters list
                    params = "";
                }
                else if(!args_done){
                	args.push_back(argv[i]);
                }
                else{	//everything else is an arg for the most recent option
					if(params != "")
						params += " ";
                    params += argv[i];
                }
            }
            //set the last option
            set(name, params);
        }
        ///Determines of a parameter has been set and returns true if it has
        /// @param _name is the name of the argument
        bool operator()(std::string _name)
        {
            int i = find(opts.begin(), opts.end(), _name) - opts.begin();
            if(i < 0)
            {
                std::cout<<"ERROR - Unspecified parameter name: "<<_name<<std::endl;
                exit(1);
            }
            return opts[i].is_set();
        }
        ///Returns the number of parameters for a specified argument
        /// @param _name is the name of the argument whose parameter number will be returned
        unsigned int nargs(std::string _name)
        {
            int i = find(opts.begin(), opts.end(), _name) - opts.begin();
            if(i < 0)
            {
                std::cout<<"ERROR - Unspecified parameter name: "<<_name<<std::endl;
                exit(1);
            }
            return opts[i].nargs();
        }
        ///Returns the number of arguments that have been set
        unsigned int nargs(){
        	return args.size();
        }
        ///Returns the name of an argument, given its index
        /// @param a is the index of the requested argument
        std::string arg(unsigned int a){
        	return args[a];
        }
        ///Returns an object describing the argument
        /// @param _name is the name of the requested argument
        cmd_option operator[](std::string _name)
        {
            int i = find(opts.begin(), opts.end(), _name) - opts.begin();
            if(i < 0 || i >= opts.size())
            {
                std::cout<<"ERROR - Unspecified parameter name: "<<_name<<std::endl;
                exit(1);
            }
            return opts[i];
        }
	};
}	//end namespace stim
#endif