search_node.h

Go to the documentation of this file.

// Search Node implementation -*- C++ -*-

// $Id: search_node.h 681 2008-07-14 14:29:16Z 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_NODE_H_
#define _SEARCH_NODE_H_

#include <iostream>
#include <coconut_config.h>
#include <interval.h>
#include <model.h>
#include <annotation.h>
#include <map>
#include <set>
#include <list>
#include <string>
#include <gptr.h>
#include <stdint.h>
#include <database>
#include <viewdbase>
#include <db_alltype>
#include <api_debug.h>
#include <datamap.h>

using namespace vgtl;

#include <api_deltabase.h>
#include <api_certbase.h>

namespace coco {


typedef enum {
  snr_root,             
  snr_reduction,        
  snr_relaxation,       
  snr_split,            
  snr_glue,             
  snr_worknode,         
  snr_virtual,          
} search_node_relation;


typedef uint32_t search_node_id;


class search_node
{
protected:
  gptr<search_node>* __global_model;
  gptr<vdbl::database>* __dbase;
  vdbl::userid _dbuser;
  search_node_relation _snr;
  search_node_id _id;
  std::vector<annotation> _keep;
  vdbl::rowid _rid;

protected:
  search_node_relation parent_relation() const { return _snr; }

public:
  virtual bool is_delta() const { return false; }

  search_node(const search_node_id& _i, const vdbl::userid& _dui,
              gptr<search_node>& _gm, gptr<vdbl::database>& _db,
              search_node_relation __snr = snr_reduction);
  
  search_node(const search_node_id& _i, const vdbl::userid& _dui,
              gptr<search_node>* _gm, gptr<vdbl::database>& _db,
              search_node_relation __snr = snr_reduction);

  search_node(const search_node& __sn);

  search_node(const search_node_id& _i, const vdbl::userid& _dui,
              gptr<vdbl::database>& _db, search_node_relation __snr = snr_root);

  virtual ~search_node();
  
  search_node& operator=(const search_node& __w);

  vdbl::userid get_dbuserid() const { return _dbuser; }

  gptr<search_node>* global_model() const { return __global_model; }

  gptr<vdbl::database>* database() const { return __dbase; }

  search_node_id get_id() const { return _id; }

  void set_id(const search_node_id& i) { _id = i; }

  vdbl::rowid get_rowid() const { return _rid; }

  void set_rowid(const vdbl::rowid& i) { _rid = i; }

  void keep(const annotation& _an) { _keep.push_back(_an); }
  
  void keep(const std::vector<annotation>& _anv)
        { _keep.insert(_keep.end(), _anv.begin(), _anv.end()); }

  void unkeep(const annotation& _an);
  
  void unkeep(const std::vector<annotation>& _anv);

  friend class search_graph;

#if DEBUG_SEARCH_NODE

  search_node_id test() const { return _id; }
#endif
};


class delta_node : public search_node
{
private:
  typedef search_node _DBase;

private:
  std::vector<delta_id> di;

public:
  delta_node(const search_node_id& _i, const vdbl::userid& _dui,
             std::vector<delta_id>& __d, gptr<search_node>& _gm,
             gptr<vdbl::database>& _db,
             search_node_relation _snr = snr_reduction)
        : search_node(_i, _dui, _gm, _db, _snr), di(__d)
    {}
  
  virtual ~delta_node() {}

  delta_node& operator=(const delta_node& __w);

  bool is_delta() const { return true; }

  unsigned int n_deltas() const { return (unsigned int)di.size(); }

  delta_id get_delta_id(unsigned int i) const { return di[i]; }
  
  delta get_delta(unsigned int i);

  const delta& get_delta(unsigned int i) const;

  template <class _Iterator>
  void add_deltas(_Iterator _f, _Iterator _l)
    { std::copy(_f, _l, back_inserter(di)); }

  template <class _SeqContainer>
  void get_deltas(_SeqContainer& _c)
    { std::copy(di.begin(), di.end(), back_inserter(_c)); }
};


class full_node : public search_node
{
private:
  typedef search_node _FBase;

protected:
  gptr<model>*          _m;

public:
  std::vector<annotation> _ann;

protected:
  full_node(const search_node_id& _i, const vdbl::userid& _dui,
            gptr<model>& __mod, gptr<search_node>* _gm,
            gptr<vdbl::database>& _db,
            search_node_relation _snr = snr_reduction)
        : search_node(_i, _dui, _gm, _db, _snr), _ann()
    { _m = new ptr<model>(*__mod); }

