RStarTree< LeafType, dimensions, min_child_items, max_child_items >::RemoveFunctor< Acceptor, LeafRemover > Struct Template Reference

#include "RStarTree.h"

Inheritance diagram for RStarTree< LeafType, dimensions, min_child_items, max_child_items >::RemoveFunctor< Acceptor, LeafRemover >:

Public Member Functions
	RemoveFunctor (const Acceptor &na, LeafRemover &lr, std::list< Leaf * > *ir, std::size_t *size)
bool	operator() (BoundedItem *item, bool isRoot=false)
void	QueueItemsToReinsert (Node *node)

Public Attributes
const Acceptor &	accept
LeafRemover &	remove
std::list< Leaf * > *	itemsToReinsert
std::size_t *	m_size

Detailed Description

template<typename LeafType, std::size_t dimensions, std::size_t min_child_items, std::size_t max_child_items>
template<typename Acceptor, typename LeafRemover>
struct RStarTree< LeafType, dimensions, min_child_items, max_child_items >::RemoveFunctor< Acceptor, LeafRemover >

Definition at line 679 of file RStarTree.h.

Constructor & Destructor Documentation

template<typename LeafType, std::size_t dimensions, std::size_t min_child_items, std::size_t max_child_items>

template<typename Acceptor , typename LeafRemover >

RStarTree< LeafType, dimensions, min_child_items, max_child_items >::RemoveFunctor< Acceptor, LeafRemover >::RemoveFunctor ( const Acceptor &  na, LeafRemover &  lr, std::list< Leaf * > *  ir, std::size_t *  size  )

inlineexplicit

Definition at line 691 of file RStarTree.h.

                        : accept(na), remove(lr), itemsToReinsert(ir), m_size(size) {}

Member Function Documentation

template<typename LeafType, std::size_t dimensions, std::size_t min_child_items, std::size_t max_child_items>

template<typename Acceptor , typename LeafRemover >

bool RStarTree< LeafType, dimensions, min_child_items, max_child_items >::RemoveFunctor< Acceptor, LeafRemover >::operator() ( BoundedItem *  item, bool  isRoot = false  )

inline

Definition at line 694 of file RStarTree.h.

References RStarNode< BoundedItem >::hasLeaves, and RStarNode< BoundedItem >::items.

                {
                        Node * node = static_cast<Node*>(item);
                
                        if (accept(node))
                        {       
                                // this is the easy part: remove nodes if they need to be removed
                                if (node->hasLeaves)
                                        node->items.erase(std::remove_if(node->items.begin(), node->items.end(), RemoveLeafFunctor<Acceptor, LeafRemover>(accept, remove, m_size)), node->items.end());
                                else
                                        node->items.erase(std::remove_if(node->items.begin(), node->items.end(), *this), node->items.end() );

                                if (!isRoot)
                                {
                                        if (node->items.empty())
                                        {
                                                // tell parent to remove us if theres nothing left
                                                delete node;
                                                return true;
                                        }
                                        else if (node->items.size() < min_child_items)
                                        {
                                                // queue up the items that need to be reinserted
                                                QueueItemsToReinsert(node);
                                                return true;
                                        }
                                }
                                else if (node->items.empty())
                                {
                                        // if the root node is empty, setting these won't hurt
                                        // anything, since the algorithms don't actually require 
                                        // the nodes to have anything in them. 
                                        node->hasLeaves = true;
                                        node->bound.reset();
                                }
                        }                       
                        
                        // anything else, don't remove it
                        return false;
                        
                }

template<typename LeafType, std::size_t dimensions, std::size_t min_child_items, std::size_t max_child_items>

template<typename Acceptor , typename LeafRemover >

void RStarTree< LeafType, dimensions, min_child_items, max_child_items >::RemoveFunctor< Acceptor, LeafRemover >::QueueItemsToReinsert ( Node *  node )

inline

Definition at line 739 of file RStarTree.h.

References evd::details::end(), RStarNode< BoundedItem >::hasLeaves, and RStarNode< BoundedItem >::items.

                {
                        typename std::vector< BoundedItem* >::iterator it = node->items.begin();
                        typename std::vector< BoundedItem* >::iterator end = node->items.end();
                
                        if (node->hasLeaves)
                        {
                                for(; it != end; it++)
                                        itemsToReinsert->push_back(static_cast<Leaf*>(*it));
                        }
                        else
                                for (; it != end; it++)
                                        QueueItemsToReinsert(static_cast<Node*>(*it));
                                        
                        delete node;
                }

Member Data Documentation

template<typename LeafType, std::size_t dimensions, std::size_t min_child_items, std::size_t max_child_items>

template<typename Acceptor , typename LeafRemover >

const Acceptor& RStarTree< LeafType, dimensions, min_child_items, max_child_items >::RemoveFunctor< Acceptor, LeafRemover >::accept

Definition at line 682 of file RStarTree.h.

template<typename LeafType, std::size_t dimensions, std::size_t min_child_items, std::size_t max_child_items>

template<typename Acceptor , typename LeafRemover >

std::list<Leaf*>* RStarTree< LeafType, dimensions, min_child_items, max_child_items >::RemoveFunctor< Acceptor, LeafRemover >::itemsToReinsert

Definition at line 686 of file RStarTree.h.

template<typename LeafType, std::size_t dimensions, std::size_t min_child_items, std::size_t max_child_items>

template<typename Acceptor , typename LeafRemover >

std::size_t* RStarTree< LeafType, dimensions, min_child_items, max_child_items >::RemoveFunctor< Acceptor, LeafRemover >::m_size

Definition at line 687 of file RStarTree.h.

template<typename LeafType, std::size_t dimensions, std::size_t min_child_items, std::size_t max_child_items>

template<typename Acceptor , typename LeafRemover >

LeafRemover& RStarTree< LeafType, dimensions, min_child_items, max_child_items >::RemoveFunctor< Acceptor, LeafRemover >::remove

Definition at line 683 of file RStarTree.h.

---

The documentation for this struct was generated from the following file:

• larreco/v06_64_02/source/larreco/ClusterFinder/RStarTree/RStarTree.h