Changeset 274 for trunk

Timestamp:

07/04/14 21:57:48 (11 years ago)

Author:

epyon

Message:

• packed_indexed_array (experimental)

File:

• trunk/nv/handle.hh (modified) (4 diffs)

trunk/nv/handle.hh

@@ -123 +123 @@
         };
 
-
-
         template < typename T, typename HANDLE = handle<>, typename TINDEX = sint32 >
-        class entity_store
+        class packed_indexed_array
         {
         public:
@@ -138 +136 @@
                 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 +251 @@
                 }
 
-                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 +265 @@
                         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(); }