argumentshelper.cpp

#include "argumentshelper.h"

namespace n2nc {
namespace utils {
namespace args {
ArgumentsHelper::ArgumentsHelper(char** argv, int argc/*, vector<ValidArgument>& validargs*/ ){
  
//   this->m_validargs = validargs ; //copy ctor
  this->m_argv = argv ;
  
  if (argc < 2) return ; /* FIXME throw() or is still OK ? */

  /* FIXME this cannot handle unicode ( wide_char */
  for (int i=1; i < argc ; i++){
    if ( argv[i][0] == '-' ){
      if (i+1 < argc && !( argv[i+1][0] == '-') ){
        //param detected
        m_arguments.push_back( Argument(argv[i],argv[i+1]) );
        i++;
      }else{
        //no param
        m_arguments.push_back(Argument(argv[i], "" ));  /* FIXME */
      }
    }else{
      this->m_freeargs.push_back(argv[i]);
    }
    
  }
  
//   /* convert argv to a vector of strings */
//   vector<string> v_args ;
//   for (int z=1; z < argc ; z++){
//     v_args.push_back(argv[z]);  //implicit constructor conversion
//   }
//   
//   
//   
//   if (! v_args.size() ) return ;

//   if (! v_args.size() ) return ;
// 
//   for (int i=0; i < v_args.size() ; i++){
//     if ( v_args[i][0] == '-' ){
//       if (i+1 < v_args.size() && !( v_args[i+1][0] == '-') ){
//         //param detected
//         m_arguments.push_back( Argument(v_args[i],v_args[i+1]) );
//         i++;
//       }else{
//         //no param
//         m_arguments.push_back(Argument(v_args[i], "" ));  /* FIXME */
//       }
//     }
//   }


}

ArgumentsHelper::~ArgumentsHelper(){}

bool ArgumentsHelper::validate() /*throw(  )*/{
  bool isallok = true ;
  //delete invalid argument
  for (int i=0; i < m_arguments.size(); ){
    if (! m_arguments[i].validate(m_validargs)){
      vector<Argument>::iterator it = m_arguments.begin()  ;
      m_arguments.erase(it + i);  //FIXME ok ?
      isallok = isallok && false ;
    }
    else{
      i++ ;
    }
  }
  //check for dependencies
  for (int i=0; i < m_arguments.size(); i++){
    isallok = isallok && m_arguments[i].checkForDependecies(m_arguments);
  }
  //check for conflicts
  for (int i=0; i < m_arguments.size(); i++){
    isallok = isallok && m_arguments[i].checkForConflicts(m_arguments);
  }
  
  return isallok;
}

int ArgumentsHelper::size(){
  return m_arguments.size();
}

Argument* ArgumentsHelper::getArgumentByName(string name) throw(  ){
  for (int i=0; i < m_arguments.size(); i++){
    if ( name == m_arguments[i].m_name ){
      return &m_arguments[i];
    }
  }
  return NULL ;
//   return  ; /* FIXME throw */
}
/* alias */
Argument* ArgumentsHelper::operator[](string name) throw(  ){
  return this->getArgumentByName(name);
}

string ArgumentsHelper::toString(){
  string retval = "" ;
  for (int i=0; i < m_arguments.size(); i++){
          retval += m_arguments[i].toString() + "\n" ;  /* FIXME remove ending slash ?*/
  }
  return retval ;
}

string ArgumentsHelper::dumpAllValid(){
  string retval = "" ;
  for (int i=0; i < m_validargs.size() ; i++){
    retval += m_validargs[i].toString() + "\n" ;  /* FIXME remove ending slash ?*/
  }
  return retval ;
}

ValidArgument* ArgumentsHelper::addValid(string name){
  this->m_validargs.push_back(ValidArgument(name));
  return &this->m_validargs.back();
}

string ArgumentsHelper::getFreeArg(int pos){
  if (pos < m_freeargs.size())  /* avoid expeption */
    return this->m_freeargs[pos] ;
  else
    return "" ;
}




}
}
}

---