api_delta.h

Go to the documentation of this file.

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

// $Id: api_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 _API_DELTA_H_
#define _API_DELTA_H_

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

namespace coco {

static std::string ___empty_string;


class delta_get_action : public vdbl::method<const std::string&>
{
private:
  typedef vdbl::method<const 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 delta_id& _d) const
{ _x = _y; return apply(_x, _u, _d); }

// 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 delta_id& _d) const
{ _x = _y; return unapply(_x, _d); }

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, _i))
       {
         _x.undeltas.insert(std::make_pair(_i,undelta(_u)));

// Mihaly, 14.01.2004. Set deltanew_it if needed, i.e. if deltanew_it points to
// the end (before _i is inserted).
         if ( _x.deltanew_it == _x.deltas.end() )
           _x.deltanew_it = _x.deltas.insert(_x.deltanew_it,_i);
         else
           _x.deltas.push_back(_i);
// end Mihaly

         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, _i))
       {
         _x.undeltas.insert(std::make_pair(_i,undelta(_u)));

// Mihaly, 14.01.2004. Set deltanew_it if needed, i.e. if deltanew_it points to
// the end (before _i is inserted).
         if ( _x.deltanew_it == _x.deltas.end() )
           _x.deltanew_it = _x.deltas.insert(_x.deltanew_it,_i);
         else
           _x.deltas.push_back(_i);
// end Mihaly

         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 void delta::unkeep() { _d->unkeep(); }

inline bool delta::operator==(const delta& _t) const
     { return _d->get_action() == _t._d->get_action()
              && _d->operator==(*_t._d); }
inline bool delta::operator!=(const delta& _t) const
     { return _d->get_action() != _t._d->get_action()
              || _d->operator!=(*_t._d); }

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 delta_id& _i) const
     { return _d->unapply(_x, _i); }

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

} // namespace coco

#endif /* _API_DELTA_H_ */

---