Context Navigation

source: trunk/nv/core/handle.hh @ 333

Last change on this file since 333 was 333, checked in by epyon, 11 years ago
extended handle_operator (unsafe ops) lua_handle library and support (multiple handle types supported)
File size: 9.0 KB

Rev	Line
[270]	1	// Copyright (C) 2014 ChaosForge Ltd
	2	// http://chaosforge.org/
	3	//
	4	// This file is part of NV Libraries.
	5	// For conditions of distribution and use, see copyright notice in nv.hh
	6
	7	/**
	8	* @file handle.hh
	9	* @author Kornel Kisielewicz
	10	*/
	11
[319]	12	#ifndef NV_CORE_HANDLE_HH
	13	#define NV_CORE_HANDLE_HH
[270]	14
[319]	15	#include <nv/core/common.hh>
	16	#include <nv/core/array.hh>
[270]	17
	18	namespace nv
	19	{
	20
	21	template <
	22	typename T = uint32,
	23	unsigned IBITS = 16,
	24	unsigned CBITS = 16,
	25	typename TAG = void
	26	>
	27	class handle
	28	{
	29	public:
	30	typedef T value_type;
[333]	31	typedef TAG tag_type;
[270]	32	static const int INDEX_BITS = IBITS;
	33	static const int COUNTER_BITS = IBITS;
	34	static const T MAX_INDEX = (1 << IBITS) - 1;
	35	static const T MAX_COUNTER = (1 << CBITS) - 1;
	36
	37	handle() : m_index(0), m_counter(0) {}
	38
[273]	39	inline bool operator==(const handle& rhs) const {return m_index == rhs.m_index && m_counter == rhs.m_counter; }
	40	inline bool operator!=(const handle& rhs) const {return !(*this == rhs);}
[270]	41
	42	bool is_nil() const { return m_index == 0 && m_counter == 0; }
	43	bool is_valid() const { return !is_nil(); }
[273]	44	T index() const { return m_index; }
[323]	45	size_t hash() const { return std::hash<T>()( T( m_counter << IBITS \| m_index ) ); }
[270]	46	protected:
	47	T m_index : IBITS;
	48	T m_counter : CBITS;
	49
	50	handle( T a_index, T a_counter ) : m_index( a_index ), m_counter( a_counter ) {}
[333]	51	template < typename H >
	52	friend class handle_operator;
[270]	53	};
	54
[333]	55	template < typename HANDLE >
	56	class handle_operator
	57	{
	58	public:
	59	typedef typename HANDLE::value_type value_type;
[273]	60
[333]	61	static HANDLE create( value_type index, value_type counter )
	62	{
	63	return HANDLE( index, counter );
	64	}
	65	static value_type get_counter( const HANDLE& h ) { return h.m_counter; }
	66	static value_type get_index( const HANDLE& h ) { return h.m_index; }
	67	};
[273]	68
[333]	69
[270]	70	template < typename HANDLE, typename TINDEX = sint32 >
	71	class index_store
	72	{
	73	public:
	74	typedef HANDLE handle;
	75	typedef TINDEX index_type;
	76	typedef typename HANDLE::value_type value_type;
	77
	78	index_store() : m_first_free(-1), m_last_free(-1) {}
	79
	80	handle create_handle( index_type index )
	81	{
[333]	82	typedef handle_operator<HANDLE> hop;
[270]	83	value_type i = get_free_entry();
	84	m_entries[i].index = index;
	85	m_entries[i].counter++;
[333]	86	return hop::create( i, m_entries[i].counter );
[270]	87	}
	88
	89	void free_handle( handle h )
	90	{
[333]	91	m_entries[ h.index() ].index = -1;
	92	m_entries[ h.index() ].next_free = -1;
[270]	93	if ( m_last_free == -1 )
	94	{
[333]	95	m_first_free = m_last_free = h.index();
[270]	96	return;
	97	}
[333]	98	m_entries[ (unsigned)m_last_free ].next_free = h.index();
	99	m_last_free = h.index();
[270]	100	}
	101
	102	void swap_indices( handle h1, handle h2 )
	103	{
[333]	104	std::swap( m_entries[ h1.index() ].index, m_entries[ h2.index() ].index );
[270]	105	}
	106
	107	sint32 get_index( handle h ) const
	108	{
[333]	109	typedef handle_operator<HANDLE> hop;
	110	return m_entries[ h.index() ].counter == hop::get_counter(h) ? m_entries[ h.index() ].index : -1;
[270]	111	}
	112	private:
	113	struct index_entry
	114	{
	115	index_type index;
	116	value_type counter;
	117	index_type next_free;
	118
	119	index_entry() : index(0), counter(0), next_free(-1) {}
	120	};
	121
	122	value_type get_free_entry()
	123	{
	124	if ( m_first_free != -1 )
	125	{
	126	value_type result = (value_type)m_first_free;
	127	m_first_free = m_entries[result].next_free;
	128	m_entries[result].next_free = -1;
	129	if ( m_first_free == -1 ) m_last_free = -1;
	130	return result;
	131	}
	132	m_entries.emplace_back();
	133	return value_type( m_entries.size() - 1 );
	134	}
	135
	136	index_type m_first_free;
	137	index_type m_last_free;
	138	std::vector< index_entry > m_entries;
	139	};
	140
[274]	141	template < typename T, typename HANDLE = handle<>, typename TINDEX = sint32 >
	142	class packed_indexed_array
	143	{
	144	public:
	145	typedef HANDLE handle;
	146	typedef TINDEX index_type;
	147	typedef std::vector< T > storage;
	148	typedef T value_type;
	149	typedef typename storage::iterator iterator;
	150	typedef typename storage::const_iterator const_iterator;
	151	typedef typename storage::reference reference;
	152	typedef typename storage::const_reference const_reference;
[273]	153
[274]	154	packed_indexed_array() {}
	155	packed_indexed_array( uint32 reserve )
	156	{
	157	m_data.reserve( reserve );
	158	m_indexes.reserve( reserve );
	159	}
[273]	160
[274]	161	T* insert( handle h )
	162	{
[323]	163	resize_indexes_to( (index_type) h.index() );
	164	m_indexes[ h.index() ] = (index_type) m_data.size();
[295]	165	m_handles.push_back( h );
[274]	166	m_data.emplace_back();
	167	return &(m_data.back());
	168	}
	169
	170	bool exists( handle h )
	171	{
	172	if ( h.is_nil() \|\| h.index() >= m_indexes.size() ) return false;
	173	return m_indexes[ h.index() ] >= 0;
	174	}
	175
	176	T* get( handle h )
	177	{
	178	if ( h.is_nil() \|\| h.index() >= m_indexes.size() ) return nullptr;
	179	index_type i = m_indexes[ h.index() ];
[323]	180	return i >= 0 ? &(m_data[ (unsigned)i ]) : nullptr;
[274]	181	}
	182
	183	void remove( handle h )
	184	{
	185	handle swap_handle = m_handles.back();
	186	sint32 dead_eindex = m_indexes[ h.index() ];
	187	if ( dead_eindex != (sint32)m_data.size()-1 )
	188	{
[323]	189	m_data[ (unsigned)dead_eindex ] = m_data.back();
	190	m_handles[ (unsigned)dead_eindex ] = swap_handle;
	191	m_indexes[ swap_handle.index() ] = dead_eindex;
[274]	192	}
	193	m_data.pop_back();
	194	m_handles.pop_back();
	195	m_indexes[ h.index() ] = -1;
	196	}
	197
	198	void clear()
	199	{
	200	m_data.clear();
	201	m_handles.clear();
	202	m_indexes.clear();
	203	}
	204
	205	const value_type& operator[] ( index_type i ) const { return m_data[i]; }
	206	value_type& operator[] ( index_type i ) { return m_data[i]; }
	207	size_t size() const { return m_data.size(); }
	208
	209	iterator begin() { return m_data.begin(); }
	210	const_iterator begin() const { return m_data.cbegin(); }
	211	const_iterator cbegin() const { return m_data.cbegin(); }
	212
	213	iterator end() { return m_data.end(); }
	214	const_iterator end() const { return m_data.cend(); }
	215	const_iterator cend() const { return m_data.cend(); }
	216
	217	private:
	218	void resize_indexes_to( index_type i )
	219	{
	220	index_type size = (index_type)m_indexes.size();
	221	if ( i >= size )
	222	{
	223	if ( size == 0 ) size = 1;
	224	while ( i >= size ) size = size * 2;
[323]	225	m_indexes.resize( (size_t)size, -1 );
[274]	226	}
	227	}
	228
	229	std::vector< T > m_data;
	230	std::vector< handle > m_handles;
	231	std::vector< index_type > m_indexes;
	232	};
	233
	234
[271]	235	template < typename T, typename HANDLE = handle<>, typename TINDEX = sint32 >
	236	class entity_store
	237	{
	238	public:
[272]	239	typedef HANDLE handle;
	240	typedef TINDEX index_type;
	241	typedef std::vector< T > storage;
	242	typedef T value_type;
	243	typedef typename storage::iterator iterator;
	244	typedef typename storage::const_iterator const_iterator;
	245	typedef typename storage::reference reference;
	246	typedef typename storage::const_reference const_reference;
[270]	247
[271]	248	entity_store() {}
[273]	249
	250	explicit entity_store( uint32 reserve )
	251	{
	252	m_handles.reserve( reserve );
	253	m_data.reserve( reserve );
	254	}
	255
[271]	256	handle create()
	257	{
	258	m_data.emplace_back();
	259	m_handles.push_back( m_indexes.create_handle( sint32( m_data.size() - 1 ) ) );
	260	return m_handles.back();
	261	}
[273]	262
[287]	263	const value_type* get( handle h ) const
	264	{
	265	if ( h.is_nil() ) return nullptr;
	266	sint32 eindex = m_indexes.get_index( h );
[323]	267	return eindex >= 0 ? &(m_data[ (unsigned)eindex ]) : nullptr;
[287]	268	}
	269
[271]	270	value_type* get( handle h )
	271	{
	272	if ( h.is_nil() ) return nullptr;
	273	sint32 eindex = m_indexes.get_index( h );
[323]	274	return eindex >= 0 ? &(m_data[ (unsigned)eindex ]) : nullptr;
[271]	275	}
[273]	276
[271]	277	void destroy( handle e )
	278	{
	279	handle swap_handle = m_handles.back();
	280	sint32 dead_eindex = m_indexes.get_index( e );
	281	if ( dead_eindex != (sint32)m_data.size()-1 )
	282	{
[323]	283	m_data[ (unsigned)dead_eindex ] = m_data.back();
	284	m_handles[ (unsigned)dead_eindex ] = m_handles.back();
[271]	285	}
	286	m_data.pop_back();
	287	m_handles.pop_back();
	288	m_indexes.swap_indices( e, swap_handle );
	289	m_indexes.free_handle( e );
	290	}
[272]	291
[323]	292	handle get_handle( index_type i ) const { return m_handles[(unsigned)i]; }
	293	const value_type& operator[] ( index_type i ) const { return m_data[(unsigned)i]; }
	294	value_type& operator[] ( index_type i ) { return m_data[(unsigned)i]; }
[274]	295	size_t size() const { return m_data.size(); }
	296
[272]	297	iterator begin() { return m_data.begin(); }
	298	const_iterator begin() const { return m_data.cbegin(); }
	299	const_iterator cbegin() const { return m_data.cbegin(); }
	300
	301	iterator end() { return m_data.end(); }
	302	const_iterator end() const { return m_data.cend(); }
	303	const_iterator cend() const { return m_data.cend(); }
	304
[271]	305	private:
	306	std::vector< handle > m_handles;
[272]	307	storage m_data;
[271]	308	index_store< handle, TINDEX > m_indexes;
	309	};
	310
[273]	311	}
[271]	312
[273]	313	namespace std
	314	{
	315	template <
	316	typename T,
	317	unsigned IBITS,
	318	unsigned CBITS,
	319	typename TAG
	320	>
	321	struct hash<nv::handle<T,IBITS,CBITS,TAG>>
	322	{
	323	size_t operator()(const nv::handle<T,IBITS,CBITS,TAG>& h) const
	324	{
	325	return h.hash();
	326	}
	327	};
[270]	328	}
	329
[319]	330	#endif // NV_CORE_HANDLE_HH

Note: See TracBrowser for help on using the repository browser.

Download in other formats: