redsnow 0.3.2 → 0.3.3

data/ext/snowcrash/ext/cmdline/LICENSE

@@ -1,30 +0,0 @@
-Copyright (c) 2009, Hideyuki Tanaka
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
-
-    * Neither the name of Hideyuki Tanaka nor the names of other
-      contributors may be used to endorse or promote products derived
-      from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/ext/snowcrash/ext/cmdline/README.rst

@@ -1,191 +0,0 @@
-=============================================
-cmdline: A simple command line parser for C++
-=============================================
-
-About
------
-
-This is a simple command line parser for C++.
-
-- Easy to use
-- Only one header file
-- Automatic type check
-
-Sample
-------
-
-Here show sample usages of cmdline.
-
-Normal usage
-============
-
-This is an example of simple usage.
-
-::
-
-  // include cmdline.h
-  #include "cmdline.h"
-  
-  int main(int argc, char *argv[])
-  {
-    // create a parser
-    cmdline::parser a;
-    
-    // add specified type of variable.
-    // 1st argument is long name
-    // 2nd argument is short name (no short name if '\0' specified)
-    // 3rd argument is description
-    // 4th argument is mandatory (optional. default is false)
-    // 5th argument is default value  (optional. it used when mandatory is false)
-    a.add<string>("host", 'h', "host name", true, "");
-    
-    // 6th argument is extra constraint.
-    // Here, port number must be 1 to 65535 by cmdline::range().
-    a.add<int>("port", 'p', "port number", false, 80, cmdline::range(1, 65535));
-    
-    // cmdline::oneof() can restrict options.
-    a.add<string>("type", 't', "protocol type", false, "http", cmdline::oneof<string>("http", "https", "ssh", "ftp"));
-    
-    // Boolean flags also can be defined.
-    // Call add method without a type parameter.
-    a.add("gzip", '\0', "gzip when transfer");
-    
-    // Run parser.
-    // It returns only if command line arguments are valid.
-    // If arguments are invalid, a parser output error msgs then exit program.
-    // If help flag ('--help' or '-?') is specified, a parser output usage message then exit program.
-    a.parse_check(argc, argv);
-    
-    // use flag values
-    cout << a.get<string>("type") << "://"
-         << a.get<string>("host") << ":"
-         << a.get<int>("port") << endl;
-    
-    // boolean flags are referred by calling exist() method.
-    if (a.exist("gzip")) cout << "gzip" << endl;
-  }
-
-Here are some execution results:
-
-::
-
-  $ ./test
-  usage: ./test --host=string [options] ... 
-  options:
-    -h, --host    host name (string)
-    -p, --port    port number (int [=80])
-    -t, --type    protocol type (string [=http])
-        --gzip    gzip when transfer
-    -?, --help    print this message
-
-::
-
-  $ ./test -?
-  usage: ./test --host=string [options] ... 
-  options:
-    -h, --host    host name (string)
-    -p, --port    port number (int [=80])
-    -t, --type    protocol type (string [=http])
-       --gzip    gzip when transfer
-    -?, --help    print this message
-
-::
-
-  $ ./test --host=github.com
-  http://github.com:80
-
-::
-
-  $ ./test --host=github.com -t ftp
-  ftp://github.com:80
-
-::
-
-  $ ./test --host=github.com -t ttp
-  option value is invalid: --type=ttp
-  usage: ./test --host=string [options] ... 
-  options:
-    -h, --host    host name (string)
-    -p, --port    port number (int [=80])
-    -t, --type    protocol type (string [=http])
-        --gzip    gzip when transfer
-    -?, --help    print this message
-
-::
-
-  $ ./test --host=github.com -p 4545
-  http://github.com:4545
-
-::
-
-  $ ./test --host=github.com -p 100000
-  option value is invalid: --port=100000
-  usage: ./test --host=string [options] ... 
-  options:
-    -h, --host    host name (string)
-    -p, --port    port number (int [=80])
-    -t, --type    protocol type (string [=http])
-        --gzip    gzip when transfer
-    -?, --help    print this message
-
-::
-
-  $ ./test --host=github.com --gzip
-  http://github.com:80
-  gzip
-
-Extra Options
-=============
-
-- rest of arguments
-
-Rest of arguments are referenced by rest() method.
-It returns vector of string.
-Usualy, they are used to specify filenames, and so on.
-
-::
-
-  for (int i = 0; i < a.rest().size(); i++)
-    cout << a.rest()[i] << endl\;
-
-- footer
-
-footer() method is add a footer text of usage.
-
-::
-
-  ...
-  a.footer("filename ...");
-  ...
-
-Result is:
-
-::
-
-  $ ./test
-  usage: ./test --host=string [options] ... filename ...
-  options:
-    -h, --host    host name (string)
-    -p, --port    port number (int [=80])
-    -t, --type    protocol type (string [=http])
-        --gzip    gzip when transfer
-    -?, --help    print this message
-
-- program name
-
-A parser shows program name to usage message.
-Default program name is determin by argv[0].
-set_program_name() method can set any string to program name.
-
-Process flags manually
-----------------------
-
-parse_check() method parses command line arguments and
-check error and help flag.
-
-You can do this process mannually.
-bool parse() method parses command line arguments then
-returns if they are valid.
-You should check the result, and do what you want yourself.
-
-(For more information, you may read test2.cpp.)

