MP_domain.hpp

Go to the documentation of this file.

// ******************** FlopCpp **********************************************
// File: MP_domain.hpp
// $Id$
// Author: Tim Helge Hultberg (thh@mat.ua.pt)
// Copyright (C) 2003 Tim Helge Hultberg
// All Rights Reserved.
// ****************************************************************************
#ifndef _MP_domain_hpp_
#define _MP_domain_hpp_

#include <vector>
#include <map>
#include "MP_utilities.hpp"
#include "MP_boolean.hpp" 
#include "MP_index.hpp" 

namespace flopc {

  class MP_set_base;
  class MP_set;
  class MP_index;

  template<int nbr> class MP_subset;

  class MP_domain_base : public Functor, public MP_index_base {
    friend class MP_domain;
    friend class Handle<MP_domain_base*>;
    friend MP_domain operator*(const MP_domain& a, const MP_domain& b);
  private:
    int count;
  public:
    MP_domain_base();
    virtual ~MP_domain_base();

    virtual Functor* makeInsertFunctor() const;
    virtual MP_index* getIndex() const = 0;
    virtual const MP_set_base* getSet() const = 0;
    void display()const;
    virtual size_t size() const ;
    const Functor* donext;
  };

  class MP_domain : public Handle<MP_domain_base*> {
    friend MP_domain operator*(const MP_domain& a, const MP_domain& b);
    
    friend class MP_constraint;
    friend class MP_index_exp;
  public:
    MP_domain();
    ~MP_domain();
    MP_domain(MP_domain_base* r);

    MP_domain such_that(const MP_boolean& b);

    void forall(const Functor* op) const;
    void forall(const Functor& op) const;
    size_t size() const;
    static const MP_domain& getEmpty();
  private:
    std::vector<MP_boolean> condition;
    Handle<MP_domain_base*> last;
    static const MP_domain* Empty;
  };

  class MP_domain_set : public MP_domain_base {
  public:
    MP_domain_set(const MP_set* s, MP_index* i);
    void operator()() const;
    int evaluate() const;
    const MP_set_base* getSet() const;
    MP_index* getIndex() const;
    MP_domain getDomain(MP_set* s) const ;
    ~MP_domain_set();
  private:
    const MP_set* S;
    MP_index* I;
  };

  template<int nbr> class MP_domain_subset;

  template<int nbr> class insertFunctor : public Functor {
  public:
    insertFunctor(MP_domain_subset<nbr>* d) : D(d) {}
    void operator()() const { 
      std::vector<int> elm(nbr);
      for (int i=0; i<nbr; i++) {
        elm[i] = D->I[i]->evaluate();
      }
      D->S->insert(elm);
    }
  private:
    MP_domain_subset<nbr>* D;
  };

  template<int nbr> class MP_domain_subset : public MP_domain_base {
    friend class insertFunctor<nbr>;
  public:
    MP_domain_subset<nbr> (MP_subset<nbr>* s, 
                           const std::vector<MP_index*> &i) : S(s), I(i){}

    int evaluate() const {
      return S->evaluate(I);
    }
    MP_set_base* getSet() const {
      return S;
    }
    MP_index* getIndex() const {
      return S;
    }
    MP_domain getDomain(MP_set* s) const {
      return MP_domain(const_cast<MP_domain_subset<nbr>*>(this));
    }
    void operator()() const {
      bool isBound[nbr];
      bool allBound = true;
      for (int j=0; j<nbr; j++) {
        if (I[j]->isInstantiated() == true) {
          isBound[j] = true;
        } else {
          isBound[j] = false;
          allBound = false;
          if (I[j]!=&MP_index::getEmpty()) { 
            I[j]->instantiate();
          }
        }
      }
      if (allBound == true) {
        (*donext)(); 
      } else {
        std::map<std::vector<int>, int>::const_iterator i;
        int counter = 0;
        for (i = S->elements.begin(); i != S->elements.end(); i++) {
          S->assign(counter);
          counter++;
          bool goOn = true;
          for (int j=0; j<nbr; j++) {
            if (isBound[j] == true) {
              if (I[j]->evaluate() != i->first[j]) {
                goOn = false;
                break;
              }
            } else {
              I[j]->assign(i->first[j]);
            }
          }
          if (goOn == true) {
            (*donext)();
          }
        }
      }
      for (int j=0; j<nbr; j++) {
        if (isBound[j] == false) {
          I[j]->assign(0);
          I[j]->unInstantiate();
        }
      }
    }    

    Functor* makeInsertFunctor() const {
      return new insertFunctor<nbr>(
        const_cast<MP_domain_subset<nbr>*>(this));
    }
  private:
    MP_subset<nbr>* S;
    std::vector<MP_index*> I;
  };

  MP_domain operator*(const MP_domain& a, const MP_domain& b);
  
}  // End of namespace flopc
#endif