dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/driver/options.cpp

@@ -0,0 +1,435 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2010-10-07 07:44:30 +1100 (Thu, 07 Oct 2010) $ by $Author: schulte $
+ *     $Revision: 11465 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <gecode/driver.hh>
+
+#include <iostream>
+#include <iomanip>
+
+#include <cstdlib>
+#include <cstring>
+
+namespace Gecode {
+
+  namespace Driver {
+
+    /*
+     * Option baseclass
+     *
+     */
+    char*
+    BaseOption::strdup(const char* s) {
+      if (s == NULL)
+        return NULL;
+      char* d = heap.alloc<char>(static_cast<unsigned long int>(strlen(s)+1));
+      (void) strcpy(d,s);
+      return d;
+    }
+
+    void
+    BaseOption::strdel(const char* s) {
+      if (s == NULL)
+        return;
+      heap.rfree(const_cast<char*>(s));
+    }
+
+    BaseOption::BaseOption(const char* o, const char* e)
+      : opt(strdup(o)), exp(strdup(e)) {}
+
+    BaseOption::~BaseOption(void) {
+      strdel(opt);
+      strdel(exp);
+    }
+
+
+    bool
+    StringValueOption::parse(int& argc, char* argv[]) {
+      if ((argc < 2) || strcmp(argv[1],opt))
+        return false;
+      if (argc == 2) {
+        std::cerr << "Missing argument for option \"" << opt << "\"" << std::endl;
+        exit(EXIT_FAILURE);
+      }
+      cur = strdup(argv[2]);
+      // Remove options
+      argc -= 2;
+      for (int i=1; i<argc; i++)
+        argv[i] = argv[i+2];
+      return true;
+    }
+    
+    void
+    StringValueOption::help(void) {
+      using namespace std;
+      cerr << '\t' << opt << " (string) default: " 
+           << ((cur == NULL) ? "NONE" : cur) << endl
+           << "\t\t" << exp << endl;
+    }
+  
+    StringValueOption::~StringValueOption(void) {
+      strdel(cur);
+    }
+  
+
+
+    void
+    StringOption::add(int v, const char* o, const char* h) {
+      Value* n = new Value;
+      n->val  = v;
+      n->opt  = strdup(o);
+      n->help = strdup(h);
+      n->next = NULL;
+      if (fst == NULL) {
+        fst = n;
+      } else {
+        lst->next = n;
+      }
+      lst = n;
+    }
+    
+    bool
+    StringOption::parse(int& argc, char* argv[]) {
+      if ((argc < 2) || strcmp(argv[1],opt))
+        return false;
+      if (argc == 2) {
+        std::cerr << "Missing argument for option \"" << opt << "\"" << std::endl;
+        exit(EXIT_FAILURE);
+      }
+      for (Value* v = fst; v != NULL; v = v->next)
+        if (!strcmp(argv[2],v->opt)) {
+          cur = v->val;
+          // Remove options
+          argc -= 2;
+          for (int i=1; i<argc; i++)
+            argv[i] = argv[i+2];
+          return true;
+        }
+      std::cerr << "Wrong argument \"" << argv[2]
+                << "\" for option \"" << opt << "\""
+                << std::endl;
+      exit(EXIT_FAILURE);
+    }
+    
+    void
+    StringOption::help(void) {
+      if (fst == NULL)
+        return;
+      std::cerr << '\t' << opt << " (";
+      const char* d = NULL;
+      for (Value* v = fst; v != NULL; v = v->next) {
+        std::cerr << v->opt << ((v->next != NULL) ? ", " : "");
+        if (v->val == cur)
+          d = v->opt;
+      }
+      std::cerr << ")";
+      if (d != NULL)
+        std::cerr << " default: " << d;
+      std::cerr << std::endl << "\t\t" << exp << std::endl;
+      for (Value* v = fst; v != NULL; v = v->next)
+        if (v->help != NULL)
+          std::cerr << "\t\t  " << v->opt << ": " << v->help << std::endl;
+    }
+    
+    StringOption::~StringOption(void) {
+      Value* v = fst;
+      while (v != NULL) {
+        strdel(v->opt);
+        strdel(v->help);
+        Value* n = v->next;
+        delete v;
+        v = n;
+      }
+    }
+    
+    
+    bool
+    IntOption::parse(int& argc, char* argv[]) {
+      if ((argc < 2) || strcmp(argv[1],opt))
+        return false;
+      if (argc == 2) {
+        std::cerr << "Missing argument for option \"" << opt << "\"" << std::endl;
+        exit(EXIT_FAILURE);
+      }
+      cur = atoi(argv[2]);
+      // Remove options
+      argc -= 2;
+      for (int i=1; i<argc; i++)
+        argv[i] = argv[i+2];
+      return true;
+    }
+    
+    void
+    IntOption::help(void) {
+      using namespace std;
+      cerr << '\t' << opt << " (int) default: " << cur << endl
+           << "\t\t" << exp << endl;
+    }
+  
+
+    bool
+    UnsignedIntOption::parse(int& argc, char* argv[]) {
+      if ((argc < 2) || strcmp(argv[1],opt))
+        return false;
+      if (argc == 2) {
+        std::cerr << "Missing argument for option \"" << opt << "\"" << std::endl;
+        exit(EXIT_FAILURE);
+      }
+      cur = static_cast<unsigned int>(atoi(argv[2]));
+      // Remove options
+      argc -= 2;
+      for (int i=1; i<argc; i++)
+        argv[i] = argv[i+2];
+      return true;
+    }
+    
+    void
+    UnsignedIntOption::help(void) {
+      using namespace std;
+      cerr << '\t' << opt << " (unsigned int) default: " << cur << endl
+           << "\t\t" << exp << endl;
+    }
+  
+
+    bool
+    DoubleOption::parse(int& argc, char* argv[]) {
+      if ((argc < 2) || strcmp(argv[1],opt))
+        return false;
+      if (argc == 2) {
+        std::cerr << "Missing argument for option \"" << opt << "\"" << std::endl;
+        exit(EXIT_FAILURE);
+      }
+      cur = atof(argv[2]);
+      // Remove options
+      argc -= 2;
+      for (int i=1; i<argc; i++)
+        argv[i] = argv[i+2];
+      return true;
+    }
+    
+    void
+    DoubleOption::help(void) {
+      using namespace std;
+      cerr << '\t' << opt << " (double) default: " << cur << endl
+           << "\t\t" << exp << endl;
+    }
+
+    bool
+    BoolOption::parse(int& argc, char* argv[]) {
+      if ((argc < 2) || strcmp(argv[1],opt)) {
+        return false;
+      }
+      // Remove options
+      argc--;
+      for (int i=1; i<argc; i++)
+        argv[i] = argv[i+1];
+      cur = true;
+      return true;
+    }
+
+    void 
+    BoolOption::help(void) {
+      using namespace std;
+      cerr << '\t' << opt << endl << "\t\t" << exp << endl;
+    }
+
+  
+  }
+
+  BaseOptions::BaseOptions(const char* n)
+    : fst(NULL), lst(NULL), 
+      _name(Driver::BaseOption::strdup(n)) {}
+
+  void
+  BaseOptions::name(const char* n) {
+    Driver::BaseOption::strdel(_name);
+    _name = Driver::BaseOption::strdup(n);
+  }
+
+  void
+  BaseOptions::help(void) {
+    std::cerr << "Gecode configuration information:" << std::endl
+              << " - Version: " << GECODE_VERSION << std::endl
+              << " - Variable types: ";
+#ifdef GECODE_HAS_INT_VARS
+    std::cerr << "BoolVar IntVar ";
+#endif
+#ifdef GECODE_HAS_SET_VARS
+    std::cerr << "SetVar";
+#endif
+    std::cerr << std::endl
+              << " - Thread support: ";
+#ifdef GECODE_HAS_THREADS
+    if (Support::Thread::npu() == 1)
+      std::cerr << "enabled (1 processing unit)";
+    else
+      std::cerr << "enabled (" << Support::Thread::npu() 
+                << " processing units)";
+#else
+    std::cerr << "disabled";
+#endif
+    std::cerr << std::endl
+              << " - Gist support: ";
+#ifdef GECODE_HAS_GIST
+    std::cerr << "enabled";
+#else
+    std::cerr << "disabled";
+#endif
+    std::cerr << std::endl << std::endl
+              << "Options for " << name() << ":" << std::endl
+              << "\t-help, --help, -?" << std::endl
+              << "\t\tprint this help message" << std::endl;
+    for (Driver::BaseOption* o = fst; o != NULL; o = o->next)
+      o->help();
+  }
+
+  void
+  BaseOptions::parse(int& argc, char* argv[]) {
+  next:
+    for (Driver::BaseOption* o = fst; o != NULL; o = o->next)
+      if (o->parse(argc,argv))
+        goto next;
+    if (argc < 2)
+      return;
+    if (!strcmp(argv[1],"-help") || !strcmp(argv[1],"--help") ||
+        !strcmp(argv[1],"-?")) {
+      help();
+      exit(EXIT_SUCCESS);
+    }
+    return;
+  }
+  
+  BaseOptions::~BaseOptions(void) {
+    Driver::BaseOption::strdel(_name);
+  }
+
+
+  Options::Options(const char* n)
+    : BaseOptions(n),
+      
+      _model("-model","model variants"),
+      _symmetry("-symmetry","symmetry variants"),
+      _propagation("-propagation","propagation variants"),
+      _icl("-icl","integer consistency level",ICL_DEF),
+      _branching("-branching","branching variants"),
+      
+      _search("-search","search engine variants"),
+      _solutions("-solutions","number of solutions (0 = all)",1),
+      _threads("-threads","number of threads (0 = #processing units)",
+               Search::Config::threads),
+      _c_d("-c-d","recomputation commit distance",Search::Config::c_d),
+      _a_d("-a-d","recomputation adaptation distance",Search::Config::a_d),
+      _node("-node","node cutoff (0 = none, solution mode)"),
+      _fail("-fail","failure cutoff (0 = none, solution mode)"),
+      _time("-time","time (in ms) cutoff (0 = none, solution mode)"),
+      _interrupt("-interrupt","whether to catch Ctrl-C (true) or not (false)", true),
+      
+      _mode("-mode","how to execute script",SM_SOLUTION),
+      _samples("-samples","how many samples (time mode)",1),
+      _iterations("-iterations","iterations per sample (time mode)",1)
+  {
+    
+    _icl.add(ICL_DEF, "def"); _icl.add(ICL_VAL, "val");
+    _icl.add(ICL_BND, "bnd"); _icl.add(ICL_DOM, "dom");
+    
+    _mode.add(SM_SOLUTION, "solution");
+    _mode.add(SM_TIME, "time");
+    _mode.add(SM_STAT, "stat");
+    _mode.add(SM_GIST, "gist");
+    
+    _interrupt.add(false, "false");
+    _interrupt.add(true, "true");
+    
+    add(_model); add(_symmetry); add(_propagation); add(_icl); 
+    add(_branching);
+    add(_search); add(_solutions); add(_threads); add(_c_d); add(_a_d);
+    add(_node); add(_fail); add(_time); add(_interrupt);
+    add(_mode); add(_iterations); add(_samples);
+  }
+
+  
+  SizeOptions::SizeOptions(const char* e)
+    : Options(e), _size(0) {}
+  
+  void
+  SizeOptions::help(void) {
+    Options::help();
+    std::cerr << "\t(unsigned int) default: " << size() << std::endl
+              << "\t\twhich version/size for script" << std::endl;
+  }
+
+  void
+  SizeOptions::parse(int& argc, char* argv[]) {
+    Options::parse(argc,argv);
+    if (argc < 2)
+      return;
+    size(static_cast<unsigned int>(atoi(argv[1])));
+  }
+
+
+
+  InstanceOptions::InstanceOptions(const char* e)
+    : Options(e), _inst(NULL) {}
+  
+  void
+  InstanceOptions::instance(const char* s) {
+    Driver::BaseOption::strdel(_inst);
+    _inst = strdup(s);
+  }
+
+  void
+  InstanceOptions::help(void) {
+    Options::help();
+    std::cerr << "\t(string) default: " << instance() << std::endl
+              << "\t\twhich instance for script" << std::endl;
+  }
+
+  void
+  InstanceOptions::parse(int& argc, char* argv[]) {
+    Options::parse(argc,argv);
+    if (argc < 2)
+      return;
+    instance(argv[1]);
+  }
+
+  InstanceOptions::~InstanceOptions(void) {
+    Driver::BaseOption::strdel(_inst);
+  }
+
+}
+
+// STATISTICS: driver-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/driver/options.hpp