data/ext/snowcrash/ext/cmdline/cmdline.h

@@ -1,817 +0,0 @@
-/*
-  Copyright (c) 2009, Hideyuki Tanaka
-  All rights reserved.
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-  * Redistributions of source code must retain the above copyright
-  notice, this list of conditions and the following disclaimer.
-  * Redistributions in binary form must reproduce the above copyright
-  notice, this list of conditions and the following disclaimer in the
-  documentation and/or other materials provided with the distribution.
-  * Neither the name of the <organization> nor the
-  names of its contributors may be used to endorse or promote products
-  derived from this software without specific prior written permission.
-
-  THIS SOFTWARE IS PROVIDED BY <copyright holder> ''AS IS'' AND ANY
-  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#pragma once
-
-#include <iostream>
-#include <sstream>
-#include <vector>
-#include <map>
-#include <string>
-#include <stdexcept>
-#include <typeinfo>
-#include <cstring>
-#include <algorithm>
-
-#if defined(__clang__) || defined(__GNUC__)
-#include <cxxabi.h>
-#endif 
-
-#include <cstdlib>
-
-namespace cmdline{
-
-namespace detail{
-
-template <typename Target, typename Source, bool Same>
-class lexical_cast_t{
-public:
-  static Target cast(const Source &arg){
-    Target ret;
-    std::stringstream ss;
-    if (!(ss<<arg && ss>>ret && ss.eof()))
-      throw std::bad_cast();
-    
-    return ret;
-  }
-};
-
-template <typename Target, typename Source>
-class lexical_cast_t<Target, Source, true>{
-public:
-  static Target cast(const Source &arg){
-    return arg;
-  }  
-};
-
-template <typename Source>
-class lexical_cast_t<std::string, Source, false>{
-public:
-  static std::string cast(const Source &arg){
-    std::ostringstream ss;
-    ss<<arg;
-    return ss.str();
-  }
-};
-
-template <typename Target>
-class lexical_cast_t<Target, std::string, false>{
-public:
-  static Target cast(const std::string &arg){
-    Target ret;
-    std::istringstream ss(arg);
-    if (!(ss>>ret && ss.eof()))
-      throw std::bad_cast();
-    return ret;
-  }
-};
-
-template <typename T1, typename T2>
-struct is_same {
-  static const bool value = false;
-};
-
-template <typename T>
-struct is_same<T, T>{
-  static const bool value = true;
-};
-
-template<typename Target, typename Source>
-Target lexical_cast(const Source &arg)
-{
-  return lexical_cast_t<Target, Source, detail::is_same<Target, Source>::value>::cast(arg);
-}
-
-static inline std::string demangle(const std::string &name)
-{
-#if defined(__clang__) || defined(__GNUC__)
-  int status=0;
-  char *p=abi::__cxa_demangle(name.c_str(), 0, 0, &status);
-  std::string ret(p);
-  free(p);
-  return ret;
-#else
-  return name;
-#endif
-}
-
-template <class T>
-std::string readable_typename()
-{
-  return demangle(typeid(T).name());
-}
-
-template <class T>
-std::string default_value(T def)
-{
-  return detail::lexical_cast<std::string>(def);
-}
-
-template <>
-inline std::string readable_typename<std::string>()
-{
-  return "string";
-}
-
-} // detail
-
-//-----
-
-class cmdline_error : public std::exception {
-public:
-  cmdline_error(const std::string &msg): msg(msg){}
-  ~cmdline_error() throw() {}
-  const char *what() const throw() { return msg.c_str(); }
-private:
-  std::string msg;
-};
-
-template <class T>
-struct default_reader{
-  T operator()(const std::string &str){
-    return detail::lexical_cast<T>(str);
-  }
-};
-
-template <class T>
-struct range_reader{
-  range_reader(const T &low, const T &high): low(low), high(high) {}
-  T operator()(const std::string &s) const {
-    T ret=default_reader<T>()(s);
-    if (!(ret>=low && ret<=high)) throw cmdline::cmdline_error("range_error");
-    return ret;
-  }
-private:
-  T low, high;
-};
-
-template <class T>
-range_reader<T> range(const T &low, const T &high)
-{
-  return range_reader<T>(low, high);
-}
-
-template <class T>
-struct oneof_reader{
-  T operator()(const std::string &s){
-    T ret=default_reader<T>()(s);
-    if (std::find(alt.begin(), alt.end(), ret)==alt.end())
-      throw cmdline_error("");
-    return ret;
-  }
-  void add(const T &v){ alt.push_back(v); }
-private:
-  std::vector<T> alt;
-};
-
-template <class T>
-oneof_reader<T> oneof(T a1)
-{
-  oneof_reader<T> ret;
-  ret.add(a1);
-  return ret;
-}
-
-template <class T>
-oneof_reader<T> oneof(T a1, T a2)
-{
-  oneof_reader<T> ret;
-  ret.add(a1);
-  ret.add(a2);
-  return ret;
-}
-
-template <class T>
-oneof_reader<T> oneof(T a1, T a2, T a3)
-{
-  oneof_reader<T> ret;
-  ret.add(a1);
-  ret.add(a2);
-  ret.add(a3);
-  return ret;
-}
-
-template <class T>
-oneof_reader<T> oneof(T a1, T a2, T a3, T a4)
-{
-  oneof_reader<T> ret;
-  ret.add(a1);
-  ret.add(a2);
-  ret.add(a3);
-  ret.add(a4);
-  return ret;
-}
-
-template <class T>
-oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5)
-{
-  oneof_reader<T> ret;
-  ret.add(a1);
-  ret.add(a2);
-  ret.add(a3);
-  ret.add(a4);
-  ret.add(a5);
-  return ret;
-}
-
-template <class T>
-oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6)
-{
-  oneof_reader<T> ret;
-  ret.add(a1);
-  ret.add(a2);
-  ret.add(a3);
-  ret.add(a4);
-  ret.add(a5);
-  ret.add(a6);
-  return ret;
-}
-
-template <class T>
-oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7)
-{
-  oneof_reader<T> ret;
-  ret.add(a1);
-  ret.add(a2);
-  ret.add(a3);
-  ret.add(a4);
-  ret.add(a5);
-  ret.add(a6);
-  ret.add(a7);
-  return ret;
-}
-
-template <class T>
-oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8)
-{
-  oneof_reader<T> ret;
-  ret.add(a1);
-  ret.add(a2);
-  ret.add(a3);
-  ret.add(a4);
-  ret.add(a5);
-  ret.add(a6);
-  ret.add(a7);
-  ret.add(a8);
-  return ret;
-}
-
-template <class T>
-oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8, T a9)
-{
-  oneof_reader<T> ret;
-  ret.add(a1);
-  ret.add(a2);
-  ret.add(a3);
-  ret.add(a4);
-  ret.add(a5);
-  ret.add(a6);
-  ret.add(a7);
-  ret.add(a8);
-  ret.add(a9);
-  return ret;
-}
-
-template <class T>
-oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8, T a9, T a10)
-{
-  oneof_reader<T> ret;
-  ret.add(a1);
-  ret.add(a2);
-  ret.add(a3);
-  ret.add(a4);
-  ret.add(a5);
-  ret.add(a6);
-  ret.add(a7);
-  ret.add(a8);
-  ret.add(a9);
-  ret.add(a10);
-  return ret;
-}
-
-//-----
-
-class parser{
-public:
-  parser(){
-  }
-  ~parser(){
-    for (std::map<std::string, option_base*>::iterator p=options.begin();
-         p!=options.end(); p++)
-      delete p->second;
-  }
-
-  void add(const std::string &name,
-           char short_name=0,
-           const std::string &desc=""){
-    if (options.count(name)) throw cmdline_error("multiple definition: "+name);
-    options[name]=new option_without_value(name, short_name, desc);
-    ordered.push_back(options[name]);
-  }
-
-  template <class T>
-  void add(const std::string &name,
-           char short_name=0,
-           const std::string &desc="",
-           bool need=true,
-           const T def=T()){
-    add(name, short_name, desc, need, def, default_reader<T>());
-  }
-
-  template <class T, class F>
-  void add(const std::string &name,
-           char short_name=0,
-           const std::string &desc="",
-           bool need=true,
-           const T def=T(),
-           F reader=F()){
-    if (options.count(name)) throw cmdline_error("multiple definition: "+name);
-    options[name]=new option_with_value_with_reader<T, F>(name, short_name, need, def, desc, reader);
-    ordered.push_back(options[name]);
-  }
-
-  void footer(const std::string &f){
-    ftr=f;
-  }
-
-  void set_program_name(const std::string &name){
-    prog_name=name;
-  }
-
-  bool exist(const std::string &name) const {
-    if (options.count(name)==0) throw cmdline_error("there is no flag: --"+name);
-    return options.find(name)->second->has_set();
-  }
-
-  template <class T>
-  const T &get(const std::string &name) const {
-    if (options.count(name)==0) throw cmdline_error("there is no flag: --"+name);
-    const option_with_value<T> *p=dynamic_cast<const option_with_value<T>*>(options.find(name)->second);
-    if (p==NULL) throw cmdline_error("type mismatch flag '"+name+"'");
-    return p->get();
-  }
-
-  const std::vector<std::string> &rest() const {
-    return others;
-  }
-
-  bool parse(const std::string &arg){
-    std::vector<std::string> args;
-
-    std::string buf;
-    bool in_quote=false;
-    for (std::string::size_type i=0; i<arg.length(); i++){
-      if (arg[i]=='\"'){
-        in_quote=!in_quote;
-        continue;
-      }
-
-      if (arg[i]==' ' && !in_quote){
-        args.push_back(buf);
-        buf="";
-        continue;
-      }
-
-      if (arg[i]=='\\'){
-        i++;
-        if (i>=arg.length()){
-          errors.push_back("unexpected occurrence of '\\' at end of string");
-          return false;
-        }
-      }
-
-      buf+=arg[i];
-    }
-
-    if (in_quote){
-      errors.push_back("quote is not closed");
-      return false;
-    }
-
-    if (buf.length()>0)
-      args.push_back(buf);
-
-    for (size_t i=0; i<args.size(); i++)
-      std::cout<<"\""<<args[i]<<"\""<<std::endl;
-
-    return parse(args);
-  }
-
-  bool parse(const std::vector<std::string> &args){
-    int argc=static_cast<int>(args.size());
-    std::vector<const char*> argv(argc);
-
-    for (int i=0; i<argc; i++)
-      argv[i]=args[i].c_str();
-
-    return parse(argc, &argv[0]);
-  }
-
-  bool parse(int argc, const char * const argv[]){
-    errors.clear();
-    others.clear();
-
-    if (argc<1){
-      errors.push_back("argument number must be longer than 0");
-      return false;
-    }
-    if (prog_name=="")
-      prog_name=argv[0];
-
-    std::map<char, std::string> lookup;
-    for (std::map<std::string, option_base*>::iterator p=options.begin();
-         p!=options.end(); p++){
-      if (p->first.length()==0) continue;
-      char initial=p->second->short_name();
-      if (initial){
-        if (lookup.count(initial)>0){
-          lookup[initial]="";
-          errors.push_back(std::string("short option '")+initial+"' is ambiguous");
-          return false;
-        }
-        else lookup[initial]=p->first;
-      }
-    }
-
-    for (int i=1; i<argc; i++){
-      if (strncmp(argv[i], "--", 2)==0){
-        const char *p=strchr(argv[i]+2, '=');
-        if (p){
-          std::string name(argv[i]+2, p);
-          std::string val(p+1);
-          set_option(name, val);
-        }
-        else{
-          std::string name(argv[i]+2);
-          if (options.count(name)==0){
-            errors.push_back("undefined option: --"+name);
-            continue;
-          }
-          if (options[name]->has_value()){
-            if (i+1>=argc){
-              errors.push_back("option needs value: --"+name);
-              continue;
-            }
-            else{
-              i++;
-              set_option(name, argv[i]);
-            }
-          }
-          else{
-            set_option(name);
-          }
-        }
-      }
-      else if (strncmp(argv[i], "-", 1)==0){
-        if (!argv[i][1]) continue;
-        char last=argv[i][1];
-        for (int j=2; argv[i][j]; j++){
-          last=argv[i][j];
-          if (lookup.count(argv[i][j-1])==0){
-            errors.push_back(std::string("undefined short option: -")+argv[i][j-1]);
-            continue;
-          }
-          if (lookup[argv[i][j-1]]==""){
-            errors.push_back(std::string("ambiguous short option: -")+argv[i][j-1]);
-            continue;
-          }
-          set_option(lookup[argv[i][j-1]]);
-        }
-
-        if (lookup.count(last)==0){
-          errors.push_back(std::string("undefined short option: -")+last);
-          continue;
-        }
-        if (lookup[last]==""){
-          errors.push_back(std::string("ambiguous short option: -")+last);
-          continue;
-        }
-
-        if (i+1<argc && options[lookup[last]]->has_value()){
-          set_option(lookup[last], argv[i+1]);
-          i++;
-        }
-        else{
-          set_option(lookup[last]);
-        }
-      }
-      else{
-        others.push_back(argv[i]);
-      }
-    }
-
-    for (std::map<std::string, option_base*>::iterator p=options.begin();
-         p!=options.end(); p++)
-      if (!p->second->valid())
-        errors.push_back("need option: --"+std::string(p->first));
-
-    return errors.size()==0;
-  }
-
-  void parse_check(const std::string &arg){
-    if (!options.count("help"))
-      add("help", '?', "print this message");
-    check(0, parse(arg));
-  }
-
-  void parse_check(const std::vector<std::string> &args){
-    if (!options.count("help"))
-      add("help", '?', "print this message");
-    check(static_cast<int>(args.size()), parse(args));
-  }
-
-  void parse_check(int argc, const char *argv[]){
-    if (!options.count("help"))
-      add("help", '?', "print this message");
-    check(argc, parse(argc, argv));
-  }
-
-  std::string error() const{
-    return errors.size()>0?errors[0]:"";
-  }
-
-  std::string error_full() const{
-    std::ostringstream oss;
-    for (size_t i=0; i<errors.size(); i++)
-      oss<<errors[i]<<std::endl;
-    return oss.str();
-  }
-
-  std::string usage() const {
-    std::ostringstream oss;
-    oss<<"usage: "<<prog_name<<" ";
-    for (size_t i=0; i<ordered.size(); i++){
-      if (ordered[i]->must())
-        oss<<ordered[i]->short_description()<<" ";
-    }
-    
-    oss<<"[options] ... "<<ftr<<std::endl;
-    oss<<"options:"<<std::endl;
-
-    size_t max_width=0;
-    for (size_t i=0; i<ordered.size(); i++){
-      max_width=std::max(max_width, ordered[i]->name().length());
-    }
-    for (size_t i=0; i<ordered.size(); i++){
-      if (ordered[i]->short_name()){
-        oss<<"  -"<<ordered[i]->short_name()<<", ";
-      }
-      else{
-        oss<<"      ";
-      }
-
-      oss<<"--"<<ordered[i]->name();
-      for (size_t j=ordered[i]->name().length(); j<max_width+4; j++)
-        oss<<' ';
-      oss<<ordered[i]->description()<<std::endl;
-    }
-    return oss.str();
-  }
-
-private:
-
-  void check(int argc, bool ok){
-    if ((argc==1 && !ok) || exist("help")){
-      std::cerr<<usage();
-      exit(0);
-    }
-
-    if (!ok){
-      std::cerr<<error()<<std::endl<<usage();
-      exit(1);
-    }
-  }
-
-  void set_option(const std::string &name){
-    if (options.count(name)==0){
-      errors.push_back("undefined option: --"+name);
-      return;
-    }
-    if (!options[name]->set()){
-      errors.push_back("option needs value: --"+name);
-      return;
-    }
-  }
-
-  void set_option(const std::string &name, const std::string &value){
-    if (options.count(name)==0){
-      errors.push_back("undefined option: --"+name);
-      return;
-    }
-    if (!options[name]->set(value)){
-      errors.push_back("option value is invalid: --"+name+"="+value);
-      return;
-    }
-  }
-
-  class option_base{
-  public:
-    virtual ~option_base(){}
-
-    virtual bool has_value() const=0;
-    virtual bool set()=0;
-    virtual bool set(const std::string &value)=0;
-    virtual bool has_set() const=0;
-    virtual bool valid() const=0;
-    virtual bool must() const=0;
-
-    virtual const std::string &name() const=0;
-    virtual char short_name() const=0;
-    virtual const std::string &description() const=0;
-    virtual std::string short_description() const=0;
-  };
-
-  class option_without_value : public option_base {
-  public:
-    option_without_value(const std::string &name,
-                         char short_name,
-                         const std::string &desc)
-      :nam(name), snam(short_name), desc(desc), has(false){
-    }
-    ~option_without_value(){}
-
-    bool has_value() const { return false; }
-
-    bool set(){
-      has=true;
-      return true;
-    }
-
-    bool set(const std::string &){
-      return false;
-    }
-
-    bool has_set() const {
-      return has;
-    }
-
-    bool valid() const{
-      return true;
-    }
-
-    bool must() const{
-      return false;
-    }
-
-    const std::string &name() const{
-      return nam;
-    }
-
-    char short_name() const{
-      return snam;
-    }
-
-    const std::string &description() const {
-      return desc;
-    }
-
-    std::string short_description() const{
-      return "--"+nam;
-    }
-
-  private:
-    std::string nam;
-    char snam;
-    std::string desc;
-    bool has;
-  };
-
-  template <class T>
-  class option_with_value : public option_base {
-  public:
-    option_with_value(const std::string &name,
-                      char short_name,
-                      bool need,
-                      const T &def,
-                      const std::string &desc)
-      : nam(name), snam(short_name), need(need), has(false)
-      , def(def), actual(def) {
-      this->desc=full_description(desc);
-    }
-    ~option_with_value(){}
-
-    const T &get() const {
-      return actual;
-    }
-
-    bool has_value() const { return true; }
-
-    bool set(){
-      return false;
-    }
-
-    bool set(const std::string &value){
-      try{
-        actual=read(value);
-        has=true;
-      }
-      catch(const std::exception &){
-        return false;
-      }
-      return true;
-    }
-
-    bool has_set() const{
-      return has;
-    }
-
-    bool valid() const{
-      if (need && !has) return false;
-      return true;
-    }
-
-    bool must() const{
-      return need;
-    }
-
-    const std::string &name() const{
-      return nam;
-    }
-
-    char short_name() const{
-      return snam;
-    }
-
-    const std::string &description() const {
-      return desc;
-    }
-
-    std::string short_description() const{
-      return "--"+nam+"="+detail::readable_typename<T>();
-    }
-
-  protected:
-    std::string full_description(const std::string &desc){
-      return
-        desc+" ("+detail::readable_typename<T>()+
-        (need?"":" [="+detail::default_value<T>(def)+"]")
-        +")";
-    }
-
-    virtual T read(const std::string &s)=0;
-
-    std::string nam;
-    char snam;
-    bool need;
-    std::string desc;
-
-    bool has;
-    T def;
-    T actual;
-  };
-
-  template <class T, class F>
-  class option_with_value_with_reader : public option_with_value<T> {
-  public:
-    option_with_value_with_reader(const std::string &name,
-                                  char short_name,
-                                  bool need,
-                                  const T def,
-                                  const std::string &desc,
-                                  F reader)
-      : option_with_value<T>(name, short_name, need, def, desc), reader(reader){
-    }
-
-  private:
-    T read(const std::string &s){
-      return reader(s);
-    }
-
-    F reader;
-  };
-
-  std::map<std::string, option_base*> options;
-  std::vector<option_base*> ordered;
-  std::string ftr;
-
-  std::string prog_name;
-  std::vector<std::string> others;
-
-  std::vector<std::string> errors;
-};
-
-} // cmdline