CommandLine.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_core_util_CommandLine_hpp
#define anna_core_util_CommandLine_hpp

#include <stdlib.h>

#include <vector>

#include <anna/core/functions.hpp>
#include <anna/core/Singleton.hpp>

namespace anna {

class RuntimeException;

namespace xml {
class Node;
}


class CommandLine : public Singleton <CommandLine> {

  /* returns first no-leading hyphen position; -1 is error */
  static int removeLeadingHyphens(std::string &argv) ;

public:
  struct Argument { enum Type { Mandatory = 0, Optional};  };

  // Accesores
  const char** getArgv() const { return a_argv; }

  int getArgc() const { return a_argc; }

  //
  // Metodos
  //
  void initialize(const char** argv, const int argc, int positionalArguments = 0) noexcept(false);

  void add(const char* argumentExpression, Argument::Type type, const char* comment, const bool needValue = true) ;

  const char *getPositional(int position) const {
    const char *result = NULL;
    if ((position > 0) && (position <= a_positionalArguments)) result = a_argv[position];
    return result;
  }

  const char* getValue(const char* argumentExpression, const bool exitOnFault = true) ;

  int getIntegerValue(const char* argumentExpression) { return atoi(getValue(argumentExpression)); }

  bool exists(const char* argumentExpression) { return (getValue(argumentExpression, false) != NULL) ? true : false; }

  void verify() noexcept(false);


  std::string asString() const ;

  xml::Node* asXML(xml::Node* parent) const ;


private:
  Mutex a_mutex;

  class Variable {
  public:
    // Constructors
    Variable(const std::string &name1, const std::string &name2, const Argument::Type type, const char* comment, const bool needValue = true) :
      a_name1(name1), a_name2(name2), a_type(type), a_comment(comment), a_needValue(needValue), a_isOn(false), a_value(NULL) {
    }
    virtual ~Variable() { if(a_value) free(a_value); }

    // Accesores
    const std::string& getName1() const { return a_name1; }
    const std::string& getName2() const { return a_name2; }
    std::string getHelpExpression() const ;
    const char* getValue() const { return a_value; }
    const char* getComment() const { return a_comment; }
    bool getNeedValue() const { return a_needValue; }
    bool getIsOn() const { return a_isOn; }
    Argument::Type getType() const { return a_type; }

    // Modificadores
    void setValue(const char* value) { a_value = (value == NULL) ? NULL : strdup(value); }
    void setIsOn(const bool isOn) { a_isOn = isOn; }

    // Metodos
    std::string asString() const ;

  protected:
    std::string a_name1, a_name2;
    Argument::Type a_type;
    const char* a_comment;
    bool a_needValue;
    bool a_isOn;
    char* a_value;
  };

  const char **a_argv;
  int a_argc;
  bool a_wasParsed;
  std::vector <Variable*> a_arguments;
  int a_positionalArguments;

  CommandLine() : a_argv(NULL), a_argc(0), a_positionalArguments(0)  {;}

  bool analize() ;
  const Variable* search(const char *argumentExpression) const ;
  void printUsage() const ;

  friend class Singleton <CommandLine>;
};

}

#endif