source: to-imperative/trunk/runtime/rf_table.ih @ 1123

#ifndef __rf_table_ih__

#define __rf_table_ih__

#include <typeinfo>
#include "rf_table.hh"
#include "rf_object.ih"
#include "rf_expr.ih"
#include <new>

namespace rftype
{

inline Table::Table()
  : Object()
{
  static bool flag = false;
  if (!flag) {
    flag = true;
    TableNode::nil = new TableNode;
    TableNode::nil->color = TableNode::BLACK;
  }
  root = TableNode::nil;
  count ++;
}

inline unsigned Table::get_type () const
{
  return reg.get_type();
}

inline uint32_t Table::hash () const
{
  return 0;
}

inline bool Table::operator== (Object const& _table) const
{
  try {
    Table const&  t = static_cast <Table const&>(_table);  
    return table_equal(*root, *t.root);
 }
  catch (std::bad_cast&)
  {
    return false;
  }
} 

//
// Destructor: deleting of this-RBtree 
inline Table::~Table ()
{  
   if (root != TableNode::nil) 
     delete_tree(root);
   count--;
   if (!count)
     delete(TableNode::nil);
}

inline Expr Table::domain ()
{  
  Expr res = Expr();
  if (root != TableNode::nil)
    list_node(*root, res);   
  return res;
}

//  zaglushka  - hash-function
inline int expr_hash (Expr const& _key)
{
  return _key.get_len();
}

inline void Table::bind (Expr const& _key, Expr const& _val)
{ 
  TableNode* new_node;
  if ((new_node = search_node(_key)) == TableNode::nil) { 
    new_node = new TableNode;
    new_node->key = _key;
    new_node->hash_key = expr_hash(_key);
    new_node->left = TableNode::nil;
    new_node->right = TableNode::nil;
    new_node->p = TableNode::nil;
    new_node->val = _val;
    insert_node_RB(new_node);
  }
  else
    new_node->val = _val;
}

inline void Table::unbind (Expr& _key)
{
  TableNode* new_node;
  if ((new_node = search_node(_key)) != TableNode::nil) {
    new_node = delete_node_RB(new_node);
    delete(new_node);
  }
}


inline bool Table::lookup (Expr const& _key, Expr& _val)
{   
  TableNode* new_node;
  if ((new_node = search_node(_key)) == TableNode::nil)
    return false;    
  else {
    _val = new_node->val;
    return true;
  }
}


inline bool Table::in_table (Expr const& _key)
{
  TableNode* new_node;
  if ((new_node = search_node(_key)) == TableNode::nil)
    return false;
  else
    return true;
}

 
// 
// Table_copy : this - sourceTable, newTable - result 
inline void Table::table_copy (Table& _new_table)
{  
  TableNode* node;
  if (root != TableNode::nil) {
    node = new TableNode;
    node->p = TableNode::nil;       
    _new_table.root = node;   // p - root  
    copy_tree(*root, *node);  // p - root 
  }
}

 
// 
//  ReplaceTable: this - TargetTable 
inline void Table::replace_table (Table const& _source_table)   
{   
  TableNode* x;
  if (root != TableNode::nil) { 
    delete_tree(root);
    root = TableNode::nil;   
  }
  if (_source_table.root != TableNode::nil) {   
    x = new TableNode;
    x->p = TableNode::nil;
    root = x;      
    copy_tree(*_source_table.root, *root);
  }
}

 
}

#endif     // __rf_table_ih__