node.hpp

Go to the documentation of this file.

#ifndef _node_hpp_
#define _node_hpp_
//---------------------------------------------
#include<iostream>
#include<vector>
#include"utils.hpp"
 
template <class X1, template<typename> class pred_type> class CMMTree;
                                              
template <class T>
typename std::vector<T>::const_iterator const& Null_iterator( T ) {
  static std::vector<T> vec;
  static typename std::vector<T>::const_iterator it = vec.begin();
  return it;  
}
 
template <class X1>
class node{
  public:
  using data_addr = typename std::vector<X1>::const_iterator ;
 
  private:
  node<X1>*                  parent;              
  data_addr                  d_iterator;          
  std::vector< node<X1>* >*  children;            
  
  #ifdef NODE_COUNTER
    static unsigned n_count;                                  
    static  inline std::mutex _mutex;                       
  public:
    static inline std::mutex &mutex() { return _mutex; }          
  #endif
 
  public:
 
  node(node<X1>* const& prev, const data_addr& pos ): parent(prev), d_iterator(pos), children(0) {
    #ifdef NODE_COUNTER
      n_count++;
    #endif
  } 
  
  node():parent(nullptr), d_iterator( Null_iterator( X1() ) ), children(nullptr){
    #ifdef NODE_COUNTER
      n_count++;
    #endif
  }
 
  node(node<X1> const& ) = delete;                         
 
  node<X1>& operator=(node<X1> const& ) = delete;          
 
  node(node<X1>&& other)noexcept
  : parent( std::move(other.parent) ), d_iterator( std::move(other.d_iterator) ), children( std::move(other.children ) )
  {}
 
  node<X1>& operator=(node<X1>&& other)noexcept{
    parent = std::move(other.parent); d_iterator = std::move(other.d_iterator); children = std::move(other.children );
  }
 
  ~node();
 
  bool isNULLit(data_addr const& r)const {
    return r == Null_iterator(X1()) ? true : false;
  }
 
  void add_new_node( data_addr const & pos );
 
  size_t node_level()const;
 
  data_addr const& data_address() const {return d_iterator;}
 
  data_addr& data_address(){return d_iterator;}
 
  void data_on_path(std::vector< data_addr > & vec) const; 
 
  node<X1>* const& parent_node_address()const { return parent; }
 
  node<X1>const* this_node_address()const { return this; }
  //node<X1>* this_node_address() { return this; }
 
  size_t children_number()const { return children ? children->size() : 0 ; }
 
  size_t siblings_number()const { return parent ? parent->children_number()-1 : 0; }
  void change_children_capacity()const { if(parent) parent->children->shrink_to_fit(); }
 
  node<X1>* const& operator[](size_t i)const  {
    if(!children) throw std::runtime_error("ERROR ! node<T>::operator[]()\nThe current node is a leaf - it has no any children.\n");
    if(i>=children->size()) throw std::runtime_error("ERROR ! node<T>::operator[]()\nIndex out of range.\n");
    return children->operator[](i);
  }
 
  std::vector< node<X1>* > const& childrenVec()const {return *children;}
 
  std::vector< node<X1>* > & childrenVec() {return *children;}
 
  void all_siblings_addresses(std::vector< const node<X1>* > & vec)const;
 
  X1 const& node_value()const {
    if( isNULLit(d_iterator) ) throw std::runtime_error("ERROR ! node<T>::node_value()\nYou can not use this function for root node\nwhen you have decided beforehand that root will not refer to any element of the input dataset.\n");
    return *d_iterator;
  }
 
  static void n_counter_info(){ 
    #ifdef NODE_COUNTER
      SetColor(BLUE);
      std::cout << "Number of nodes<" << typeid(X1).name() << "> = ";
      SetColor(BBLUE);
      std::cout << n_count << std::endl;
      SetColor(DEFAULT);
    #else
      std::cout << "Information about the number of node objects is not available.\nUncomment the NODE_COUNTER directive to start object counting." << std::endl;
    #endif
  }
 
  static unsigned n_Count(){
    #ifdef NODE_COUNTER
      return n_count;
    #else
      println("Information about the number of node objects is not available.\nUncomment the NODE_COUNTER directive to start object counting.");
      return 0; 
    #endif 
  }
 
  template <class T1, template<typename> class T2> friend class CMMTree;
};
 
//---------------------------------------------
#endif