argument.cpp

#include "argument.h"

namespace n2nc {
namespace utils {
namespace args {

Argument::Argument(string name,string param) : m_validarg(NULL) {
  this->m_name = name ;
  this->m_param = param ;
}
Argument::~Argument(){}

bool Argument::validate(std::vector< ValidArgument >& validargs) throw(  ){
  for(int i=0; i < validargs.size() ; i++){
    /* for each valid arg */
    if(this->m_name == validargs[i].name){
      this->m_validarg = &validargs[i] ;  //FIXME is valid ?
      //now check if it expects a parameter
      if(this->m_validarg->paramlist.size() || this->m_validarg->paramlist_pattern.size()){
        /* check parameters */
        if(this->m_param.empty()){
          
          if(this->m_validarg->paramrequired){  /* ERROR param required */cerr << "param required" << endl ; return false ;}
          // set default
          cerr << "assuming default param: " << this->m_validarg->defaultparam << endl ;
          this->m_param = this->m_validarg->defaultparam ;
          return true ;
        }else{
          for(int p=0; p < this->m_validarg->paramlist.size() ; p++){
            if(this->m_param == this->m_validarg->paramlist[p] ){
              //Ok valid param
              return true ;
            }
          }
          // FIXME pattern match
          for(int p=0; p < this->m_validarg->paramlist_pattern.size() ; p++){
            switch (this->m_validarg->paramlist_pattern[p].c_str()[0]){
              case 'd' :
                if (::strtol(this->m_param.c_str(),NULL,10) && errno != EINVAL) return true ;
                break ;
              
              case 's' :
                if (::strlen(this->m_param.c_str())) return true ;
                break ;
            
            }
          }

          // error paramatere is invalid.
          cerr << "param invalid" << endl ;
          return false ;
        }
      }else{
        if(this->m_param.size()){
          //Error this param is not expected here
          cerr << "param unexpected here" << endl ;
          return false ;
        }
        return true ;
      }
    }
  }
  /* No argument name match */
  cerr << "argument name: \"" << this->m_name << "\" unexpected here" << endl ;
  return false ;
}

bool Argument::checkForDependecies(vector<Argument>& args){
  int checkeddep = 0;
  
  if (!this->m_validarg->dependsof.size()){return true ;}
  
  for(int d=0; d < this->m_validarg->dependsof.size() ; d++){
    for (int i=0; i < args.size(); i++){
      if ( this->m_validarg->dependsof[d] == args[i].m_name ){
        checkeddep++;
      }
    }
  }
  
  if(this->m_validarg->dependsof.size() != checkeddep){
    if(this->m_validarg->dependsof.size() <= checkeddep){
      cerr << "Dependencies problem: maybe a duplicate argument?" << endl ;
      return false ;
//       throw new ArgumentException("Dependencies problem: maybe a duplicate argument?");
    }
    cerr << "Dependencies problem: following arguments must appears: {"
         << explode(this->m_validarg->dependsof,", ") <<  "}" << endl ;
    return false ;
/*    throw new ArgumentException("Dependencies problem: following arguments must appears: {" + 
                                explode(m_validarg.dependsof,", ")+ "}" );*/
  }
  return  (this->m_validarg->dependsof.size() == checkeddep );
}

bool Argument::checkForConflicts(vector<Argument>& args){
  int checkedconf = 0;
  
  if (! this->m_validarg->conflictsto.size() ){return true ;}
  
  for(int d=0; d < this->m_validarg->conflictsto.size() ; d++){
  
    for (int i=0; i < args.size() ; i++){
      if ( this->m_validarg->conflictsto[d] == args[i].m_name ){
        checkedconf++;
        cerr << "Conflicts problem: \"" << args[i].m_name <<
                        "\" conflicts with \"" << this->m_name << "\"" << endl ;
        return false ;
/*        throw new ArgumentException("Conflicts problem: \""+ args.get(i).name +
                        "\" conflicts with \"" + this.name + "\"");*/
      }
    }
  }
  return true ;
}

string Argument::toString(){
  return "name: " + this->m_name + " param:" + this->m_param ;
}

// bool Argument::checkForParam(string name){
//   
//     if(this->m_validarg->paramlist.size()){
//     /* check parameters */
//     if(this->m_param.empty()){
//       
//       if(this->m_validarg->paramrequired){  /* ERROR param required */cerr << "param required" << endl ; return false ;}
//       // set default
//       cerr << "assuming default param: " << this->m_validarg->defaultparam << endl ;
//       this->m_param = this->m_validarg->defaultparam ;
//       return true ;
//     }else{
//       for(int p=0; p < this->m_validarg->paramlist.size() ; p++){
//         if(this->m_param == this->m_validarg->paramlist[p] ){
//           //Ok valid param
//           return true ;
//         }
//         // TODO pattern match
//       }
//       // error paramatere is invalid.
//       cerr << "param invalid" << endl ;
//       return false ;
//     }
//   }else{
//     if(this->m_param.size()){
//       //Error this param is not expected here
//       cerr << "param unexpected here" << endl ;
//       return false ;
//     }
//     return true ;
//   }
// }
// 
// 
// bool Argument::checkForName(string name){
//   
// }

string n2nc::utils::args::Argument::param(){
  return this->m_param ;
}


}
}
}

---