Changeset 536 for trunk

Timestamp:

01/17/17 19:15:37 (8 years ago)

Author:

epyon

Message:

• ecs relationship tree

Location:

trunk/nv

Files:

• ecs/ecs.hh (modified) (5 diffs)
• stl/handle_manager.hh (modified) (2 diffs)

trunk/nv/ecs/ecs.hh

@@ -182 +182 @@
                         }
 
+                        virtual void attach( handle_type parent, handle_type child )
+                        {
+                                m_handles.detach( child );
+                                m_handles.attach( parent, child );
+                        }
+
+                        handle_type get_parent( handle_type h ) const
+                        {
+                                return h ? m_handles.get_parent( h ) : handle_type();
+                        }
+
+                        handle_type next( handle_type h ) const
+                        {
+                                return h ? m_handles.next( h ) : handle_type();
+                        }
+
+                        handle_type first( handle_type h ) const
+                        {
+                                return h ? m_handles.first( h ) : handle_type();
+                        }
+
                         void remove( handle_type h )
                         {
+                                handle_type ch = m_handles.first( h );
+                                while ( handle_type r = ch )
+                                {
+                                        ch = m_handles.next( ch );
+                                        remove( r );
+                                }
                                 for ( auto c : m_components )
                                         c->remove( h );
@@ -208 +235 @@
                 protected:
 
-                        handle_manager< handle_type >               m_handles;
+                        handle_tree_manager< handle_type >          m_handles;
                         vector< component_interface* >              m_components;
                         vector< receiver_interface* >               m_receivers;
@@ -246 +273 @@
                         value_type& insert( handle_type h )
                         {
-                                /*index_type i = */m_index.insert( h );
-                                //NV_ASSERT( i == m_data.size(), "Fail!" );
+                                index_type i = m_index.insert( h );
+                                NV_ASSERT( i == index_type( m_data.size() ), "Fail!" );
+                                NV_UNUSED( i );
                                 m_data.emplace_back();
                                 return m_data.back();
@@ -255 +283 @@
                         value_type& insert( handle_type h, Args&&... args )
                         {
-                                /*index_type i = */m_index.insert( h );
-                                //NV_ASSERT( i == m_data.size(), "Fail!" );
+                                index_type i = m_index.insert( h );
+                                NV_ASSERT( i == index_type( m_data.size() ), "Fail!" );
+                                NV_UNUSED( i );
                                 m_data.emplace_back( nv::forward<Args>( args )... );
                                 return m_data.back();
@@ -302 +331 @@
                                 return i >= 0 ? &( m_data[unsigned( i )] ) : nullptr;
                         }
-
 
                         virtual void remove( handle_type h )

trunk/nv/stl/handle_manager.hh

@@ -95 +95 @@
                         value_type counter;
                         index_type next_free;
-
+                        
                         index_entry() : counter( 0 ), next_free( NONE ) {}
                 };
@@ -118 +118 @@
         };
 
