Subversion Repositories spk

#ifndef BOB_POINT_BST
#define BOB_POINT_BST

#include "../common/ext_bstree.h"

class bob_point_bst
{
        private:
                template <class Key, class Ty>
                struct getkey
                {
                        Key operator() (const Ty& n) { return n->coord; }
                };
                
                template <class Key, class Ty>
                struct getkey2
                {
                        Key operator() (const Ty& n) { return n; }
                };
                
                struct node
                {
                        int coord;
                        
                        typedef ext::bstree<int, node*, getkey<int, node*> > nodebst;
                        
                        nodebst tree;
                        
                        node(int c) { coord=c; }
                };
                
                struct node2
                {
                        int x,y,z;
                        
                        node2() {}
                        node2(const bob_dom_point& p) { x=p.x; y=p.y; z=p.z; }
                        
                        bool operator == (const node2& r) const { return x==r.x && y==r.y && z==r.z; }
                };
                
                struct keyless
                {
                        bool operator () (const node2& left, const node2& right) const {
                                return left.x < right.x || 
                                (left.x == right.x && (left.y < right.y || (left.y == right.y && (left.z < right.z)))); 
                        }
                };
                
                node::nodebst level1;
                
                typedef ext::bstree<node2, node2, getkey2<node2, node2>, keyless> newbst;
                
                newbst tree;
                
        public:
                size_t m_compCount;
                
                bob_point_bst() { m_compCount=0; }
                
                void addPoint(bob_dom_point *pnt)
                {
                        node2 n=node2(*pnt);
                        newbst::insert_iterator &iit=tree.find(n);
                        if(iit==tree.end())
                                tree.insert(iit, n);
                        
                        m_compCount+=tree.m_compCount;
                        
                /*
                        node::nodebst::insert_iterator &iit=level1.find(pnt->x);
                        node::nodebst::const_iterator it;
                        if(iit==level1.end())
                                it=level1.insert(iit, new node(pnt->x));
                        else
                                it=iit;
                        
                        m_compCount+=level1.m_compCount;
                        
                        iit=it->tree.find(pnt->y);
                        m_compCount+=it->tree.m_compCount;
                        
                        if(iit==it->tree.end())
                                it=it->tree.insert(iit, new node(pnt->y));
                        else
                                it=iit;
                        
                        iit=it->tree.find(pnt->z);
                        m_compCount+=it->tree.m_compCount;
                        
                        if(iit==it->tree.end())
                                it=it->tree.insert(iit, new node(pnt->z));
                        else
                                it=iit;
                        
                        */
                }
                
};

#endif // !defined(BOB_POINT_BST)