split_delta.h

Go to the documentation of this file.

// Split Delta implementation -*- C++ -*-

// $Id: split_delta.h 631 2008-05-19 17:38:05Z mihaly $
// 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 _SPLIT_DELTA_H_
#define _SPLIT_DELTA_H_

#include <api_delta.h>
#include <bound_delta.h>

namespace coco {


class split_undelta : public undelta_base
{
private:
  work_node::transaction_number se;

public:
  split_undelta(const work_node::transaction_number& _se) : se(_se) {}

  split_undelta(const split_undelta& _su) : se(_su.se)
      {
#if DEBUG_DELTA
        std::cerr << "Called split_undelta copy constructor" << std::endl;
#endif
      }

  virtual ~split_undelta() {}

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

  bool unapply(work_node& x, const delta_id& _did) const;
};


class split_delta : public delta_base
{
public:
  std::list<std::vector<delta> > splits;// we could also use dag<delta*>
                                        // splits or std::list<delta*> splits
                                        // if trees are not necessary.  

public:
  split_delta() : delta_base("split"), splits() {}
                                // we do not need to keep data for unapply,
                                // because unapplying a split effectively
                                // means to remove the information from the
                                // list of suggested splits

  split_delta(unsigned int _node_num, const interval& _l, const interval& _u)
                                        : delta_base("split"), splits()
      {
        splits.push_back(std::vector<delta>(1,
                                delta(bound_delta(_node_num, _l))));
        splits.push_back(std::vector<delta>(1,
                                delta(bound_delta(_node_num, _u))));
      }

  split_delta(unsigned int _node_num, const std::vector<interval>& _m)
                        : delta_base("split"), splits()
      {
        for(std::vector<interval>::const_iterator __l = _m.begin();
            __l != _m.end(); ++__l)
        {
          splits.push_back(std::vector<delta>(1,
                                delta(bound_delta(_node_num, *__l))));
        }
      }

  split_delta(const std::vector<unsigned int>& _i,
              const std::vector<interval>& _l, const std::vector<interval>& _u)
                        : delta_base("split"), splits()
      {
        splits.push_back(std::vector<delta>(1,delta(bound_delta(_i, _l))));
        splits.push_back(std::vector<delta>(1,delta(bound_delta(_i, _u))));
      }

  split_delta(const std::list<std::vector<delta> >& __dl)
                        : delta_base("split"), splits(__dl)
      {}

  split_delta(const std::vector<unsigned int> nnum,
                    const std::vector<std::pair<interval,interval> >& bds)
                        : delta_base("split"), splits()
      { add_multisplit(nnum, bds); }

  split_delta(const std::vector<unsigned int> nnum,
                    const std::vector<std::vector<interval> >& bds)
                        : delta_base("split"), splits()
      { add_multisplit(nnum, bds); }

  ~split_delta() {}

  split_delta(const split_delta& __s) : delta_base(__s), splits(__s.splits) {}

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

  void add_delta(const delta& __d)
  {
    splits.push_back(std::vector<delta>(1,__d));
  }

  void add_deltas(const std::vector<delta>& __d)
  {
    splits.push_back(__d);
  }
  void add_split(const std::vector<unsigned int>& _i,
                 const std::vector<interval>& _b)
  {
    splits.push_back(std::vector<delta>(1,delta(bound_delta(_i, _b))));
  }


  void add_split(unsigned int _nnum, interval _b)
  {
    splits.push_back(std::vector<delta>(1,delta(bound_delta(_nnum, _b))));
  }

  void add_split(unsigned int _nnum, interval _l, interval _u)
  {
    splits.push_back(std::vector<delta>(1,delta(bound_delta(_nnum, _l))));
    splits.push_back(std::vector<delta>(1,delta(bound_delta(_nnum, _u))));
  }

