lemon-1.1: comparison lemon/arg

equal deleted inserted replaced

-:c98ef4a71b54
+:dc409a17e6de
-/* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
-* This file is a part of LEMON, a generic C++ optimization library
+* This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2008
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 ArgParser::~ArgParser()
 {
 for(Opts::iterator i=_opts.begin();i!=_opts.end();++i)
 if(i->second.self_delete)
-	switch(i->second.type) {
+switch(i->second.type) {
-	case BOOL:
+case BOOL:
-	  delete i->second.bool_p;
+delete i->second.bool_p;
-	  break;
+break;
-	case STRING:
+case STRING:
-	  delete i->second.string_p;
+delete i->second.string_p;
-	  break;
+break;
-	case DOUBLE:
+case DOUBLE:
-	  delete i->second.double_p;
+delete i->second.double_p;
-	  break;
+break;
-	case INTEGER:
+case INTEGER:
-	  delete i->second.int_p;
+delete i->second.int_p;
-	  break;
+break;
-	case UNKNOWN:
+case UNKNOWN:
-	  break;
+break;
-	case FUNC:
+case FUNC:
-	  break;
+break;
-	}
+}
 }
 ArgParser &ArgParser::intOption(const std::string &name,
-			       const std::string &help,
+const std::string &help,
-			       int value, bool obl)
+int value, bool obl)
 {
 ParData p;
 p.int_p=new int(value);
 p.self_delete=true;
 p.help=help;
 _opts[name]=p;
 return *this;
 }
 ArgParser &ArgParser::doubleOption(const std::string &name,
-			       const std::string &help,
+const std::string &help,
-			       double value, bool obl)
+double value, bool obl)
 {
 ParData p;
 p.double_p=new double(value);
 p.self_delete=true;
 p.help=help;
 _opts[name]=p;
 return *this;
 }
 ArgParser &ArgParser::boolOption(const std::string &name,
-			       const std::string &help,
+const std::string &help,
-			       bool value, bool obl)
+bool value, bool obl)
 {
 ParData p;
 p.bool_p=new bool(value);
 p.self_delete=true;
 p.help=help;
 _opts[name]=p;
 return *this;
 }
 ArgParser &ArgParser::stringOption(const std::string &name,
-			       const std::string &help,
+const std::string &help,
-			       std::string value, bool obl)
+std::string value, bool obl)
 {
 ParData p;
 p.string_p=new std::string(value);
 p.self_delete=true;
 p.help=help;
 _opts[name]=p;
 return *this;
 }
 ArgParser &ArgParser::refOption(const std::string &name,
-			       const std::string &help,
+const std::string &help,
-			       int &ref, bool obl)
+int &ref, bool obl)
 {
 ParData p;
 p.int_p=&ref;
 p.self_delete=false;
 p.help=help;
 return *this;
 }
 ArgParser &ArgParser::refOption(const std::string &name,
-			       const std::string &help,
+const std::string &help,
-			       std::string &ref, bool obl)
+std::string &ref, bool obl)
 {
 ParData p;
 p.string_p=&ref;
 p.self_delete=false;
 p.help=help;
 _opts[name]=p;
 return *this;
 }
 ArgParser &ArgParser::funcOption(const std::string &name,
-			       const std::string &help,
+const std::string &help,
-			       void (*func)(void *),void *data)
+void (*func)(void *),void *data)
 {
 ParData p;
 p.func_p.p=func;
 p.func_p.data=data;
 p.self_delete=false;
 _opts[name]=p;
 return *this;
 }
 ArgParser &ArgParser::optionGroup(const std::string &group,
-				    const std::string &opt)
+const std::string &opt)
 {
 Opts::iterator i = _opts.find(opt);
 LEMON_ASSERT(i!=_opts.end(), "Unknown option: '"+opt+"'");
 LEMON_ASSERT(!(i->second.ingroup),
 "Option already in option group: '"+opt+"'");
 GroupData &g=_groups[group];
 g.opts.push_back(opt);
 i->second.ingroup=true;
 return *this;
 g.only_one=true;
 return *this;
 }
 ArgParser &ArgParser::synonym(const std::string &syn,
-				const std::string &opt)
+const std::string &opt)
 {
 Opts::iterator o = _opts.find(opt);
 Opts::iterator s = _opts.find(syn);
 LEMON_ASSERT(o!=_opts.end(), "Unknown option: '"+opt+"'");
 LEMON_ASSERT(s==_opts.end(), "Option already used: '"+syn+"'");
 g.mandatory=true;
 return *this;
 }
 ArgParser &ArgParser::other(const std::string &name,
-			      const std::string &help)
+const std::string &help)
 {
 _others_help.push_back(OtherArg(name,help));
 return *this;
 }
 void ArgParser::show(std::ostream &os,Opts::iterator i)
 {
 os << "-" << i->first;
 if(i->second.has_syn)
 for(Opts::iterator j=_opts.begin();j!=_opts.end();++j)
-	if(j->second.syn&&j->second.help==i->first)
+if(j->second.syn&&j->second.help==i->first)
-	  os << "|-" << j->first;
+os << "|-" << j->first;
 switch(i->second.type) {
 case STRING:
 os << " str";
 break;
 case INTEGER:
 show(os,_opts.find(*o));
 ++o;
 if(o!=i->second.opts.end()) os<<'|';
 }
 }
 void ArgParser::showHelp(Opts::iterator i)
 {
 if(i->second.help.size()==0||i->second.syn) return;
 std::cerr << "  ";
 show(std::cerr,i);
 }
 void ArgParser::showHelp(std::vector<ArgParser::OtherArg>::iterator i)
 {
 if(i->help.size()==0) return;
 std::cerr << "  " << i->name << std::endl
-	      << "     " << i->help << std::endl;
+<< "     " << i->help << std::endl;
 }
 void ArgParser::shortHelp()
 {
 const unsigned int LINE_LEN=77;
 const std::string indent("    ");
 std::cerr << "Usage:\n  " << _command_name;
 cstr << ' ';
 if(!g->second.mandatory) cstr << '[';
 show(cstr,g);
 if(!g->second.mandatory) cstr << ']';
 if(pos+cstr.str().size()>LINE_LEN) {
-	std::cerr << std::endl << indent;
+std::cerr << std::endl << indent;
-	pos=indent.size();
+pos=indent.size();
 }
 std::cerr << cstr.str();
 pos+=cstr.str().size();
 }
 for(Opts::iterator i=_opts.begin();i!=_opts.end();++i)
 if(!i->second.ingroup&&!i->second.syn) {
-	std::ostringstream cstr;
+std::ostringstream cstr;
-	cstr << ' ';
+cstr << ' ';
-	if(!i->second.mandatory) cstr << '[';
+if(!i->second.mandatory) cstr << '[';
-	show(cstr,i);
+show(cstr,i);
-	if(!i->second.mandatory) cstr << ']';
+if(!i->second.mandatory) cstr << ']';
-	if(pos+cstr.str().size()>LINE_LEN) {
+if(pos+cstr.str().size()>LINE_LEN) {
-	  std::cerr << std::endl << indent;
+std::cerr << std::endl << indent;
-	  pos=indent.size();
+pos=indent.size();
-	}
+}
-	std::cerr << cstr.str();
+std::cerr << cstr.str();
-	pos+=cstr.str().size();
+pos+=cstr.str().size();
 }
 for(std::vector<OtherArg>::iterator i=_others_help.begin();
-	i!=_others_help.end();++i)
+i!=_others_help.end();++i)
 {
-	std::ostringstream cstr;
+std::ostringstream cstr;
-	cstr << ' ' << i->name;
+cstr << ' ' << i->name;
-	if(pos+cstr.str().size()>LINE_LEN) {
+if(pos+cstr.str().size()>LINE_LEN) {
-	  std::cerr << std::endl << indent;
+std::cerr << std::endl << indent;
-	  pos=indent.size();
+pos=indent.size();
-	}
+}
-	std::cerr << cstr.str();
+std::cerr << cstr.str();
-	pos+=cstr.str().size();
+pos+=cstr.str().size();
 }
 std::cerr << std::endl;
 }
 void ArgParser::showHelp()
 {
 shortHelp();
 std::cerr << "Where:\n";
 for(std::vector<OtherArg>::iterator i=_others_help.begin();
-	i!=_others_help.end();++i) showHelp(i);
+i!=_others_help.end();++i) showHelp(i);
 for(Opts::iterator i=_opts.begin();i!=_opts.end();++i) showHelp(i);
 exit(1);
 }
 void ArgParser::unknownOpt(std::string arg)
 {
 std::cerr << "\nUnknown option: " << arg << "\n";
 std::cerr << "\nType '" << _command_name <<
 " --help' to obtain a short summary on the usage.\n\n";
 exit(1);
 }
 void ArgParser::requiresValue(std::string arg, OptType t)
 {
 std::cerr << "Argument '" << arg << "' requires a";
 switch(t) {
 case STRING:
 std::cerr << " string";
 break;
 }
 std::cerr << " value\n\n";
 showHelp();
 }
 void ArgParser::checkMandatories()
 {
 bool ok=true;
 for(Opts::iterator i=_opts.begin();i!=_opts.end();++i)
 if(i->second.mandatory&&!i->second.set)
-	{
+{
-	  if(ok)
+if(ok)
-	    std::cerr << _command_name
+std::cerr << _command_name
-		      << ": The following mandatory arguments are missing.\n";
+<< ": The following mandatory arguments are missing.\n";
-	  ok=false;
+ok=false;
-	  showHelp(i);
+showHelp(i);
-	}
+}
 for(Groups::iterator i=_groups.begin();i!=_groups.end();++i)
 if(i->second.mandatory||i->second.only_one)
-	{
+{
-	  int set=0;
+int set=0;
-	  for(GroupData::Opts::iterator o=i->second.opts.begin();
+for(GroupData::Opts::iterator o=i->second.opts.begin();
-	      o!=i->second.opts.end();++o)
+o!=i->second.opts.end();++o)
-	    if(_opts.find(*o)->second.set) ++set;
+if(_opts.find(*o)->second.set) ++set;
-	  if(i->second.mandatory&&!set) {
+if(i->second.mandatory&&!set) {
-	    std::cerr << _command_name
+std::cerr << _command_name
-		      << ": At least one of the following arguments is mandatory.\n";
+<< ": At least one of the following arguments is mandatory.\n";
-	    ok=false;
+ok=false;
-	    for(GroupData::Opts::iterator o=i->second.opts.begin();
+for(GroupData::Opts::iterator o=i->second.opts.begin();
-		o!=i->second.opts.end();++o)
+o!=i->second.opts.end();++o)
-	      showHelp(_opts.find(*o));
+showHelp(_opts.find(*o));
-	  }
+}
-	  if(i->second.only_one&&set>1) {
+if(i->second.only_one&&set>1) {
-	    std::cerr << _command_name
+std::cerr << _command_name
-		      << ": At most one of the following arguments can be given.\n";
+<< ": At most one of the following arguments can be given.\n";
-	    ok=false;
+ok=false;
-	    for(GroupData::Opts::iterator o=i->second.opts.begin();
+for(GroupData::Opts::iterator o=i->second.opts.begin();
-		o!=i->second.opts.end();++o)
+o!=i->second.opts.end();++o)
-	      showHelp(_opts.find(*o));
+showHelp(_opts.find(*o));
-	  }
+}
-	}
+}
 if(!ok) {
 std::cerr << "\nType '" << _command_name <<
-	" --help' to obtain a short summary on the usage.\n\n";
+" --help' to obtain a short summary on the usage.\n\n";
 exit(1);
 }
 }
 ArgParser &ArgParser::parse()
 {
 for(int ar=1; ar<_argc; ++ar) {
 std::string arg(_argv[ar]);
 if (arg[0] != '-' || arg.size() == 1) {
-	_file_args.push_back(arg);
+_file_args.push_back(arg);
 }
 else {
-	Opts::iterator i = _opts.find(arg.substr(1));
+Opts::iterator i = _opts.find(arg.substr(1));
-	if(i==_opts.end()) unknownOpt(arg);
+if(i==_opts.end()) unknownOpt(arg);
-	else {
+else {
-	  if(i->second.syn) i=_opts.find(i->second.help);
+if(i->second.syn) i=_opts.find(i->second.help);
-	  ParData &p(i->second);
+ParData &p(i->second);
-	  if (p.type==BOOL) *p.bool_p=true;
+if (p.type==BOOL) *p.bool_p=true;
-	  else if (p.type==FUNC) p.func_p.p(p.func_p.data);
+else if (p.type==FUNC) p.func_p.p(p.func_p.data);
-	  else if(++ar==_argc) requiresValue(arg, p.type);
+else if(++ar==_argc) requiresValue(arg, p.type);
-	  else {
+else {
-	    std::string val(_argv[ar]);
+std::string val(_argv[ar]);
-	    std::istringstream vals(val);
+std::istringstream vals(val);
-	    switch(p.type) {
+switch(p.type) {
-	    case STRING:
+case STRING:
-	      *p.string_p=val;
+*p.string_p=val;
-	      break;
+break;
-	    case INTEGER:
+case INTEGER:
-	      vals >> *p.int_p;
+vals >> *p.int_p;
-	      break;
+break;
-	    case DOUBLE:
+case DOUBLE:
-	      vals >> *p.double_p;
+vals >> *p.double_p;
-	      break;
+break;
-	    default:
+default:
-	      break;
+break;
-	    }
+}
-	    if(p.type!=STRING&&(!vals||!vals.eof()))
+if(p.type!=STRING&&(!vals||!vals.eof()))
-	      requiresValue(arg, p.type);
+requiresValue(arg, p.type);
-	  }
+}
-	  p.set = true;
+p.set = true;
-	}
+}
 }
 }
 checkMandatories();
 return *this;
 }
 }

changeset 209	765619b7cbb2
parent 137	483bc6ed7292
child 210	81cfc04531e8