@@ -0,0 +1,418 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2011-02-22 23:52:12 +1100 (Tue, 22 Feb 2011) $ by $Author: schulte $
+ *     $Revision: 11766 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <cstring>
+
+namespace Gecode {
+
+  namespace Driver {
+    /*
+     * String option
+     *
+     */
+    inline
+    StringValueOption::StringValueOption(const char* o, const char* e, 
+                                         const char* v)
+      : BaseOption(o,e), cur(strdup(v)) {}
+    inline void
+    StringValueOption::value(const char* v) {
+      strdel(cur);
+      cur = strdup(v);
+    }
+    inline const char*
+    StringValueOption::value(void) const {
+      return cur;
+    }
+
+    /*
+     * String option
+     *
+     */
+    inline
+    StringOption::StringOption(const char* o, const char* e, int v)
+      : BaseOption(o,e), cur(v), fst(NULL), lst(NULL) {}
+    inline void
+    StringOption::value(int v) {
+      cur = v;
+    }
+    inline int
+    StringOption::value(void) const {
+      return cur;
+    }
+    
+    /*
+     * Integer option
+     *
+     */
+    inline
+    IntOption::IntOption(const char* o, const char* e, int v)
+      : BaseOption(o,e), cur(v) {}
+    inline void
+    IntOption::value(int v) {
+      cur = v;
+    }
+    inline int
+    IntOption::value(void) const {
+      return cur;
+    }
+
+    /*
+     * Unsigned integer option
+     *
+     */
+    inline
+    UnsignedIntOption::UnsignedIntOption(const char* o, const char* e,
+                                         unsigned int v)
+      : BaseOption(o,e), cur(v) {}
+    inline void
+    UnsignedIntOption::value(unsigned int v) {
+      cur = v;
+    }
+    inline unsigned int
+    UnsignedIntOption::value(void) const {
+      return cur;
+    }
+
+    /*
+     * Double option
+     *
+     */
+    inline
+    DoubleOption::DoubleOption(const char* o, const char* e,
+                               unsigned int v)
+      : BaseOption(o,e), cur(v) {}
+    inline void
+    DoubleOption::value(double v) {
+      cur = v;
+    }
+    inline double
+    DoubleOption::value(void) const {
+      return cur;
+    }
+
+    /*
+     * Bool option
+     *
+     */
+    inline
+    BoolOption::BoolOption(const char* o, const char* e) 
+      : BaseOption(o,e), cur(false) {}
+    inline void
+    BoolOption::value(bool v) {
+      cur = v;
+    }
+    inline bool
+    BoolOption::value(void) const {
+      return cur;
+    }
+
+
+  }
+  
+  /*
+   * Options
+   *
+   */
+  inline void
+  BaseOptions::add(Driver::BaseOption& o) {
+    o.next = NULL;
+    if (fst == NULL) {
+      fst=&o;
+    } else {
+      lst->next=&o;
+    }
+    lst=&o;
+  }
+  inline const char*
+  BaseOptions::name(void) const {
+    return _name;
+  }
+
+
+
+  /*
+   * Model options
+   *
+   */
+  inline void
+  Options::model(int v) {
+    _model.value(v);
+  }
+  inline void
+  Options::model(int v, const char* o, const char* h) {
+    _model.add(v,o,h);
+  }
+  inline int
+  Options::model(void) const {
+    return _model.value();
+  }
+  
+  inline void
+  Options::symmetry(int v) {
+    _symmetry.value(v);
+  }
+  inline void
+  Options::symmetry(int v, const char* o, const char* h) {
+    _symmetry.add(v,o,h);
+  }
+  inline int
+  Options::symmetry(void) const {
+    return _symmetry.value();
+  }
+  
+  inline void
+  Options::propagation(int v) {
+    _propagation.value(v);
+  }
+  inline void
+  Options::propagation(int v, const char* o, const char* h) {
+    _propagation.add(v,o,h);
+  }
+  inline int
+  Options::propagation(void) const {
+    return _propagation.value();
+  }
+  
+  inline void
+  Options::icl(IntConLevel i) {
+    _icl.value(i);
+  }
+  inline IntConLevel
+  Options::icl(void) const {
+    return static_cast<IntConLevel>(_icl.value());
+  }
+  
+  inline void
+  Options::branching(int v) {
+    _branching.value(v);
+  }
+  inline void
+  Options::branching(int v, const char* o, const char* h) {
+    _branching.add(v,o,h);
+  }
+  inline int
+  Options::branching(void) const {
+    return _branching.value();
+  }
+  
+  /*
+   * Search options
+   *
+   */
+  inline void
+  Options::search(int v) {
+    _search.value(v);
+  }
+  inline void
+  Options::search(int v, const char* o, const char* h) {
+    _search.add(v,o,h);
+  }
+  inline int
+  Options::search(void) const {
+    return _search.value();
+  }
+  
+  inline void
+  Options::solutions(unsigned int n) {
+    _solutions.value(n);
+  }
+  inline unsigned int
+  Options::solutions(void) const {
+    return _solutions.value();
+  }
+  
+  inline void
+  Options::threads(double n) {
+    _threads.value(n);
+  }
+  inline double
+  Options::threads(void) const {
+    return _threads.value();
+  }
+  
+  inline void
+  Options::c_d(unsigned int d) {
+    _c_d.value(d);
+  }
+  inline unsigned int
+  Options::c_d(void) const {
+    return _c_d.value();
+  }
+  
+  inline void
+  Options::a_d(unsigned int d) {
+    _a_d.value(d);
+  }
+  inline unsigned int
+  Options::a_d(void) const {
+    return _a_d.value();
+  }
+  
+  inline void
+  Options::node(unsigned int n) {
+    _node.value(n);
+  }
+  inline unsigned int
+  Options::node(void) const {
+    return _node.value();
+  }
+  
+  inline void
+  Options::fail(unsigned int n) {
+    _fail.value(n);
+  }
+  inline unsigned int
+  Options::fail(void) const {
+    return _fail.value();
+  }
+  
+  inline void
+  Options::time(unsigned int t) {
+    _time.value(t);
+  }
+  inline unsigned int
+  Options::time(void) const {
+    return _time.value();
+  }
+  
+  inline void
+  Options::interrupt(bool b) {
+    _interrupt.value(b);
+  }
+  inline bool
+  Options::interrupt(void) const {
+    return static_cast<bool>(_interrupt.value());
+  }
+  
+  
+  /*
+   * Execution options
+   *
+   */
+  inline void
+  Options::mode(ScriptMode sm) {
+    _mode.value(sm);
+  }
+  inline ScriptMode
+  Options::mode(void) const {
+    return static_cast<ScriptMode>(_mode.value());
+  }
+  
+  inline void
+  Options::iterations(unsigned int i) {
+    _iterations.value(i);
+  }
+  inline unsigned int
+  Options::iterations(void) const {
+    return _iterations.value();
+  }
+  
+  inline void
+  Options::samples(unsigned int s) {
+    _samples.value(s);
+  }
+  inline unsigned int
+  Options::samples(void) const {
+    return _samples.value();
+  }
+
+#ifdef GECODE_HAS_GIST
+  forceinline
+  Options::_I::_I(void) : _click(heap,1), n_click(0),
+    _solution(heap,1), n_solution(0), _move(heap,1), n_move(0),
+    _compare(heap,1), n_compare(0) {}
+
+  forceinline void
+  Options::_I::click(Gist::Inspector* i) {
+    _click[static_cast<int>(n_click++)] = i;
+  }
+  forceinline void
+  Options::_I::solution(Gist::Inspector* i) {
+    _solution[static_cast<int>(n_solution++)] = i;
+  }
+  forceinline void
+  Options::_I::move(Gist::Inspector* i) {
+    _move[static_cast<int>(n_move++)] = i;
+  }
+  forceinline void
+  Options::_I::compare(Gist::Comparator* i) {
+    _compare[static_cast<int>(n_compare++)] = i;
+  }
+  forceinline Gist::Inspector*
+  Options::_I::click(unsigned int i) const {
+    return (i < n_click) ? _click[i] : NULL;
+  }
+  forceinline Gist::Inspector*
+  Options::_I::solution(unsigned int i) const {
+    return (i < n_solution) ? _solution[i] : NULL;
+  }
+  forceinline Gist::Inspector*
+  Options::_I::move(unsigned int i) const {
+    return (i < n_move) ? _move[i] : NULL;
+  }
+  forceinline Gist::Comparator*
+  Options::_I::compare(unsigned int i) const {
+    return (i < n_compare) ? _compare[i] : NULL;
+  }
+#endif
+
+  /*
+   * Options with additional size argument
+   *
+   */
+  inline void
+  SizeOptions::size(unsigned int s) {
+    _size = s;
+  }
+  inline unsigned int
+  SizeOptions::size(void) const {
+    return _size;
+  }
+  
+  /*
+   * Options with additional string argument
+   *
+   */
+  inline const char*
+  InstanceOptions::instance(void) const {
+    return _inst;
+  }
+  
+}
+
+// STATISTICS: driver-any