api_deltabase.h

Go to the documentation of this file.

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

// $Id: api_deltabase.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_DELTABASE_H_
#define _API_DELTABASE_H_

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

namespace coco {

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);
  void unkeep();

  delta_id store(work_node& _x, const certificate& _c);

  delta& operator=(const delta& _d);
  
  bool operator==(const delta& _c) const;
  bool operator!=(const delta& _c) const;

  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 of type " << t.get_action() << "!"
    << std::endl;
  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 PURE_VIRTUAL
  virtual void destroy_copy(delta_base* __d) const PURE_VIRTUAL

  virtual ~delta_base() {}

  delta make_delta(const std::string& a)
  {
    delta_base* __tmp = this->new_copy();
    __tmp->_action = a;
    return delta(__tmp);
  }

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

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

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

  virtual bool apply3(work_node& _x, const work_node& _y, undelta_base*& _u,
                      const delta_id& _d) const;

  virtual bool operator==(const delta_base& _c) const PURE_VIRTUAL
  virtual bool operator!=(const delta_base& _c) const PURE_VIRTUAL
};


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 delta_id& _i) const;
  bool unapply3(work_node& _x, const work_node& _y, const delta_id& _i) const;
  
  undelta& operator=(const undelta& _u);
};


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

  virtual undelta_base* new_copy() const PURE_VIRTUAL
  virtual void destroy_copy(undelta_base* __d) const PURE_VIRTUAL

  virtual ~undelta_base() {}

  undelta make_undelta()
  {
    undelta_base* __tmp = this->new_copy();
    return undelta(__tmp);
  }

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

  virtual bool unapply3(work_node& _x, const work_node& _y,
                                                const delta_id& _d) const;
};

} // namespace coco

#endif /* _API_DELTABASE_H_ */

---