+        template < typename Handle, typename Index = sint32 >
+        class handle_tree_manager
+        {
+                typedef Index index_type;
+                static const index_type NONE = index_type( -1 );
+                static const index_type USED = index_type( -2 );
+        public:
+
+                typedef Handle handle_type;
+                typedef typename handle_type::value_type value_type;
+
+                handle_tree_manager() 
+                        : m_first_free( NONE ), m_last_free( NONE ) {}
+
+                handle_type create_handle()
+                {
+                        typedef handle_operator<handle_type> hop;
+                        value_type i = get_free_entry();
+                        m_entries[i].counter++;
+                        NV_ASSERT( m_entries[i].counter != 0, "Out of handles!" );
+                        m_entries[i].next_free = USED;
+                        return hop::create( i, m_entries[i].counter );
+                }
+
+                void free_handle( handle_type h )
+                {
+                        remove( h );
+                        value_type index = h.index();
+                        NV_ASSERT( m_entries[index].next_free == USED, "Unused handle freed!" );
+                        NV_ASSERT( m_entries[index].counter == handle_operator<handle_type>::get_counter( h ), "Handle corruption!" );
+                        m_entries[index].next_free = NONE;
+                        if ( m_last_free == NONE )
+                        {
+                                m_first_free = m_last_free = static_cast<index_type>( index );
+                                return;
+                        }
+                        m_entries[static_cast<value_type>( m_last_free )].next_free = static_cast<index_type>( index );
+                        m_last_free = static_cast<index_type>( index );
+                }
+
+                void attach( handle_type parent, handle_type child )
+                {
+                        value_type pindex = parent.index();
+                        value_type cindex = child.index();
+                        NV_ASSERT( m_entries[cindex].parent == NONE, "Attach called on handle with parent!" );
+                        m_entries[cindex].parent = pindex;
+                        m_entries[cindex].next_sibling = m_entries[pindex].first_child;
+                        m_entries[cindex].prev_sibling = NONE;
+                        m_entries[pindex].first_child = cindex;
+                }
+
+                handle_type get_parent( handle_type h ) const
+                {
+                        NV_ASSERT( is_valid( h ), "INVALID HANDLE" );
+                        value_type pindex = m_entries[h.index()].parent;
+                        typedef handle_operator<handle_type> hop;
+                        return pindex == NONE ? handle_type() : hop::create( pindex, m_entries[pindex].counter );
+                }
+
+                handle_type next( handle_type h ) const
+                {
+                        NV_ASSERT( is_valid( h ), "INVALID HANDLE" );
+                        value_type nindex = m_entries[ h.index() ].next_sibling;
+                        typedef handle_operator<handle_type> hop;
+                        return nindex == NONE ? handle_type() : hop::create( nindex, m_entries[nindex].counter ); 
+                }
+
+                handle_type first( handle_type h ) const
+                {
+                        NV_ASSERT( is_valid( h ), "INVALID HANDLE" );
+                        value_type nindex = m_entries[h.index()].first_child;
+                        typedef handle_operator<handle_type> hop;
+                        return nindex == NONE ? handle_type() : hop::create( nindex, m_entries[nindex].counter );
+                }
+
+
+                void remove( handle_type h )
+                {
+                        NV_ASSERT( m_entries[h.index()].first_child == NONE, "Remove called on handle with children!" );
+                        detach( h );
+                }
+
+                void remove_and_orphan( handle_type h )
+                {
+                        detach( h );
+                        value_type index = h.index();
+                        while ( m_entries[index].first_child != NONE )
+                        {
+                                value_type child = m_entries[index].first_child;
+                                m_entries[index].first_child  = m_entries[child].next_sibling;
+                                m_entries[child].parent       = NONE;
+                                m_entries[child].next_sibling = NONE;
+                                m_entries[child].prev_sibling = NONE;
+                        }
+                }
+
+                void detach( handle_type h )
+                {
+                        value_type index      = h.index();
+                        value_type pindex     = m_entries[index].parent;
+                        value_type next_index = m_entries[index].next_sibling;
+                        value_type prev_index = m_entries[index].prev_sibling;
+                        
+                        m_entries[index].parent       = NONE;
+                        m_entries[index].next_sibling = NONE;
+                        m_entries[index].prev_sibling = NONE;
+
+                        if ( pindex == NONE )
+                        {
+                                NV_ASSERT( next_index == NONE, "Hierarchy fail! next_index" );
+                                NV_ASSERT( prev_index == NONE, "Hierarchy fail! prev_index" );
+                                return;
+                        }
+                        if ( value_type( m_entries[pindex].first_child ) == index )
+                        {
+                                NV_ASSERT( prev_index == NONE, "Hierarchy fail! prev_index" );
+                                m_entries[pindex].first_child = next_index;
+                                if ( next_index == NONE ) // only child
+                                        return;
+                                m_entries[next_index].prev_sibling = NONE;
+                        }
+                        else
+                        {
+                                NV_ASSERT( prev_index != NONE, "Hierarchy fail! prev_index" );
+                                if ( next_index != NONE )
+                                        m_entries[next_index].prev_sibling = prev_index;
+                                if ( prev_index != NONE )
+                                        m_entries[prev_index].next_sibling = next_index;
+                        }
+                }
+
+                bool is_valid( handle_type h ) const
+                {
+                        typedef handle_operator<handle_type> hop;
+                        if ( h.is_nil() ) return false;
+                        if ( h.index() >= m_entries.size() ) return false;
+                        const index_entry& entry = m_entries[h.index()];
+                        return entry.next_free == USED && entry.counter == hop::get_counter( h );
+                }
+
+                void clear()
+                {
+                        m_first_free = NONE;
+                        m_last_free = NONE;
+                        m_entries.clear();
+                }
+
+        private:
+                struct index_entry
+                {
+                        value_type counter;
+                        index_type next_free;
+
+                        index_type parent;
+                        index_type first_child;
+                        index_type next_sibling;
+                        index_type prev_sibling;
+
+                        index_entry() 
+                                : counter( 0 )
+                                , next_free( NONE )
+                                , parent( NONE )
+                                , first_child( NONE )
+                                , next_sibling( NONE )
+                                , prev_sibling( NONE )
+                        {}
+                };
+
+                value_type get_free_entry()
+                {
+                        if ( m_first_free != NONE )
+                        {
+                                value_type result = static_cast<value_type>( m_first_free );
+                                m_first_free = m_entries[result].next_free;
+                                m_entries[result].next_free = USED;
+                                if ( m_first_free == NONE ) m_last_free = NONE;
+                                return result;
+                        }
+                        m_entries.emplace_back();
+                        return value_type( m_entries.size() - 1 );
+                }
+
+                index_type m_first_free;
+                index_type m_last_free;
+                vector< index_entry > m_entries;
+        };
+
+
 }