search_graph.h

Go to the documentation of this file.

// Search Graph implementation -*- C++ -*-

// $Id: search_graph.h 931 2009-11-12 17:22:21Z mihaly $
// Copyright (C) 2001-2003 Hermann Schichl, Evgueni Petrov, Brice Pajot
//
// 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 _SEARCH_GRAPH_H
#define _SEARCH_GRAPH_H

#include <iostream>
#include <algorithm>
#include <dag.h>
#include <coconut_config.h>
#include <search_node.h>
#include <comp_hook.h>
#include <api_exception.h>

using namespace vgtl;

namespace coco {

class search_graph_context;


class search_graph : public dag<search_node*>
{
private:
  typedef dag<search_node*> _Base;
  typedef search_graph _Self;
  typedef search_graph::const_walker search_inspector;
  typedef search_graph::walker search_focus;

  // private:
public:
  std::list<walker> focus;
  std::list<const_walker> inspector;

  search_node *root;
  search_inspector inspector_for_root;
  ptr<search_node> ptr_ground;
  ptr<model> ptr_root_model;
  std::list<search_node*> search_nodes_to_deallocate;
  std::list<delta_id> db_deltas_to_remove;
  gptr<vdbl::database> *__dbase;
  vdbl::userid __dbuser;

  search_graph_context* sgc;
  vdbl::viewdbase __vdbf;


private:
  search_node_id __maxid;
  std::map<search_node_id,search_inspector> __id_ref;

  void _internal_remove(search_focus& _sf);

  void _extract(work_node& wnode, const search_inspector& where) const;

  void _extract_indirect(work_node& wnode, const search_inspector & from,
                         const search_inspector & to) const;

  void _extract_full(work_node& wnode, const search_inspector & where,
        std::list<delta_id>& dels, std::set<search_node_id>& nds,
        full_node* fn) const;

private:
  std::list<work_node_comp_hook*> wn_hooks;

public:
  search_graph(model& root_model, gptr<vdbl::database>& _db);

  search_graph(model & root_model, gptr<vdbl::database>& _db,
               const std::vector<annotation>& _a);

  ~search_graph();

  search_node_id get_node_id() { return ++__maxid; }

  search_graph_context* get_search_graph_context() { return sgc; }

  const search_graph_context* get_search_graph_context() const { return sgc; }

  vdbl::viewdbase& get_viewdbase() { return __vdbf; }

  const vdbl::viewdbase& get_viewdbase() const { return __vdbf; }

  bool possible_focus(const search_inspector& _si,
                      const search_focus& not_this) const;
  bool possible_focus(const search_inspector& _si,
         const std::list<search_focus>::const_iterator* not_this = NULL) const;
  search_focus& new_focus(const search_inspector& _si);
  const search_focus& get_focus(const search_inspector& _si, bool& isNew);
  void destroy_focus(const search_focus& _sf);
  search_focus& set_focus(search_focus& _fc, const search_inspector& _si);

  search_inspector& new_inspector(const search_inspector& inspector_to_add);

  search_inspector& new_inspector()
    { return new_inspector(ground()); }

  void destroy_inspector(const search_inspector& inspector_to_destroy);

  search_inspector child(search_inspector& n, unsigned int i);

  search_inspector parent(search_inspector& n, unsigned int i);

  search_inspector get(search_node_id id) const;

  work_node extract(const search_inspector& where) const;
  work_node extract(const search_focus& where) const;
  void extract(work_node& wnode, const search_inspector& where) const;
  void extract(work_node& wnode, const search_focus& where) const;
  search_focus& update(work_node& wnode, search_focus& foc,
                       const search_inspector& where);
  search_focus& update_and_delete(work_node& wnode, search_focus& foc,
                       const search_inspector& where, bool just_this,
                       bool relaxation_kills);
  search_inspector& insert(const search_focus& where, const search_node& what);
  search_inspector& replace(search_focus& where, const search_node& what);
  bool add_deltas(const search_focus& where,
                  const std::vector<delta_id>& del_vec);
  void remove(search_focus& _sf);
  void remove_upwards(search_focus& _sf, bool relaxation_kills);
  search_focus& promote(search_focus& _sf);

  bool register_hook(const work_node_comp_hook& wnch);
  bool unregister_hook(const std::string& name);
  void apply_hooks(const work_node& w, const search_node_id& id,
                   vdbl::rowid& rid, std::list<delta>& add_ds,
                   std::list<certificate>& add_cs);
};

} // namespace coco

#include <search_graph.hpp>

#if DEBUG_SEARCH_NODES
#include <g_algotest.h>
namespace coco {


class __test_sn_help
{
public:
  search_node_id operator()(const search_node* __sn) const
  {
    return __sn->test();
  }
};


inline void consistency_test(const search_graph& __s)
{
  recursive_consistency_test(__s.ground(), __test_sn_help());
}

} // namespace coco
#endif

namespace coco {


typedef search_graph::const_walker search_inspector;

typedef search_graph::walker search_focus;

} // namespace coco

#endif // _SEARCH_GRAPH_H

---