/home/malcolm/tmp/duncan/prototype/0/server/charlist.h

#ifndef SERVER_CHARLIST_H_
#define SERVER_CHARLIST_H_

#include <vector>
#include <functional>
#include <utility>
#include "character.h"
#include "kdtree++/kdtree.hpp"

namespace server {

template <typename T> class CharList {
        public:
                typedef std::pair<T*,std::pair<double,double> > node_t;
        private:
        //      typedef std::pair<T*,std::pair<double,double> > node_t;
                typedef KDTree::KDTree<2,node_t,std::pointer_to_binary_function<node_t,size_t,double> > tree_t;
                tree_t tree_;
                //mutable T* dummy_;

                inline node_t make_node(T* c) const {
                        return std::make_pair(c,std::make_pair(c->row(),c->col()));
                }
                inline node_t make_node(double r, double c) const {
                        return std::make_pair((T*)0,std::make_pair(r,c));
                }
        public:
                typedef typename tree_t::const_iterator const_iterator;

                CharList() : tree_(std::ptr_fun(acc)) {
                //      dummy_=new T();
                //      dummy_->set_name("Dummy (tc)");
                }

                void insert(T* c) {tree_.insert(make_node(c));}

                void erase(T* c) {tree_.erase_exact(make_node(c));}

                void optimise() {tree_.optimise();}

                const_iterator begin() {return tree_.begin();}

                const_iterator end() {return tree_.end();}

                void square(double rc,double cc,double r,std::vector<node_t>& v) const {
                //      dummy_->set_pos(rc,cc);
                        tree_.find_within_range(make_node(rc,cc),r,std::back_inserter(v));      
                }

                void square(T* c,double r,std::vector<node_t>& v) const {
                        tree_.find_within_range(make_node(c),r,std::back_inserter(v));
                }

                T* nearest(double r, double c) {
                        //dummy_->set_pos(r,c);
                        typename tree_t::iterator iter=tree_.find_nearest(make_node(r,c)).first;
                        return (iter==tree_.end()?0:(*iter).first);
                }

                void move(T* e, double r, double c) {
                        erase(e);
                        e->set_pos(r,c);
                        insert(e);
                }

                static inline double acc(node_t c,size_t k) {return (k?c.second.second:c.second.first);}
};

}

#endif