task.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
 *
 *  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_INT_TASK_HH__
#define __GECODE_INT_TASK_HH__

#include <gecode/int.hh>

namespace Gecode { namespace Int {

  template<class ManTask>
  class ManToOptTask : public ManTask {
  protected:
    Int::BoolView _m;
  public:


    ManToOptTask(void);



    bool mandatory(void) const;
    bool excluded(void) const;
    bool optional(void) const;


    bool assigned(void) const;



    ModEvent mandatory(Space& home);
    ModEvent excluded(Space& home);



    void update(Space& home, ManToOptTask& t);



    void subscribe(Space& home, Propagator& p, PropCond pc);
    void cancel(Space& home, Propagator& p, PropCond pc);
    void reschedule(Space& home, Propagator& p, PropCond pc);
  };

}}

#include <gecode/int/task/man-to-opt.hpp>

namespace Gecode { namespace Int {

  template<class TaskView>
  class FwdToBwd : public TaskView {
  public:


    int est(void) const;
    int ect(void) const;
    int lst(void) const;
    int lct(void) const;
    int pmin(void) const;
    int pmax(void) const;



    ModEvent est(Space& home, int n);
    ModEvent ect(Space& home, int n);
    ModEvent lst(Space& home, int n);
    ModEvent lct(Space& home, int n);
    ModEvent norun(Space& home, int e, int l);
  };

}}

#include <gecode/int/task/fwd-to-bwd.hpp>

namespace Gecode { namespace Int {

  template<class TaskView>
  class TaskViewTraits {};

  template<class Task>
  class TaskTraits {};

}}

namespace Gecode { namespace Int {

  template<class Task>
  class TaskArray {
  private:
    int n;
    Task* t;
  public:


    TaskArray(void);
    TaskArray(Space& home, int n);
    TaskArray(const TaskArray<Task>& a);
    const TaskArray<Task>& operator =(const TaskArray<Task>& a);



    int size(void) const;
    void size(int n);



    Task& operator [](int i);
    const Task& operator [](int i) const;



    void subscribe(Space& home, Propagator& p, PropCond pc=Int::PC_INT_BND);
    void cancel(Space& home, Propagator& p, PropCond pc=Int::PC_INT_BND);
    void reschedule(Space& home, Propagator& p, PropCond pc=Int::PC_INT_BND);



    void update(Space&, TaskArray& a);

  private:
    static void* operator new(size_t);
    static void  operator delete(void*,size_t);
  };

  template<class Char, class Traits, class Task>
  std::basic_ostream<Char,Traits>&
  operator <<(std::basic_ostream<Char,Traits>& os,
              const TaskArray<Task>& t);


  template<class TaskView>
  class TaskViewArray {
  protected:
    typedef typename TaskViewTraits<TaskView>::Task Task;
    TaskArray<Task>& t;
  public:


    TaskViewArray(TaskArray<Task>& t);



    int size(void) const;
    void size(int n);



    TaskView& operator [](int i);
    const TaskView& operator [](int i) const;
  private:
    static void* operator new(size_t);
    static void  operator delete(void*,size_t);
  };

  template<class Char, class Traits, class TaskView>
  std::basic_ostream<Char,Traits>&
  operator <<(std::basic_ostream<Char,Traits>& os,
              const TaskViewArray<TaskView>& t);

}}

#include <gecode/int/task/array.hpp>

namespace Gecode { namespace Int {

  enum SortTaskOrder {
    STO_EST, 
    STO_ECT, 
    STO_LST, 
    STO_LCT  
  };

  template<class TaskView, SortTaskOrder sto, bool inc>
  void sort(TaskViewArray<TaskView>& t);

  template<class TaskView, SortTaskOrder sto, bool inc>
  void sort(int* map, const TaskViewArray<TaskView>& t);

  template<class TaskView, SortTaskOrder sto, bool inc>
  void sort(int* map, int n, const TaskViewArray<TaskView>& t);

}}

#include <gecode/int/task/sort.hpp>

namespace Gecode { namespace Int {

