sum_deltas.h

Go to the documentation of this file.

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

// $Id: sum_deltas.h 726 2008-09-23 13:55:13Z mihaly $
// Copyright (C) 2001-2003 Evgueni Petrov, 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 _SUM_DELTAS_H_
#define _SUM_DELTAS_H_
#include <vector>
#include "delta.h"


inline work_node full_node_to_work_node(full_node& n_full,
                                        gptr<search_node> &ground)
{
  ptr<model> ptr_to_model_from_n_full(*n_full.get_model_ptr());
  ptr<vdbl::database> ptr_to_dbase_from_n_full(*n_full.get_database_ptr());
//  return work_node ( ptr_to_model_from_n_full, n_work_annotation, empty_list_of_delta_id, & ground );
// memory leak !!!
  std::list<delta_id> empty_list_of_delta_id;
  return work_node(n_full.get_id(), n_full.get_dbuserid(),
                   *new ptr<model>(ptr_to_model_from_n_full),
                   *new ptr<vdbl::database>(ptr_to_dbase_from_n_full),
                   n_full.get_annotations(), empty_list_of_delta_id, &ground);
}


class sum_deltas: public prepost_visitor<search_node*, search_node*>
{
public:
  std::vector<return_value> ancestors;
  return_value result;
  std::list<delta_id>* dels;
  std::set<search_node_id>* nds;
  const std::set<search_node_id>* c_nds;
  const search_node_id* psnid;

  sum_deltas(std::list<delta_id>& _dels, std::set<search_node_id>& _nds) :
    result(NULL), dels(&_dels), nds(&_nds), c_nds(NULL), psnid(NULL)
  {
#if DEBUG_SGRAPH_EXTRACT
    std::cerr << "sum_deltas:" << std::endl;
#endif
  }

  sum_deltas(std::list<delta_id>& _dels, std::set<search_node_id>& _nds,
             const std::set<search_node_id>& _c_nds) :
    result(NULL), dels(&_dels), nds(&_nds), c_nds(&_c_nds), psnid(NULL)
  {
#if DEBUG_SGRAPH_EXTRACT
    std::cerr << "sum_deltas: c_nds: " << *c_nds << std::endl;
#endif
  }

  sum_deltas(std::list<delta_id>& _dels, std::set<search_node_id>& _nds,
             const search_node_id& _psnid) :
    result(NULL), dels(&_dels), nds(&_nds), c_nds(NULL), psnid(&_psnid)
  {
#if DEBUG_SGRAPH_EXTRACT
    std::cerr << "sum_deltas: psnid: " << *psnid << std::endl;
#endif
  }


  inline void vinit()
  {
    // cout << "vinit" << endl;
  }

  inline void vcollect(return_value const &)
  {
    // cout << "vcollect" << endl;
    throw api_exception(apiee_search_graph,
        "in sum_deltas::vcollect: do not know how to handle virtual nodes");
  }

  inline return_value vvalue()
  {
    // cout << "vvalue" << endl;
    return result;
  }

  inline bool preorder(search_node* const& r)
  {
    bool res;
    search_node_id rid(r->get_id());
    // cout << "preorder" << endl;
    ancestors.clear();
    // this is true, if r is a delta node, which is not in the comparison set
    res = r->is_delta() &&
      (!c_nds || c_nds->find(rid) == c_nds->end()) && (!psnid || *psnid != rid);
    if(!res)
      result = r;
    else
      nds->insert(rid);
    return res;
  }

  inline void collect(search_node* const&, return_value const &ancestor)
  {
    // cout << "collect" << endl;
    ancestors.push_back(ancestor);
  }

  bool postorder(search_node* const &r)
  {
    // cout << "postorder" << endl;
    if(ancestors.size() >= 2)
      throw api_exception(apiee_search_graph,
        "in sum_deltas::postorder: search_node has several ancestors");
    else if(!result)
    {
      result = ancestors[0];
      delta_node *r_as_delta_node = (delta_node *) r;     //  cast to delta_node *
      r_as_delta_node->get_deltas(*dels);
#if DEBUG_SGRAPH_EXTRACT
      {
        std::list<delta_id> dels_dummy;
        r_as_delta_node->get_deltas(dels_dummy);
        std::cerr << "node: " << r->get_id() << ", deltas: " <<
          dels_dummy << std::endl;
      }
#endif
    }
    return false;
  }

  inline return_value value()
  {
    // cout << "value" << endl;
    return result;
  }
};
#endif // _SUM_DELTAS_H_

---