  full_node(const search_node_id& _i, const vdbl::userid& _dui,
            gptr<model>& __mod, gptr<search_node>* _gm,
            gptr<vdbl::database>& _db, const std::vector<annotation>& _a,
            search_node_relation _snr = snr_reduction)
        : search_node(_i, _dui, _gm, _db, _snr), _ann(_a)
    { _m = new ptr<model>(*__mod); }

public:
  // constructors,...
  full_node(const search_node_id& _i, const vdbl::userid& _dui,
            gptr<model>& __mod, gptr<search_node>& _gm,
            gptr<vdbl::database>& _db,
            search_node_relation _snr = snr_reduction)
        : search_node(_i, _dui, _gm, _db, _snr), _ann()
    { _m = new ptr<model>(*__mod); }

  full_node(const search_node_id& _i, const vdbl::userid& _dui,
            gptr<model>& __mod, gptr<search_node>& _gm,
            gptr<vdbl::database>& _db, const std::vector<annotation>& _a,
            search_node_relation _snr = snr_reduction)
        : search_node(_i, _dui, _gm, _db, _snr), _ann(_a)
    { _m = new ptr<model>(*__mod); }

  full_node(const full_node& _i)
        : _FBase(_i), _m(new ptr<model>(**_i._m)), _ann(_i._ann)
    { }

  virtual ~full_node() { if(_m) delete _m; _m = NULL; }
  
  full_node& operator=(const full_node& __w);

  bool is_delta() const
    { return false; }

  unsigned int n_annotations() const { return (unsigned int)_ann.size(); }

  const annotation& get_annotation(unsigned int i) const
    { return _ann[i]; }

  const std::vector<annotation>& get_annotations() const
    { return _ann; }

  const model* get_model() const
    { return (*_m).get_local_copy(); } 

  const vdbl::database* get_database() const
    { return (*database()).get_local_copy(); } 

  model* get_model_ptr() const
    { return (*_m).get_local_copy(); }

  vdbl::database* get_database_ptr() const
    { return (*database()).get_local_copy(); }

  friend class delta_base;
  friend class certificate_base;
  friend class dag_delta;
  friend class dag_undelta;
};

class work_node_context;


class work_node : public full_node
{
private:
  typedef full_node _Base;

public:
  template <class _TW, class _TV, class _VR, class _TP, class _TR, class _TI>
  class constraint_iterator_base;

  typedef constraint_iterator_base<expression_walker,
         const std::vector<expression_walker>*,
         const std::vector<expression_walker>&,const expression_walker*,
         const expression_walker&,
         std::vector<expression_walker>::const_iterator> constraint_const_iterator;
  typedef constraint_iterator_base<expression_walker,
         std::vector<expression_walker>*,
         std::vector<expression_walker>&,expression_walker*,expression_walker&,
         std::vector<expression_walker>::iterator> constraint_iterator;

public:  
  std::list<delta_id> deltas;

  std::list<delta_id>::iterator deltanew_it;

  std::set<search_node_id> parents_in_graph;

  std::map<delta_id,undelta> undeltas;
  vdbl::standard_table *dtable;
  vdbl::tableid dtable_id;
  vdbl::standard_table *gitable;
  vdbl::tableid gitable_id;
  // to add a list of references to delta_id or a map to delta_id's

  work_node_context* wnc;
  vdbl::viewdbase* __vdb;
  vdbl::viewdbase* __vdbf;

public:
  std::vector<interval> node_ranges;
  std::vector<unsigned int> node_order;
  bool infeasible;

  double log_vol;
  double gain_factor;
  datamap globalinfo;

public:
  typedef uint32_t transaction_number;

private:
  transaction_number _tnum;

public:
  transaction_number get_transaction_number()
    { return ++_tnum; }

public:
  std::map<transaction_number,std::list<std::vector<delta> > > proposed_splits;
  std::map<delta_id, transaction_number> split_delta_ids;

private:
  unsigned int n_bds;
  unsigned int n_lin;
  unsigned int n_quad;
  unsigned int n_poly;
  unsigned int n_other;

public:
  void init_cnumbers();
  void reset_node_ranges();
  void make_node_ranges(bool keep_old_ranges);
  void make_node_order();
  double compute_log_volume(const std::vector<interval>& _r) const;
  void set_globalinfo();

private:
  void init_all();

  void set_deltanew_it(const work_node& __w);

public:
  work_node(const work_node& __w);

  work_node(const full_node& __f, const std::list<delta_id>& __de,
            vdbl::viewdbase* vdbf = NULL);

  work_node(const search_node_id& _i, const vdbl::userid& _dui,
            gptr<model>& __m, gptr<vdbl::database>& __d,
            const std::vector<annotation>& __an,
            const std::list<delta_id>& __de, gptr<search_node>* _gm,
            search_node_relation snr = snr_worknode,
            vdbl::viewdbase* vdbf = NULL);

