Index: /trunk/nv/handle.hh
===================================================================
--- /trunk/nv/handle.hh	(revision 273)
+++ /trunk/nv/handle.hh	(revision 274)
@@ -123,8 +123,6 @@
 	};
 
-
-
 	template < typename T, typename HANDLE = handle<>, typename TINDEX = sint32 >
-	class entity_store
+	class packed_indexed_array
 	{
 	public:
@@ -138,4 +136,97 @@
 		typedef typename storage::const_reference const_reference;
 
+		packed_indexed_array() {}
+		packed_indexed_array( uint32 reserve )
+		{
+			m_data.reserve( reserve );
+			m_indexes.reserve( reserve );
+		}
+
+		T* insert( handle h )
+		{
+			resize_indexes_to( h.index() );
+			m_indexes[ h.index() ] = m_data.size();
+			m_data.emplace_back();
+			return &(m_data.back());
+		}
+
+		bool exists( handle h )
+		{
+			if ( h.is_nil() || h.index() >= m_indexes.size() ) return false;
+			return m_indexes[ h.index() ] >= 0;		
+		}
+
+		T* get( handle h )
+		{
+			if ( h.is_nil() || h.index() >= m_indexes.size() ) return nullptr;
+			index_type i = m_indexes[ h.index() ];
+			return i >= 0 ? &(m_data[ i ]) : nullptr;
+		}
+
+		void remove( handle h )
+		{
+			handle swap_handle    = m_handles.back();
+			sint32 dead_eindex    = m_indexes[ h.index() ];
+			if ( dead_eindex != (sint32)m_data.size()-1 )
+			{
+				m_data[ dead_eindex ]    = m_data.back();
+				m_handles[ dead_eindex ] = m_handles.back();
+				m_indexes[ h.index() ]   = m_indexes[ swap_handle.index() ];
+			}
+			m_data.pop_back();
+			m_handles.pop_back();
+			m_indexes[ h.index() ] = -1;
+		}
+
+		void clear()
+		{
+			m_data.clear();
+			m_handles.clear();
+			m_indexes.clear();
+		}
+
+		const value_type& operator[] ( index_type i ) const { return m_data[i]; }
+		value_type& operator[] ( index_type i ) { return m_data[i]; }
+		size_t size() const { return m_data.size(); }
+
+		iterator        begin()        { return m_data.begin(); }
+		const_iterator  begin()  const { return m_data.cbegin(); }
+		const_iterator  cbegin() const { return m_data.cbegin(); }
+
+		iterator        end()        { return m_data.end(); }
+		const_iterator  end()  const { return m_data.cend(); }
+		const_iterator  cend() const { return m_data.cend(); }
+
+	private:
+		void resize_indexes_to( index_type i )
+		{
+			index_type size = (index_type)m_indexes.size();
+			if ( i >= size )
+			{
+				if ( size == 0 ) size = 1;
+				while ( i >= size ) size = size * 2;
+				m_indexes.resize( size, -1 );
+			}
+		}
+
+		std::vector< T >          m_data;
+		std::vector< handle >     m_handles;
+		std::vector< index_type > m_indexes;
+	};
+
+
+	template < typename T, typename HANDLE = handle<>, typename TINDEX = sint32 >
+	class entity_store
+	{
+	public:
+		typedef HANDLE                   handle;
+		typedef TINDEX                   index_type;
+		typedef std::vector< T >         storage;
+		typedef T                        value_type;
+		typedef typename storage::iterator        iterator;
+		typedef typename storage::const_iterator  const_iterator;
+		typedef typename storage::reference       reference;
+		typedef typename storage::const_reference const_reference;
+
 		entity_store() {}
 
@@ -160,9 +251,4 @@
 		}
 
-		handle get_handle( index_type i ) const { return m_handles[i]; }
-		const T& operator[] ( index_type i ) const { return m_data[i]; }
-		T& operator[] ( index_type i ) { return m_data[i]; }
-		size_t size() const { return m_data.size(); }
-		
 		void destroy( handle e )
 		{
@@ -179,4 +265,9 @@
 			m_indexes.free_handle( e );
 		}
+
+		handle get_handle( index_type i ) const { return m_handles[i]; }
+		const value_type& operator[] ( index_type i ) const { return m_data[i]; }
+		value_type& operator[] ( index_type i ) { return m_data[i]; }
+		size_t size() const { return m_data.size(); }
 
 		iterator        begin()        { return m_data.begin(); }