  void add_split(const std::vector<unsigned int>& _i,
                 const std::vector<interval>& _l,
                 const std::vector<interval>& _u)
  {
    splits.push_back(std::vector<delta>(1,delta(bound_delta(_i, _l))));
    splits.push_back(std::vector<delta>(1,delta(bound_delta(_i, _u))));
  }

  void add_multisplit(const std::vector<unsigned int> nnum,
                    const std::vector<std::pair<interval,interval> >& bds);

  void add_multisplit(const std::vector<unsigned int> nnum,
                    const std::vector<std::vector<interval> >& bds);

  bool apply(work_node& x, undelta_base*& _u, const delta_id& _did) const;

  bool operator==(const delta_base& _c) const
       { return _c.get_action() == get_action() &&
         this->operator==(*(split_delta*)&_c); }
  bool operator!=(const delta_base& _c) const
       { return _c.get_action() != get_action() ||
         this->operator!=(*(split_delta*)&_c); }

  bool operator==(const split_delta& _c) const
       { return this == &_c || splits == _c.splits; }
  bool operator!=(const split_delta& _c) const
       { return this != &_c && splits != _c.splits; }
};

inline bool split_undelta::unapply(work_node& x, const delta_id& _did) const
{
  std::map<work_node::transaction_number,
                        std::list<std::vector<delta> > >::iterator _f;
  x.split_delta_ids.erase(_did);
  _f = x.proposed_splits.find(se);
  if(_f != x.proposed_splits.end())
  {
    x.proposed_splits.erase(_f);
    return true;
  }
  else
    return false;
}

inline bool split_delta::apply(work_node& x, undelta_base*& _u,
                                                const delta_id& _did) const
{
  work_node::transaction_number se(x.get_transaction_number());
  x.proposed_splits.insert(std::make_pair(se,splits));
  x.split_delta_ids[_did] = se;
  _u = (undelta_base*) new split_undelta(se);
  return true;
}

inline void split_delta::add_multisplit(const std::vector<unsigned int> nnum,
                  const std::vector<std::pair<interval,interval> >& bds)
{
  unsigned int vns(nnum.size());
  if(bds.size() != vns)
    throw api_exception(apiee_delta,
        "split_delta::add_splits: nnum and bds have different lengths");
  std::vector<bool> v_bool(vns, false);
  std::vector<interval> v_bnds(vns);

  bool all_and;
  do
  {
    all_and = true;
    for(unsigned int i = 0; i < vns; ++i)
    {
      if(v_bool[i])
        v_bnds[i] = bds[i].second;
      else
      {
        v_bnds[i] = bds[i].first;
        if(all_and)
        {
          all_and = false;
          v_bool[i] = true;
          for(unsigned int j = 0; j < i; ++j) v_bool[j] = false;
        }
      }
    }
    splits.push_back(std::vector<delta>(1,delta(bound_delta(nnum, v_bnds))));
  }
  while(!all_and);
}

inline void split_delta::add_multisplit(const std::vector<unsigned int> nnum,
                  const std::vector<std::vector<interval> >& bds)
{
  unsigned int vns(nnum.size());
  unsigned int hidx;
  if(bds.size() != vns)
    throw api_exception(apiee_delta,
        "split_delta::add_splits: nnum and bds have different lengths");
  std::vector<unsigned int> v_idx(vns, 0);
  std::vector<interval> v_bnds(vns);

  while(1)
  {
    for(unsigned int i; i < vns; ++i)
      v_bnds[i] = bds[i][v_idx[i]];
    splits.push_back(std::vector<delta>(1,delta(bound_delta(nnum, v_bnds))));
    
    for(hidx = 0; hidx < vns; hidx++)
    {
      v_idx[hidx]++;
      if(v_idx[hidx] == bds[hidx].size())
        v_idx[hidx] = 0;
      else
        break;
    }
    if(hidx == vns)
      break;
  }
}

} // namespace coco

#endif /* _SPLIT_DELTA_H_ */

---