  virtual ~work_node();

  const model* get_model() const
    { return (*_m).get_local_copy(); } 
  model* get_model()
    { return (*_m).get_local_copy(); } 

  work_node_context* get_work_node_context() { return wnc; }

  const work_node_context* get_work_node_context() const { return wnc; }

  vdbl::viewdbase& get_viewdbase() { return *__vdb; }

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

  vdbl::viewdbase& get_fullviewdbase() { if(__vdbf) return *__vdbf; else return *__vdb; }

  const vdbl::viewdbase& get_fullviewdbase() const { if(__vdbf) return *__vdbf; else return *__vdb; }

public:


  model get(unsigned int __type)
    { throw nyi_exception("work_node: get(type) method"); }


  constraint_const_iterator get_begin(unsigned int __type) const;

  constraint_const_iterator get_end(unsigned int __type) const;


  constraint_iterator get_begin(unsigned int __type);

  constraint_iterator get_end(unsigned int __type);

  unsigned int n(unsigned int __type) const;

  delta get_delta(const delta_id& _id);

  const delta& get_delta(const delta_id& _id) const;

  certificate get_certificate(const delta_id& _id);

  const certificate& get_certificate(const delta_id& _id) const;

  double log_volume() const
    { return log_vol; }
  double gain() const
    { return gain_factor; }
  const datamap& global_info() const
    { return globalinfo; }

  bool global_info(basic_alltype& b, const std::string& i) const;
  bool global_info(basic_alltype& b, const char* i) const
    { return global_info(b, std::string(i)); }


  basic_alltype global_info(const std::string& i) const;
  basic_alltype global_info(const char* i) const
    { return global_info(std::string(i)); }

  double reset_gain()
    { double ret = gain_factor; gain_factor = 1.; return ret; }

public:
  work_node& operator=(const work_node& __w);

  work_node& operator=(const full_node& __f);

  friend work_node operator+(const work_node& _w, const delta_id& _d);
  friend work_node operator-(const work_node& _w, const delta_id& _d);
  friend work_node& operator+=(work_node& _w, const delta_id& _d);
  friend work_node& operator-=(work_node& _w, const delta_id& _d);

  template <template <class _Tp, class _TA> class _Ctr, class _Al>
  friend work_node operator+(const work_node& _w, const _Ctr<delta_id,_Al>& _d);

  template <template <class _Tp, class _TA> class _Ctr, class _Al>
  friend work_node operator-(const work_node& _w, const _Ctr<delta_id,_Al>& _d);

  template <template <class _Tp, class _TA> class _Ctr, class _Al>
  friend work_node& operator+=(work_node& _w, const _Ctr<delta_id,_Al>& _d);

  template <template <class _Tp, class _TA> class _Ctr, class _Al>
  friend work_node& operator-=(work_node& _w, const _Ctr<delta_id,_Al>& _d);

  friend class delta;
  friend class undelta;
  friend class certificate;
  friend class wnc_hook_base;
};


template <class _TW, class _TV, class _VR, class _TP, class _TR, class _TI>
class work_node::constraint_iterator_base
{
private:
  typedef constraint_iterator_base<_TW,_TV,_VR,_TP,_TR,_TI> _Self;

private:
  _TV __cs;
  _TI __c_cur;
  unsigned int __tp;

private:
  typedef _TV _Vector;
  typedef _TI _Iterator;
  typedef _VR _Reference;

public:

  typedef std::bidirectional_iterator_tag iterator_category;
  
  typedef _TW value_type;
  typedef _TR reference;
  typedef _TP pointer;

  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  
public:
  constraint_iterator_base() : __cs(NULL), __c_cur() {}
  constraint_iterator_base(_Reference cs, unsigned int tp)
                                        : __cs(&cs), __tp(tp) {}
  constraint_iterator_base(const _Self& __c)
                : __cs(__c.__cs), __c_cur(__c.__c_cur), __tp(__c.__tp) {}

  ~constraint_iterator_base() {}

  reference operator*() const { return *__c_cur; }
  pointer operator->() const { return &(operator*()); }

  bool operator==(const _Self& _c)
    { return __cs == _c.__cs && __c_cur == _c.__c_cur; }
  
  bool operator!=(const _Self& _c)
    { return __cs != _c.__cs || __c_cur != _c.__c_cur; }

  _Self& set(const _Iterator& _c);
  _Self& operator++();
  _Self operator++(int);
  _Self& operator--();
  _Self operator--(int);
  _Self& operator=(const _Self& _c);
};

} // namespace coco

#include <search_node.hpp>

#endif // _SEARCH_NODE_H_

---