Subversion Repositories sqmusic

/*

  (c) Jose Tejada Gomez, 9th May 2013

  You can use this file following the GNU GENERAL PUBLIC LICENSE version 3

  Read the details of the license in:

  http://www.gnu.org/licenses/gpl.txt

  Send comments to: jose.tejada at ieee.org

*/

#include <string>

#include <vector>

#include <algorithm>

#include <cstdlib>

#include <iostream>

typedef std::vector<struct argument_t*> arg_vector_t;

struct argument_t {

protected:

        int imin, imax;

        float fmin, fmax;

        bool limits;

        template<typename A> bool pass( A a, A b, A x ) { return x>=a && x<=b; }

public:

  std::string short_name, long_name;

  typedef enum { integer, text, flag, real } arg_type;

  arg_type type;

  std::string description;

  // possible states

  int integer_value;

  std::string string_value;

  float real_value;

  bool state, req;

        bool parse_hex;

  argument_t( arg_vector_t& av, const char* long_name, arg_type type,

    const char* desc="", bool required=false )

    : long_name(long_name), type( type ), description( desc ),

      req(required), state(false), integer_value(0), real_value(0),

                        parse_hex(false), limits(false)

  {

    if( !this->long_name.empty() ) {

      this->short_name = "-" + this->long_name.substr(0,1);

      this->long_name = "--" + this->long_name;

    }

    av.push_back(this);

  }

  void set() { state=true; }

  bool is_set() { return state; }

        // range control

        void setlimits( int min, int max ) {

                if( type == integer ) {

                        imin = min;

                        imax = max;

                        limits = true;

                }

                else if( type == real ) {

                        fmin = (float) min;

                        fmax = (float) max;

                        limits = true;

                }

                else throw "Cannot apply integer limits to this type of input argument";

        }

        void setlimits( float min, float max ) {

                if( type == real ) {

                        fmin = min;

                        fmax = max;

                        limits = true;

                }

                else throw "Cannot apply real limits to this type of input argument";

        }

        bool passlimits() {

                if( !limits ) return true;

                if( type == real ) return pass( fmin, fmax, real_value );

                else if ( type == integer ) return pass( imin, imax, integer_value );

                return false;

        }

};

class Args {

  arg_vector_t& legal_args;

  argument_t* def_arg;

  std::string program_name;

  argument_t help_arg;

  void clean_args() {

    for( int j=0; j<legal_args.size(); j++ ) {

      argument_t& a = *legal_args[j];

      if( a.short_name=="-h" && a.long_name!="help" )

        { help_arg.short_name.clear(); break; } // remove -h for help if already used

    }

  }

  void throw_error( std::string x ) /*throw const char**/ { throw x.c_str(); }

public:

  Args( int argc, char *argv[], arg_vector_t& legal_args ) //throw const char *

  : legal_args( legal_args ),

    help_arg( legal_args, "help", argument_t::flag, "Display usage information")

  {

    clean_args(); // eliminate duplicated values

    // look for default argument

    def_arg=NULL;

    for( int j=0; j<legal_args.size(); j++ ) {

      if ( legal_args[j]->short_name.empty() && legal_args[j]->long_name.empty() )

        if( def_arg==NULL ) def_arg = legal_args[j];

        else throw "Cannot set more than one default argument.";

    }

    if( def_arg && def_arg->type!=argument_t::integer && def_arg->type!=argument_t::text )

      throw "Default arguments can only be integer or text";

    program_name = argv[0];

    for( int k=1; k<argc; k++ ) {

      bool matched=false;

      for( int j=0; j<legal_args.size(); j++ ) {

        argument_t& a = *legal_args[j];

        if( a.long_name==argv[k] || a.short_name==argv[k] ) {

          if( a.type == argument_t::flag ) { a.set(); matched=true; continue; }

          if( a.type == argument_t::text ) {

            k++;

            if( k>=argc ) throw_error("Expecting input after "+a.long_name+" param");

            a.string_value = argv[k];

            a.set();

            matched=true;

            continue;

          }

          if( a.type == argument_t::integer ) {

            k++;

            if( k>=argc ) throw_error("Expecting input after "+a.long_name+" param");

                                                if( !a.parse_hex )

                    a.integer_value = atoi(argv[k]);

                                                else {

                                                        errno = 0;

                                                        a.integer_value = strtol( argv[k], NULL, 16 );

                                                        if( errno ) throw "Cannot parse hexadecimal argument";

                                                }

                                                if( !a.passlimits() ) throw_error("Argument "+a.long_name+" is not within its allowed range");

            a.set();

            matched=true;

            continue;

          }

          if( a.type == argument_t::real ) {

            k++;

            if( k>=argc ) throw_error("Expecting input after "+a.long_name+" param");

            a.real_value = atof(argv[k]);

                                                if( !a.passlimits() ) throw_error("Argument "+a.long_name+" is not within its allowed range");

            a.set();

            matched=true;

            continue;

          }

        }

      }

      if( !matched && def_arg!=NULL )

        if( def_arg->state )

          throw_error( "Unknown parameter " + std::string(argv[k] ));

        else {

          if( def_arg->type==argument_t::integer ) def_arg->integer_value=atoi(argv[k]);

          if( def_arg->type==argument_t::text ) def_arg->string_value=argv[k];

          def_arg->set();

        }

    }

    if( help_arg.is_set() ) return; // do not perform more checks

    // check that all required parameters are present

    for( int j=0; j<legal_args.size(); j++ ) {

      argument_t& a = *legal_args[j];

      if( a.req && !a.state ) {

        std::string pname;

        if( !a.long_name.empty() ) pname=a.long_name;

        else if( !a.short_name.empty() ) pname=a.short_name;

        throw_error("Parameter "+pname+" is required.");

      }

    }

  }

  void check_ilegal_combinations( arg_vector_t& ilegal ) {

    int count=0;

    std::string names;

    for( int k=0; k < ilegal.size(); k++ )

      if( ilegal[k]->is_set() ) { count++; names += " " + ilegal[k]->long_name; }

    if( count>1 ) throw_error( "Parameters" + names + " cannot be used together" );

  }

  bool help_request() { if( help_arg.is_set() ) show_help(); return help_arg.is_set(); }

  std::string brackets( const argument_t& a, std::string s ) {

    return a.req ?  "<"+s+">" : "["+s+"]";

  }

  void show_help() {

    std::cout << "Usage: " << program_name << " ";

    if( def_arg!=NULL )

      std::cout << brackets( *def_arg, def_arg->description.empty() ? "parameter " : def_arg->description);

    std::cout << "\n";

    for( int j=0; j<legal_args.size(); j++ ) {

      argument_t& a = *legal_args[j];

      if( a.long_name.empty() && a.long_name.empty() ) continue;

      std::cout << "\t";

      std::string aux;

      if( !a.long_name.empty() ) aux = a.long_name;

      if( !a.long_name.empty() && !a.short_name.empty() ) aux += " | ";

      if( !a.short_name.empty() ) aux+= a.short_name;

      std::cout << brackets( a, aux );

      switch( a.type ) {

        case argument_t::integer: std::cout << " followed by integer number. "; break;

        case argument_t::real   : std::cout << " followed by real number. "; break;

        case argument_t::text   : std::cout << " followed by string. "; break;

      }

      if( !a.description.empty() ) std::cout << ":  " << a.description;

      std::cout << "\n";

    }

  }

};