---

api_delta.h

Go to the documentation of this file.

// 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 _API_DELTA_H_
#define _API_DELTA_H_

#include <api_deltabase.h>
#include <search_node.h>
#include <dbtools.h>
#include <counted_ptr.h>
#include <db_method>

static std::string ___empty_string;
class delta_get_action : public vdbl::method<std::string>
{
private:
  typedef vdbl::method<std::string> _Base;
  vdbl::colid cid;
  const vdbl::row* _r;

public:
  typedef vdbl::context context;
  typedef std::string return_type;

  delta_get_action(vdbl::colid _c) : _Base(), cid(_c), _r() {}
  delta_get_action(const delta_get_action& _i) : _Base(_i), cid(_i.cid),
                                                 _r(_i._r) {}
  virtual ~delta_get_action() {}

  const std::string& operator() () const;
  const std::string& def() const { return operator()(); }
  void setcontext(const context* c, const vdbl::row* r) { _r = r; }
};

// these should be implemented better in each delta,
// they, however, need not be
inline bool delta_base::apply3(work_node& _x, const work_node& _y,
                                       undelta_base*& _u) const
{ _x = _y; return apply(_x, _u); }

// these should be implemented better in each delta,
// they, however, need not be
inline bool undelta_base::unapply3(work_node& _x,
                                           const work_node& _y) const
{ _x = _y; return unapply(_x); }

inline const std::string& delta_get_action::operator() () const
{
  if(!_r)
    return ___empty_string;
  bool error;
  const vdbl::col& _c(_r->get_col(cid, error));
  if(error)
    return ___empty_string;
  const delta* _d;
  _c.get_ptr(_d);
  if(_d == NULL)
    return ___empty_string;
  return _d->get_action();
}
inline delta::delta(const delta_base& __d)
    { _d = __d.new_copy(); }
inline delta::delta(const delta& __d)
    { _d = __d._d->new_copy();
#if DEBUG_DELTA
        std::cerr << "Called delta copy constructor" << std::endl;
#endif
    }
inline delta::~delta()
    { if(_d) delete _d;
#if DEBUG_DELTA
        std::cerr << "Called delta destructor" << std::endl;
#endif
    }
inline delta& delta::operator=(const delta& __d)
    {
      if(_d) delete _d;
      _d = __d._d->new_copy();
#if DEBUG_DELTA
        std::cerr << "Called delta assignment operator" << std::endl;
#endif
      return *this;
    }

inline const std::string& delta::get_action() const { return _d->get_action(); }
inline const delta_base* delta::get_base() const { return _d; }

inline bool delta::apply(work_node& _x, const delta_id& _i) const
     { undelta_base* _u(NULL);
       if(_d->apply(_x, _u))
       {
         _x.undeltas.insert(std::make_pair(_i,undelta(_u)));
         _x.deltas.push_back(_i);
         return true;
       }
       else
         return false;
     }

inline bool delta::apply3(work_node& _x, const work_node& _y,
                          const delta_id& _i) const
     { undelta_base* _u(NULL);
       if(_d->apply3(_x, _y, _u))
       {
         _x.undeltas.insert(std::make_pair(_i,undelta(_u)));
         _x.deltas.push_back(_i);
         return true;
       }
       else
         return false;
     }

inline void delta::convert(work_node& _x)
     {
       delta_base* _do = _d;
       _do->convert(_x, _d);
       if(_do != _d)
         delete _do;
     }

inline delta_id delta::store(work_node& wn)
     {
       std::vector<vdbl::col_spec> _v;
       this->convert(wn);
       _v.push_back(vdbl::col_spec("delta", vdbl::typed_col<delta>(*this)));
       delta_id _r;
       if(!wn.dtable->insert_row(_v, _r))
       {
         std::cerr << "Storing delta in the deltas table failed!" << std::endl;
         throw "Programming error";
       }
       return _r;
     }

inline undelta::undelta(const undelta& __d)
     { _d = __d._d->new_copy();
#if DEBUG_DELTA
       std::cerr << "Called undelta copy constructor" << std::endl;
#endif
     }
inline undelta::~undelta()
     { if(_d) delete _d;
#if DEBUG_DELTA
       std::cerr << "Called undelta destructor" << std::endl;
#endif
     }
inline undelta& undelta::operator=(const undelta& __u)
    {
      if(_d) delete _d;
      _d = __u._d->new_copy();
#if DEBUG_DELTA
      std::cerr << "Called undelta assignment operator" << std::endl;
#endif
      return *this;
    }
inline const undelta_base* undelta::get_base() const { return _d; }

inline bool undelta::unapply(work_node& _x) const
     { return _d->unapply(_x); }

inline bool undelta::unapply3(work_node& _x, const work_node& _y) const
     { return _d->unapply3(_x, _y); }

#endif /* _API_DELTA_H_ */

---