support.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, 2007
 *
 *  Last modified:
 *     $Date: 2008-07-11 10:47:54 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
 *     $Revision: 7347 $
 *
 *  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_EXAMPLES_SUPPORT_HH__
#define __GECODE_EXAMPLES_SUPPORT_HH__

#include "gecode/kernel.hh"
#include "gecode/int.hh"
#include "gecode/search.hh"

#ifdef GECODE_HAS_GIST
#include "gecode/gist.hh"
#endif

using namespace Gecode;

/*
 * Options for running the examples
 *
 */

enum ExampleMode {
  EM_SOLUTION, 
  EM_TIME,     
  EM_STAT      
#ifdef GECODE_HAS_GIST
  ,
  EM_GIST      
#endif
};

class Options;

class BaseOption {
  friend class Options;
protected:
  const char* opt;  
  const char* exp;  
  BaseOption* next; 
public:
  BaseOption(const char* o, const char* e);
  virtual bool parse(int& argc, char* argv[]) = 0;
  virtual void help(void) = 0;
  virtual ~BaseOption(void);
};

class 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 bool parse(int& argc, char* argv[]);
  virtual void help(void);
  virtual ~StringOption(void);
};


class 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 bool parse(int& argc, char* argv[]);
  virtual void help(void);
};


class Options {
protected:
  BaseOption* fst;   
  BaseOption* lst;   
  const char* _name; 


  StringOption _model;       
  StringOption _propagation; 
  StringOption _pk;          
  StringOption _icl;         
  StringOption _branching;   



  StringOption      _search;    
  UnsignedIntOption _solutions; 
  UnsignedIntOption _c_d;       
  UnsignedIntOption _a_d;       
  UnsignedIntOption _fail;      
  UnsignedIntOption _time;      



  StringOption      _mode;       
  UnsignedIntOption _samples;    
  UnsignedIntOption _iterations; 


public:
  Options(const char* s);
  void add(BaseOption& o);
  virtual void help(void);
  void parse(int& argc, char* argv[]);

  const char* name(void) const;



  void model(int v);
  void model(int v, const char* o, const char* h = NULL);
  int model(void) const;

  void propagation(int v);
  void propagation(int v, const char* o, const char* h = NULL);
  int propagation(void) const;

  void pk(PropKind p);
  PropKind pk(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 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 c_d(unsigned int d);
  unsigned int c_d(void) const;

  void a_d(unsigned int d);
  unsigned int a_d(void) const;

  void fail(unsigned int n);
  unsigned int fail(void) const;

  void time(unsigned int t);
  unsigned int time(void) const;



  void mode(ExampleMode em);
  ExampleMode mode(void) const;  

  void iterations(unsigned int i);
  unsigned int iterations(void) const;

  void samples(unsigned int s);
  unsigned int samples(void) const;

  virtual ~Options(void);
};

class 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;
};

#include "examples/support/options.icc"


class Example : public Space {
public:
  Example(void) {}
  Example(bool share, Example& e) : Space(share,e) {}
  virtual void print(std::ostream& os) { (void)os; }
  template <class Script, template<class> class Engine, class Options>
  static void run(const Options& opt);
 private:
  explicit Example(Example& e);
};

#include "examples/support/example.icc"

#endif

// STATISTICS: example-any