---

api_deltabase.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_DELTABASE_H_
#define _API_DELTABASE_H_

#include <coconut_config.h>
#include <string>
#include <database>

#define DEBUG_DELTA 0

class work_node;

class delta_base;

class undelta_base;

typedef vdbl::rowid delta_id;

class delta
{
private:
  delta_base* _d;

public:
  delta() : _d(NULL) {}
private:
  delta(delta_base* __d) : _d(__d) {}
public:
  delta(const delta_base& __d);
  delta(const delta& __d);

  ~delta();

  const std::string& get_action() const;
  const delta_base* get_base() const;

  bool apply(work_node& _x, const delta_id& _d) const;
  bool apply3(work_node& _x, const work_node& _y, const delta_id& _d) const;
  void convert(work_node& _x);
  delta_id store(work_node& _x);

  delta& operator=(const delta& _d);
  
  friend std::ostream& operator<< (std::ostream& o, const delta& t);
  friend class delta_base;
  friend class ie_return_type;
};

inline std::ostream& operator<< (std::ostream& o, const delta& t)
{
  o << "Don't know how to print a delta!";
  return o;
}

class delta_base
{
protected:
  std::string _action; 

public:
  delta_base() : _action() {}
  delta_base(const std::string& a) : _action(a) {}
  delta_base(const char* a) : _action(std::string(a)) {}
  delta_base(const delta_base& __d) : _action(__d._action) {}

  virtual delta_base* new_copy() const { return new delta_base(*this); } // clone operation
  virtual void destroy_copy(delta_base* __d) { delete __d; }

  virtual ~delta_base() {}

  delta make_delta(const std::string& a)
  {
    delta_base* __tmp = new delta_base(a);
    return delta(__tmp);
  }

  const std::string& get_action() const { return _action; }

  virtual void convert(work_node& _x, delta_base*& _d)
     { _d = this; } 

  virtual bool apply(work_node& _x, undelta_base*& _u) const
     { _u = NULL; return false; }

  // these should be implemented better in each delta,
  // they, however, need not be
  virtual bool apply3(work_node& _x, const work_node& _y, undelta_base*& _u)
                                                                        const;
};

class undelta
{
private:
  undelta_base* _d;

public:
  undelta() : _d(NULL) {}
  undelta(undelta_base* __d) : _d(__d) {}
  undelta(const undelta& __d);

  ~undelta();

  const undelta_base* get_base() const;

  bool unapply(work_node& _x) const;
  bool unapply3(work_node& _x, const work_node& _y) const;
  
  undelta& operator=(const undelta& _u);
};

class undelta_base
{
public:
  undelta_base() {}
  undelta_base(const undelta_base& __d) {}

  virtual undelta_base* new_copy() const { return new undelta_base(*this); } // clone operation
  virtual void destroy_copy(undelta_base* __d) { delete __d; }

  virtual ~undelta_base() {}

  undelta make_undelta()
  {
    undelta_base* __tmp = new undelta_base();
    return undelta(__tmp);
  }

  virtual bool unapply(work_node& _x) const { return false; }

  // these should be implemented better in each delta,
  // they, however, need not be
  virtual bool unapply3(work_node& _x, const work_node& _y) const;
};

#endif /* _API_DELTABASE_H_ */

---