Subversion Repositories spk

#ifndef NEW_POINT_MAP_INCLUDED

#define NEW_POINT_MAP_INCLUDED

#include "../common/ext_array.h"

#include "../common/ext_simple_list.h"

#include "../common/ext_patricia_trie.h"

class point_traits

{

	public:

		static const size_t element_bits=32;

		static size_t size(const int *key) { return 3; }

		static bool compare(const int *k1, const int *k2) 

		{ 

			if(k1==0 || k2==0) 

				return false;

			else

				return 

			k1[0]==k2[0] &&

			k1[1]==k2[1] &&

			k1[2]==k2[2];

		}

		static int * copy(const int *key) { return (int*)key; }

		static void free(int *key) { }

};

class bob_point_map

{

	private:

		class vertex_bucket;

		class bucket_allocator;

		typedef ext::array<bob_vertex*> vertex_array;

		typedef ext::array<int> int_array;

		typedef ext::simple_list<int> int_list;

		typedef ext::patricia_trie<int, vertex_bucket, point_traits, bucket_allocator> vertex_trie;

		vertex_trie m_trie;

		vertex_array m_points; // all points

		int_array m_indexes; // converted indexes

		int m_pointSize; // size of points

		int_list m_uniqueIndexes; // list of indexes to unique points in points array

		int_list::iterator m_unique_it;

	private:

		class vertex_bucket 

		{

			private:

				int m_index;

			public:

				int index() const { return m_index; }

				void index(int i) { m_index=i; }

				vertex_bucket() { m_index=0; }

		};

		class bucket_allocator

		{

			public:

				static void deallocate(vertex_bucket pb) {  }

		};

	public:

		typedef vertex_array::iterator iterator;

		typedef vertex_array::const_iterator const_iterator;

		typedef int_list::const_iterator const_index_iterator;

		iterator begin() { return m_points.begin(); }

		iterator end() { return m_points.end(); }

		const_iterator begin() const { return m_points.begin(); }

		const_iterator end() const { return m_points.end(); }

		const_index_iterator indexBegin() const { return m_uniqueIndexes.begin(); }

		const_index_iterator indexEnd() const { return m_uniqueIndexes.end(); }

		size_t m_compCount;

		void create(size_t size)

		{

			m_points.resize(size, 0);

			m_indexes.resize(size);

			m_pointSize=0;

			m_compCount=0;

		}

		void addPoint(bob_vertex * pnt)

		{

			vertex_bucket pb;

			const int *coords=pnt->getCoordArray();

			vertex_trie::iterator where=m_trie.find(coords);

			if(where==m_trie.end()) {

				pb.index((int)m_uniqueIndexes.size());

				m_uniqueIndexes.push_back(m_pointSize);

				m_trie.insert(vertex_trie::value_type(coords, pb));

			}

			else

				pb=(*where).second;

			m_points[m_pointSize]=pnt;

			m_indexes[m_pointSize]=pb.index();

			m_pointSize++;

		}

		bob_point_map() { m_pointSize=0; m_unique_it=m_uniqueIndexes.end(); }

		~bob_point_map() { clear(); }

		void clear()

		{

			m_trie.clear();

			for(vertex_array::iterator &it=m_points.begin(); it!=m_points.end(); ++it){

				delete *it;

			}

			m_points.clear();

			m_indexes.clear();

			m_pointSize=0;

			m_unique_it=m_uniqueIndexes.end();

		}

		bob_vertex * operator[](int idx) { return m_points[idx]; }

		const bob_vertex * operator[](int idx) const { return m_points[idx]; }

		int uniqueIndex(int idx) const { return (size_t)idx < m_points.size() ? m_indexes[idx] : -1; }

		size_t pointsSize() const { return m_points.size(); }

		size_t uniquePointsSize() const { return m_uniqueIndexes.size(); }

		bob_vertex * nextUniquePoint()

		{

			++m_unique_it;

			bob_vertex *p=(m_unique_it!=m_uniqueIndexes.end() ? m_points[*m_unique_it] : 0);

			return p;

		}

		void test_trie_clear() { m_trie.test_clear(); }

};

#endif // !defined(NEW_POINT_MAP_INCLUDED)