cmmtree.hpp

Go to the documentation of this file.

#ifndef _cmmtree_hpp_
#define _cmmtree_hpp_
//---------------------------------------------
 
#include <functional>
#include <chrono>
#include <iomanip>
 
#include "predicates.hpp"
 
template <class X1, template<typename> class predicate >
class CMMTree
{ 
  using firstborns  = std::vector < node<X1>* >  ;                           
  using generations = std::vector < firstborns > ;                           
 
  node<X1>*                 root ;
  std::vector < X1 >const*  p_dataset ;                                      
  predicate<X1>             condition ;                                      
  generations               MTree ;                                          
 
  void add_next_firstborn(size_t generation, node<X1>* const& node_adr);
  void jagged_table_reconstruction(size_t lev);
  void find_new_generation( size_t generation );
 
 public:
  CMMTree(): root( new node<X1>() ), p_dataset(nullptr){ 
    MTree.push_back( firstborns( 1, root ) );            
  }                                                      
 
  CMMTree( std::vector < X1 >const* const& adr ): root( new node<X1>() ), p_dataset(adr){
    MTree.push_back( firstborns( 1, root ) );            
  }                                                      
 
  CMMTree( std::vector < X1 >const* const& adr, typename std::vector<X1>::const_iterator const& pos ): root( new node<X1>() ), p_dataset(adr){
    root->data_address()=pos;                            
    MTree.push_back( firstborns( 1, root ) );            
  }
 
  CMMTree(const CMMTree<X1, predicate>& ) = delete;
  
  CMMTree<X1, predicate>& operator=(const CMMTree<X1, predicate>& ) = delete;
 
  CMMTree(CMMTree&& other) noexcept 
    : root{std::move(other.root)}, p_dataset{std::move(other.p_dataset)}, condition{other.condition}, MTree{std::move(other.MTree)} 
  {
    other.root = new node<X1>();
    other.p_dataset = nullptr;
    other.MTree.emplace_back( firstborns( 1, other.root ) );
  }
 
  auto operator=(CMMTree&& other) noexcept ->CMMTree<X1, predicate>& {
    if(this != &other){
      delete root;
      root      = std::move(other.root);
      p_dataset = std::move(other.p_dataset);
      condition = other.condition;
      MTree     = std::move(other.MTree); 
      
      other.root      = new node<X1>();
      other.p_dataset = nullptr;
      other.MTree.emplace_back( firstborns( 1, other.root ) ); 
    }
    return *this;
  }
 
  ~CMMTree(){
    delete root;
  }
 
  void create_subtrees_roots( std::vector < X1 > const& roots_data );
 
  void join_data(std::vector < X1 >const* const& adr);
 
  void join_data(std::vector < X1 >const* const& adr, typename std::vector<X1>::const_iterator const& pos);
 
  long long tree_create();
 
  predicate<X1>& pred_value(){ return condition; }
 
  predicate<X1>const& pred_value()const{ return condition; }
 
  X1 const& firstborn_value(size_t i, size_t j)const  {
    return firstborn_address(i, j)->node_value();
  }
 
  size_t all_nodes_number()const{
    size_t an(0);
    for(size_t i=0; i<MTree.size(); ++i)
      an+=generation_size(i);
      
    return an;
  }
 
  size_t firstborns_number(size_t i)const; 
 
  size_t leaves_number(size_t i)const;
 
  size_t generation_size(size_t i)const;
 
  size_t tree_height()const { return MTree.size() - 1; }
 
  void generation_addresses(size_t i, std::vector< const node<X1>* > & vec)const;
 
  void generation_addresses(size_t i, std::vector<       node<X1>* > & vec)const;     
 
  void leaves_addresses(size_t i, std::vector< const node<X1>* > & vec)const;         //leaves addresses - at the level passed by the first argument
 
  const node<X1>*  brother_address( const node<X1>* ptr, size_t i)const;
    
  node<X1>const* const& firstborn_address(size_t i, size_t j)const;
 
  std::vector < X1 >const* const& P_dataset()const { return p_dataset; }               
 
  void delete_one_node( node<X1>* &to_del );
 
  void delete_nodes( std::vector< node<X1>* > & to_del, size_t lev );
 
  void tree_clear();
 
  void tree_shape(std::ostream& out)const;
 
  template <class T1, template<typename> class T2>
  friend
  std::ostream& operator<<(std::ostream& out, CMMTree<T1, T2> const& ref)  ;
};
 
//---------------------------------------------
#endif