driver.hh

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Christian Schulte <schulte@gecode.org>
 *
 *  Copyright:
 *     Christian Schulte, 2009
 *
 *  Last modified:
 *     $Date: 2013-02-26 14:40:29 +0100 (Tue, 26 Feb 2013) $ by $Author: schulte $
 *     $Revision: 13419 $
 *
 *  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.
 *
 */

#ifndef __GECODE_DRIVER_HH__
#define __GECODE_DRIVER_HH__

#include <gecode/minimodel.hh>
#include <gecode/search.hh>
#ifdef GECODE_HAS_GIST
#include <gecode/gist.hh>
#endif

/*
 * Configure linking
 *
 */
#if !defined(GECODE_STATIC_LIBS) && \
    (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))

#ifdef GECODE_BUILD_DRIVER
#define GECODE_DRIVER_EXPORT __declspec( dllexport )
#else
#define GECODE_DRIVER_EXPORT __declspec( dllimport )
#endif

#else

#ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
#define GECODE_DRIVER_EXPORT __attribute__ ((visibility("default")))
#else
#define GECODE_DRIVER_EXPORT
#endif

#endif

// Configure auto-linking
#ifndef GECODE_BUILD_DRIVER
#define GECODE_LIBRARY_NAME "Driver"
#include <gecode/support/auto-link.hpp>
#endif

namespace Gecode {


  enum ScriptMode {
    SM_SOLUTION, 
    SM_TIME,     
    SM_STAT,     
    SM_GIST      
  };

  enum RestartMode {
    RM_NONE,     
    RM_CONSTANT, 
    RM_LINEAR,   
    RM_LUBY,     
    RM_GEOMETRIC 
  };

  class BaseOptions;

  namespace Driver {
    class GECODE_DRIVER_EXPORT BaseOption {
      friend class Gecode::BaseOptions;
    protected:
      const char* opt;  
      const char* exp;  
      BaseOption* next; 

      char* argument(int argc, char* argv[]) const;
    public:
      BaseOption(const char* o, const char* e);
      virtual int parse(int argc, char* argv[]) = 0;
      virtual void help(void) = 0;
      virtual ~BaseOption(void);
      static char* strdup(const char* s);
      static void strdel(const char* s);
    };
    
    class GECODE_DRIVER_EXPORT StringValueOption : public BaseOption {
    protected:
      const char* cur; 
    public:
      StringValueOption(const char* o, const char* e, const char* v=NULL);
      void value(const char* v);
      const char* value(void) const;
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
      virtual ~StringValueOption(void);
    };
  

    class GECODE_DRIVER_EXPORT StringOption : public BaseOption {
    protected:
      class Value {
      public:
        int         val;  
        const char* opt;  
        const char* help; 
        Value*      next; 
      };
      int    cur; 
      Value* fst; 
      Value* lst; 
    public:
      StringOption(const char* o, const char* e, int v=0);
      void value(int v);
      int value(void) const;
      void add(int v, const char* o, const char* h = NULL);
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
      virtual ~StringOption(void);
    };
  

    class GECODE_DRIVER_EXPORT IntOption : public BaseOption {
    protected:
      int cur; 
    public:
      IntOption(const char* o, const char* e, int v=0);
      void value(int v);
      int value(void) const;
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
    };

    class GECODE_DRIVER_EXPORT UnsignedIntOption : public BaseOption {
    protected:
      unsigned int cur; 
    public:
      UnsignedIntOption(const char* o, const char* e, unsigned int v=0);
      void value(unsigned int v);
      unsigned int value(void) const;
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
    };

    class GECODE_DRIVER_EXPORT DoubleOption : public BaseOption {
    protected:
      double cur; 
    public:
      DoubleOption(const char* o, const char* e, double v=0);
      void value(double v);
      double value(void) const;
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
    };

    class GECODE_DRIVER_EXPORT BoolOption : public BaseOption {
    protected:
      bool cur; 
    public:
      BoolOption(const char* o, const char* e, bool v=false);
      void value(bool v);
      bool value(void) const;
      virtual int parse(int argc, char* argv[]);
      virtual void help(void);
    };

  }
  
  class GECODE_DRIVER_EXPORT BaseOptions {
  protected:
    Driver::BaseOption* fst;   
    Driver::BaseOption* lst;   
    const char* _name; 
  public:
    BaseOptions(const char* s);
    virtual void help(void);

    void add(Driver::BaseOption& o);
    void parse(int& argc, char* argv[]);
    
    const char* name(void) const;
    void name(const char*);

    virtual ~BaseOptions(void);
  };
  
  class GECODE_DRIVER_EXPORT Options : public BaseOptions {
  protected:    

    Driver::StringOption _model;       
    Driver::StringOption _symmetry;    
    Driver::StringOption _propagation; 
    Driver::StringOption _icl;         
    Driver::StringOption _branching;   
    Driver::DoubleOption _decay;       

    

    Driver::StringOption      _search;    
    Driver::UnsignedIntOption _solutions; 
    Driver::DoubleOption      _threads;   
    Driver::UnsignedIntOption _c_d;       
    Driver::UnsignedIntOption _a_d;       
    Driver::UnsignedIntOption _node;      
    Driver::UnsignedIntOption _fail;      
    Driver::UnsignedIntOption _time;      
    Driver::StringOption      _restart;   
    Driver::DoubleOption      _r_base;    
    Driver::UnsignedIntOption _r_scale;   
    Driver::BoolOption        _interrupt; 

    

