---

split_delta.h

Go to the documentation of this file.

// Split 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 _SPLIT_DELTA_H_
#define _SPLIT_DELTA_H_

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

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(split_undelta* __d) { delete __d; }

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

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.  
  // splits represents a list of newly created submodels. Each of these
  // submodels is generated from the work node by a number of deltas stored
  // in the inner vector.

  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() {}

  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(split_delta* __d) { delete __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(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))));
  }

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

#endif /* _SPLIT_DELTA_H_ */

---