Changeset 432

Timestamp:

07/21/15 14:12:57 (10 years ago)

Author:

epyon

Message:

• dedicated hash_store used instead of unordered_map

Location:

trunk

Files:

• nv/engine/resource_system.hh (modified) (3 diffs)
• nv/stl/container/hash_table.hh (modified) (3 diffs)
• nv/stl/container/hash_table_policy.hh (modified) (1 diff)
• nv/stl/hash_map.hh (modified) (1 diff)
• nv/stl/hash_store.hh (added)
• nv/stl/string_table.hh (modified) (2 diffs)
• nv/stl/unordered_map.hh (modified) (3 diffs)
• src/formats/assimp_loader.cc (modified) (2 diffs)

trunk/nv/engine/resource_system.hh

@@ -17 +17 @@
 #include <nv/interface/context.hh>
 #include <nv/lua/lua_state.hh>
-#include <nv/stl/unordered_map.hh>
+#include <nv/stl/hash_store.hh>
 #include <nv/stl/vector.hh>
 
@@ -43 +43 @@
 
                 lua::state* m_lua;
-                hashed_table< shash64, resource_id > m_names;
+                hash_store< shash64, resource_id > m_names;
         };
 
@@ -99 +99 @@
         protected:
                 vector< resource_manager_base* >     m_managers;
-                unordered_map< uint64, resource_id > m_manager_names;
+                hash_store< shash64, resource_id > m_manager_names;
                 lua::state* m_lua_state; 
         };

trunk/nv/stl/container/hash_table.hh

@@ -422 +422 @@
                 typename SuperClass = empty_type
         >
