---

dag_delta.h

Go to the documentation of this file.

// DAG Delta implementation -*- C++ -*-

// Copyright (C) 2001-2003 Hermann Schichl
//
// This file is part of the COCONUT API.  This library
// is free software; you can redistribute it and/or modify it under the
// terms of the Library GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// Library GNU General Public License for more details.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the Library GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the Library GNU General Public License.

#ifndef _DAG_DELTA_H_
#define _DAG_DELTA_H_

#include <api_delta.h>

class dag_undelta : public undelta_base
{
private:
  typedef model::walker walker;

public:
  gptr<model>* old_model;               // complete model for full update

  counted_ptr<model> rm_dag;            // removed nodes and edges
  std::vector<model::enhanced_edge> rm_e;

  std::vector<walker> added_nodes;      // the nodes to be removed
  std::vector<walker> added_constraints;// the constraints to be removed
  std::vector<walker> added_ghosts;     // the ghosts to be removed
  std::vector<walker> added_vars;       // the variables to be removed

  std::map<unsigned int, interval> bounds_chgd; // the bounds by ghosts

  bool is_full_undelta;                 // was full delta

private:
  class __check_walkers
  {
  private:
    const std::vector<walker>& nr;

  public:
    __check_walkers(const std::vector<walker>& __nr) : nr(__nr) {}

    bool operator()(const walker& _w) const
    {
      std::vector<walker>::const_iterator __x(nr.begin()), __e(nr.end());
      for(; __x != __e; ++__x)
        if(_w == *__x)
          return false;
      return true;
    }
  };

public:
  dag_undelta(bool full=false) : undelta_base(),
                                 old_model(NULL),
                                 rm_dag(), rm_e(),
                                 added_nodes(), added_constraints(),
                                 added_ghosts(), added_vars(),
                                 bounds_chgd(), is_full_undelta(full)
      {}

  dag_undelta(gptr<model>* __nc) : undelta_base(),
                                   old_model(__nc),
                                   rm_dag(), rm_e(),
                                   added_nodes(), added_constraints(),
                                   added_ghosts(), added_vars(),
                                   bounds_chgd(), is_full_undelta(true)
      {}

  dag_undelta(const dag_undelta& _du) : undelta_base(_du),
                                   old_model(_du.old_model),
                                   rm_dag(_du.rm_dag), rm_e(_du.rm_e),
                                   added_nodes(_du.added_nodes),
                                   added_constraints(_du.added_constraints),
                                   added_ghosts(_du.added_ghosts),
                                   added_vars(_du.added_vars),
                                   bounds_chgd(_du.bounds_chgd),
                                   is_full_undelta(_du.is_full_undelta)
      {
#if DEBUG_DELTA
        std::cerr << "Called dag_undelta copy constructor" << std::endl;
#endif
      }

  ~dag_undelta() { if(old_model) delete old_model; }

  dag_undelta* new_copy() const { return new dag_undelta(*this); }
  void destroy_copy(dag_undelta* __d) { delete __d; }

  bool unapply(work_node& x) const;

  friend class dag_delta;
};

class dag_delta : public delta_base
{
private:
  typedef model::walker walker;

public:
  counted_ptr<model> new_constraints;   // dags referring to ghost nodes

  std::vector<walker> rm_nodes;         // nodes that need to be removed
                                        // in the model

  bool is_full_delta;                   // this means that new_constraints
                                        // is a full model which completely
                                        // replaces old_constraints

  dag_delta(const std::string& __a, bool full=false) :
                                    delta_base(__a), new_constraints(),
                                    rm_nodes(), is_full_delta(full)
      {}

  dag_delta(const std::string& __a, model* __nc, bool full=false) :
                                    delta_base(__a),
                                    new_constraints(__nc),
                                    rm_nodes(), is_full_delta(full)
      {}

  dag_delta(const dag_delta& __d) : delta_base(__d),
                                    new_constraints(__d.new_constraints),
                                    rm_nodes(__d.rm_nodes),
                                    is_full_delta(__d.is_full_delta)
      {
#if DEBUG_DELTA
        std::cerr << "Called dag_delta copy constructor" << std::endl;
#endif
      }

  ~dag_delta() {}

  dag_delta* new_copy() const { return new dag_delta(*this); }
  void destroy_copy(dag_delta* __d) { delete __d; }

  void add_new(model* __m) { new_constraints = __m; }
  void add_new(model& __m) { new_constraints = new model(__m); }

  void remove(const walker& _nn) { rm_nodes.push_back(_nn); }
  void remove(const std::vector<walker>& _nn)
    { rm_nodes.insert(rm_nodes.end(), _nn.begin(), _nn.end()); }

private:
  void help_apply_p(work_node& x, model::walker& _x, model* nm) const;
  void help_apply_s(work_node& x, model* nm) const;
  void help_apply_c(work_node& x, model::walker& _x, model* nm) const;
  void help_apply_g(work_node& x, model* nm) const;

  struct __docompare_nodes
  {
    bool operator() (const model::walker& _a, unsigned int _b) const
       {return _a->node_num < _b;}
    bool operator() (unsigned int _a, const model::walker& _b) const
       {return _a < _b->node_num;}
  };
  
  class __check_nodes
  {
  private:
    const std::vector<walker>& nr;

  public:
    __check_nodes(const std::vector<walker>& __nr) : nr(__nr) {}

    bool operator()(const walker& _w) const
    {
      std::vector<walker>::const_iterator
              __x(lower_bound(nr.begin(), nr.end(),
                              _w->node_num, __docompare_nodes()));
      if(__x != nr.end() && (*__x)->node_num == _w->node_num)
        return false;
      else
        return true;
    }
  };

public:
  bool apply(work_node& x, undelta_base*& _u) const;

  friend class dag_undelta;
};

#endif /* _DAG_DELTA_H_ */

---