---

search_graph.h

Go to the documentation of this file.

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

// 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

// FIXED by IRIN as of 08/11/2002
// + re-ordered and/or completed some initialization lists
// + made some methods of search_node, full_node etc. "const"
// + suppressed some empty declarations
// + made the destructors of search_node & Co. "virtual" 
//

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

using namespace vgtl;
using namespace std;

#include <exception>

class search_graph_exception : public exception
{
public:

  char const *const message;

  search_graph_exception(char const *m):message(m) {}

  virtual char const *what() const throw()
  {
    return message;
  }
};

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;
  list<search_node*> search_nodes_to_deallocate;
  list<delta_id> db_deltas_to_remove;
  gptr<vdbl::database> *__dbase;
  vdbl::userid __dbuser;

private:
  search_node_id __maxid;

  void _internal_remove(search_focus& _sf);

public:
  search_graph(model& root_model, gptr<vdbl::database>& _db)
       : _Base(), ptr_ground(NULL), ptr_root_model(NULL),
         __dbase(&_db), __dbuser(0), __maxid(0)
  {
    ptr_root_model = root_model; // the actual initialization of ptr_root_model
    *ground() = new search_node(get_node_id(), __dbuser, *__dbase, snr_virtual);
    search_nodes_to_deallocate.push_front(*ground());
    ptr_ground = **ground();    // the actual initialization of ptr_ground
    root = new full_node(get_node_id(), __dbuser, ptr_root_model, ptr_ground,
                         *__dbase, snr_root);
    search_nodes_to_deallocate.push_front(root);
    inspector_for_root = insert(ground(), *root);
  }

  search_graph(model & root_model, gptr<vdbl::database>& _db,
               const std::vector<annotation>& _a)
       : _Base(), ptr_ground(NULL), ptr_root_model(NULL),
         __dbase(&_db), __dbuser(0), __maxid(0)
  {
    ptr_root_model = root_model;  // the actual initialization of ptr_root_model
    *ground() = new search_node(get_node_id(), __dbuser, *__dbase, snr_virtual);
    search_nodes_to_deallocate.push_front(*ground());
    ptr_ground = **ground();    // the actual initialization of ptr_ground
    root = new full_node(get_node_id(), __dbuser, ptr_root_model, ptr_ground,
                         *__dbase, _a, snr_root);
    search_nodes_to_deallocate.push_front(root);
    inspector_for_root = insert(ground(), *root);
  }

  ~search_graph()
  {
    for(list<search_node*>::iterator i = search_nodes_to_deallocate.begin();
        i != search_nodes_to_deallocate.end(); ++i)
      delete *i;

    vdbl::standard_table * dtable = (vdbl::standard_table *)
        (*__dbase)->get_table("deltas", __dbuser);
    if(dtable == NULL)
      throw "Database inconsistency: Programming Error!";
    for(list<delta_id>::iterator i = db_deltas_to_remove.begin();
        i != db_deltas_to_remove.end(); ++i)
      dtable->remove(*i);
  }

  search_node_id get_node_id() { return __maxid++; }

  search_focus& new_focus(const search_inspector& _si);
  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);

  work_node extract(const search_inspector& where);
  work_node extract(const search_focus& where);
  search_inspector& insert(const search_focus& where, const search_node& what);
  search_inspector& replace(search_focus& where, const search_node& what);
  void remove(search_focus& _sf);
  void remove_upwards(search_focus& _sf, bool relaxation_kills);

  search_focus& promote(search_focus& _sf);

  search_inspector child(search_inspector& n, unsigned int i)
  {
    if(n.n_children() < i || i < 0)
      throw search_graph_exception
        ("in search_graph :: child (...) : the index of child is out of range");
    return new_inspector(n >> (n.child_begin() + i));
  }

  search_inspector parent(search_inspector& n, unsigned int i)
  {
    if(n.n_parents() < i || i < 0)
      throw search_graph_exception
        ("in search_graph :: parent (...) : the index of parent is out of range");
    return new_inspector(n >> (n.parent_begin() + i));
  }

};

typedef search_graph::const_walker search_inspector;
typedef search_graph::walker search_focus;

#endif // _SEARCH_GRAPH_H

---