-        class hash_table : public hash_table_storage< HashEntryPolicy, RehashPolicy, SuperClass >
+        class hash_table_base : public hash_table_storage< HashEntryPolicy, RehashPolicy, SuperClass >
         {
                 typedef hash_table_storage< HashEntryPolicy, RehashPolicy, SuperClass > base_type;
@@ -447 +447 @@
 
         public: // constructors
-                hash_table() {}
-                explicit hash_table( size_type size ) : base_type( size ) {}
-                hash_table( const hash_table& other ) = delete;
-                hash_table( hash_table&& other ) = default;
+                hash_table_base() {}
+                explicit hash_table_base( size_type size ) : base_type( size ) {}
+                hash_table_base( const hash_table_base& other ) = delete;
+                hash_table_base( hash_table_base&& other ) = default;
                 template< typename InputIterator >
-                hash_table( InputIterator first, InputIterator last ) : base_type()
+                hash_table_base( InputIterator first, InputIterator last ) : base_type()
                 {
                         insert( first, last );
@@ -459 +459 @@
         public: // assignements
 
-                hash_table& operator=( const hash_table& other ) = delete;
-                hash_table& operator=( hash_table&& other ) = default;
+                hash_table_base& operator=( const hash_table_base& other ) = delete;
+                hash_table_base& operator=( hash_table_base&& other ) = default;
 
         public: // iterators

trunk/nv/stl/container/hash_table_policy.hh

@@ -145 +145 @@
         {
                 template< typename H >
-                static size_t get_index( H h, size_t n ) { return h % n; }
+                static enable_if_t< is_integral< H >::value, size_t >
+                get_index( H h, size_t n ) { return h % n; }
+
+                template< typename H >
+                static enable_if_t< is_class< H >::value, size_t >
+                get_index( H h, size_t n ) { return h.value() % n; }
+
 
                 static uint32 get_bucket_count( uint32 requested_count )

trunk/nv/stl/hash_map.hh

@@ -88 +88 @@
                 template < typename > class InsertConvertPolicy = hash_table_no_extra_types_policy
         >
-        class hash_map : public hash_table< EntryPolicy, QueryConvertPolicy >
+        class hash_map : public hash_table_base< EntryPolicy, QueryConvertPolicy >
         {
         public:
-                typedef hash_table< EntryPolicy, QueryConvertPolicy >                base_type;
+                typedef hash_table_base< EntryPolicy, QueryConvertPolicy >                base_type;
                 typedef hash_map< Key, Mapped, Hash, EntryPolicy, QueryConvertPolicy > this_type;
                 typedef typename base_type::value_type                                           value_type;

trunk/nv/stl/string_table.hh

@@ -16 +16 @@
 #include <nv/stl/vector.hh>
 #include <nv/stl/string.hh>
-#include <nv/stl/unordered_map.hh>
+#include <nv/stl/hash_store.hh>
 #include <nv/stl/stream.hh>
 
@@ -30 +30 @@
                 typedef uint32 size_type;
                 typedef uint16 length_type;
-                typedef unordered_map< hash_type, size_type > indexer_type;
+                typedef hash_store< hash_type, size_type > indexer_type;
                 typedef vector< char > storage_type;
                 typedef indexer_type::const_iterator const_iterator;

trunk/nv/stl/unordered_map.hh

@@ -230 +230 @@
         >
         class unordered_map
-                : public hash_table< 
+                : public hash_table_base<
                         HashEntryPolicy,
                         hash_table_no_extra_types_policy,
@@ -238 +238 @@
         {
         public:
-                typedef hash_table< 
+                typedef hash_table_base<
                         HashEntryPolicy,
                         hash_table_no_extra_types_policy,
@@ -324 +324 @@
         };
 
-        // TODO: remove and make a proper hashed map
-        template <
-                typename Key,
-                typename T,
-                typename Hasher = hash< Key, typename Key::value_type >,
-                typename KeyEqual = equal_to< Key >,
-                typename HashEntryPolicy = hash_table_stl_map_policy< Key, T, typename Key::value_type, KeyEqual, Hasher >
-        >
-        class hashed_table
-                : public hash_table<
-                HashEntryPolicy,
-                hash_table_no_extra_types_policy,
-                hash_table_prime_rehash_policy,
-                HashEntryPolicy
-                >
-        {
-        public:
-                typedef hash_table<
-                        HashEntryPolicy,
-                        hash_table_no_extra_types_policy,
-                        hash_table_prime_rehash_policy,
-                        HashEntryPolicy
-                > base_type;
-                typedef typename base_type::value_type                                           value_type;
-                typedef typename base_type::pointer                                              pointer;
-                typedef typename base_type::const_pointer                                        const_pointer;
-                typedef typename base_type::reference                                            reference;
-                typedef typename base_type::const_reference                                      const_reference;
-                typedef typename base_type::iterator                                             iterator;
-                typedef typename base_type::const_iterator                                       const_iterator;
-                typedef typename base_type::size_type                                            size_type;
-                typedef typename base_type::difference_type                                      difference_type;
-                typedef typename base_type::key_type                                             key_type;
-                typedef typename base_type::mapped_type                                          mapped_type;
-                typedef typename base_type::node_type                                            node_type;
-                typedef typename base_type::insert_return_type                                   insert_return_type;
-                typedef Hasher                                                                   hasher;
-                typedef KeyEqual                                                                 key_equal;
-
-                using base_type::base_type;
-
-                mapped_type& operator[]( const key_type& key )
-                {
-                        return ( *base_type::insert_key( key ).first ).second;
-                }
-        };
-
-
 }
 

trunk/src/formats/assimp_loader.cc

@@ -8 +8 @@
 
 #include "nv/interface/data_channel_access.hh"
-#include "nv/stl/unordered_map.hh"
+#include "nv/stl/hash_store.hh"
 #include "nv/lib/assimp.hh"
 
@@ -288 +288 @@
         const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
         mesh_nodes_data* result = new mesh_nodes_data( make_name( "bones" ) );
-        hashed_table< shash64, uint16 > names;
+        hash_store< shash64, uint16 > names;
         for ( unsigned int m = 0; m < m_mesh_count; ++m )
         {