    Driver::StringOption      _mode;       
    Driver::UnsignedIntOption _samples;    
    Driver::UnsignedIntOption _iterations; 
    Driver::BoolOption        _print_last; 
    Driver::StringValueOption _out_file;   
    Driver::StringValueOption _log_file;   


  public:
    Options(const char* s);
    


    void model(int v);
    void model(int v, const char* o, const char* h = NULL);
    int model(void) const;
    
    void symmetry(int v);
    void symmetry(int v, const char* o, const char* h = NULL);
    int symmetry(void) const;
    
    void propagation(int v);
    void propagation(int v, const char* o, const char* h = NULL);
    int propagation(void) const;
    
    void icl(IntConLevel i);
    IntConLevel icl(void) const;
    
    void branching(int v);
    void branching(int v, const char* o, const char* h = NULL);
    int branching(void) const;

    void decay(double d);
    double decay(void) const;
    


    void search(int v);
    void search(int v, const char* o, const char* h = NULL);
    int search(void) const;
    
    void solutions(unsigned int n);
    unsigned int solutions(void) const;

    void threads(double n);
    double threads(void) const;
    
    void c_d(unsigned int d);
    unsigned int c_d(void) const;
    
    void a_d(unsigned int d);
    unsigned int a_d(void) const;
    
    void node(unsigned int n);
    unsigned int node(void) const;
    
    void fail(unsigned int n);
    unsigned int fail(void) const;
    
    void time(unsigned int t);
    unsigned int time(void) const;
    
    void restart(RestartMode r);
    RestartMode restart(void) const;
    
    void restart_base(double base);
    double restart_base(void) const;
    
    void restart_scale(unsigned int scale);
    unsigned int restart_scale(void) const;
    
    void interrupt(bool b);
    bool interrupt(void) const;



    void mode(ScriptMode em);
    ScriptMode mode(void) const;
    
    void samples(unsigned int s);
    unsigned int samples(void) const;

    void iterations(unsigned int i);
    unsigned int iterations(void) const;
    
    void print_last(bool p);
    bool print_last(void) const;

    void out_file(const char* f);
    const char* out_file(void) const;

    void log_file(const char* f);
    const char* log_file(void) const;

#ifdef GECODE_HAS_GIST

    class _I {
    private:
      Support::DynamicArray<Gist::Inspector*,Heap> _click;
      unsigned int n_click;
      Support::DynamicArray<Gist::Inspector*,Heap> _solution;
      unsigned int n_solution;
      Support::DynamicArray<Gist::Inspector*,Heap> _move;
      unsigned int n_move;
      Support::DynamicArray<Gist::Comparator*,Heap> _compare;
      unsigned int n_compare;
    public:
      _I(void);
      void click(Gist::Inspector* i);
      void solution(Gist::Inspector* i);
      void move(Gist::Inspector* i);
      void compare(Gist::Comparator* i);
      
      Gist::Inspector* click(unsigned int i) const;
      Gist::Inspector* solution(unsigned int i) const;
      Gist::Inspector* move(unsigned int i) const;
      Gist::Comparator* compare(unsigned int i) const;
    } inspect;
#endif
  };

  class GECODE_DRIVER_EXPORT SizeOptions : public Options {
  protected:
    unsigned int _size; 
  public:
    SizeOptions(const char* s);
    virtual void help(void);
    void parse(int& argc, char* argv[]);
    
    void size(unsigned int s);
    unsigned int size(void) const;
  };

  class GECODE_DRIVER_EXPORT InstanceOptions : public Options {
  protected:
    const char* _inst; 
  public:
    InstanceOptions(const char* s);
    virtual void help(void);
    void parse(int& argc, char* argv[]);
    
    void instance(const char* s);
    const char* instance(void) const;
    ~InstanceOptions(void);
  };

}

#include <gecode/driver/options.hpp>

namespace Gecode {

  namespace Driver {
    template<class BaseSpace>
    class ScriptBase : public BaseSpace {
    public:
      ScriptBase(void) {}
      ScriptBase(bool share, ScriptBase& e) : BaseSpace(share,e) {}
      virtual void print(std::ostream& os) const { (void) os; }
      virtual void compare(const Space&, std::ostream& os) const {
        (void) os;
      }
      static std::ostream& select_ostream(const char* name, std::ofstream& ofs);
      template<class Script, template<class> class Engine, class Options>
      static void run(const Options& opt, Script* s=NULL);
    private:
      template<class Script, template<class> class Engine, class Options,
               template<template<class> class,class> class Meta>
      static void runMeta(const Options& opt, Script* s);
      explicit ScriptBase(ScriptBase& e);
    };
  }
  
  typedef Driver::ScriptBase<Space> Script;
  typedef Driver::ScriptBase<MinimizeSpace> MinimizeScript;
  typedef Driver::ScriptBase<MaximizeSpace> MaximizeScript;

}

#include <gecode/driver/script.hpp>

#endif

// STATISTICS: driver-any