  template<class TaskView, SortTaskOrder sto, bool inc>
  class TaskViewIter {
  protected:
    int* map;
    int i;
    TaskViewIter(void);
  public:
    TaskViewIter(Region& r, const TaskViewArray<TaskView>& t);


    bool operator ()(void) const;
    int left(void) const;
    void operator ++(void);



    int task(void) const;
  };

  template<class OptTaskView, SortTaskOrder sto, bool inc>
  class ManTaskViewIter : public TaskViewIter<OptTaskView,sto,inc> {
  protected:
    using TaskViewIter<OptTaskView,sto,inc>::map;
    using TaskViewIter<OptTaskView,sto,inc>::i;
  public:
    ManTaskViewIter(Region& r, const TaskViewArray<OptTaskView>& t);
  };

}}

#include <gecode/int/task/iter.hpp>

namespace Gecode { namespace Int {

  int plus(int x, int y);

  long long int plus(long long int x, long long int y);

  double plus(double x, double y);

  template<class TaskView, class Node>
  class TaskTree {
    template<class,class> friend class TaskTree;
  protected:
    const TaskViewArray<TaskView>& tasks;
    Node* node;
    int* _leaf;

    int n_inner(void) const;
    int n_nodes(void) const;
    static bool n_root(int i);
    bool n_leaf(int i) const;
    static int n_left(int i);
    static bool left(int i);
    static int n_right(int i);
    static bool right(int i);
    static int n_parent(int i);
  protected:
    Node& leaf(int i);
    const Node& root(void) const;
    void update(int i, bool l=true);
    void init(void);
    void update(void);
    TaskTree(Region& r, const TaskViewArray<TaskView>& t);
    template<class Node2> TaskTree(Region& r,
                                   const TaskTree<TaskView,Node2>& t);
  };

}}

#include <gecode/int/task/tree.hpp>

namespace Gecode { namespace Int {

  template<class Task, class PL>
  class TaskProp : public Propagator {
  protected:
    TaskArray<Task> t;
    TaskProp(Home home, TaskArray<Task>& t);
    TaskProp(Space& home, TaskProp<Task,PL>& p);
  public:
    virtual PropCost cost(const Space& home, const ModEventDelta& med) const;
    virtual void reschedule(Space& home);
    virtual size_t dispose(Space& home);
  };

  template<class OptTask, class PL>
  ExecStatus purge(Space& home, Propagator& p, TaskArray<OptTask>& t);

  template<class OptTask, class PL, class Cap>
  ExecStatus purge(Space& home, Propagator& p, TaskArray<OptTask>& t, Cap c);

  class PLB {
  public:
    static const bool basic = true;
    static const bool advanced = false;
    static const PropCond pc = PC_INT_DOM;
  };

  class PLA {
  public:
    static const bool basic = false;
    static const bool advanced = true;
    static const PropCond pc = PC_INT_BND;
  };

  class PLBA {
  public:
    static const bool basic = true;
    static const bool advanced = true;
    static const PropCond pc = PC_INT_DOM;
  };

}}

#include <gecode/int/task/prop.hpp>
#include <gecode/int/task/purge.hpp>

namespace Gecode { namespace Int {

  class Event {
  public:
    enum Type {
      LRT = 0, 
      LCT = 1, 
      EST = 2, 
      ZRO = 3, 
      ERT = 4, 
      END = 5  
    };
  protected:
    unsigned int ei;
    int t;
  public:
    void init(Type e, int t, int i);
    Type type(void) const;
    int time(void) const;
    int idx(void) const;
    bool operator <(const Event& e) const;
    template<class Task>
    static Event* events(Region& r, const TaskArray<Task>& t, bool& assigned);
    template<class Task>
    static Event* events(Region& r, const TaskArray<Task>& t);
  };

  template<class Char, class Traits>
  std::basic_ostream<Char,Traits>&
  operator <<(std::basic_ostream<Char,Traits>& os, const Event& e);

}}

#include <gecode/int/task/event.hpp>

#endif

// STATISTICS: int-prop