Index: trunk/nv/engine/resource_system.hh =================================================================== --- trunk/nv/engine/resource_system.hh (revision 431) +++ trunk/nv/engine/resource_system.hh (revision 432) @@ -17,5 +17,5 @@ #include #include -#include +#include #include @@ -43,5 +43,5 @@ lua::state* m_lua; - hashed_table< shash64, resource_id > m_names; + hash_store< shash64, resource_id > m_names; }; @@ -99,5 +99,5 @@ 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; }; Index: trunk/nv/stl/container/hash_table.hh =================================================================== --- trunk/nv/stl/container/hash_table.hh (revision 431) +++ trunk/nv/stl/container/hash_table.hh (revision 432) @@ -422,5 +422,5 @@ 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,10 +447,10 @@ 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,6 +459,6 @@ 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 Index: trunk/nv/stl/container/hash_table_policy.hh =================================================================== --- trunk/nv/stl/container/hash_table_policy.hh (revision 431) +++ trunk/nv/stl/container/hash_table_policy.hh (revision 432) @@ -145,5 +145,11 @@ { 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 ) Index: trunk/nv/stl/hash_map.hh =================================================================== --- trunk/nv/stl/hash_map.hh (revision 431) +++ trunk/nv/stl/hash_map.hh (revision 432) @@ -88,8 +88,8 @@ 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; Index: trunk/nv/stl/hash_store.hh =================================================================== --- trunk/nv/stl/hash_store.hh (revision 432) +++ trunk/nv/stl/hash_store.hh (revision 432) @@ -0,0 +1,114 @@ +// Copyright (C) 2015 ChaosForge Ltd +// http://chaosforge.org/ +// +// This file is part of Nova libraries. +// For conditions of distribution and use, see copying.txt file in root folder. + +/** + * @file hash_store.hh + * @author Kornel Kisielewicz + * @brief hash_store class + */ + +#ifndef NV_STL_HASH_STORE_HH +#define NV_STL_HASH_STORE_HH + +#include +#include +#include + +namespace nv +{ + + template < + typename Mapped, + typename Hash + > + struct hash_store_entry_policy + { + typedef Hash key_type; + typedef Hash query_type; + typedef Mapped mapped_type; + typedef Hash hash_type; + typedef pair< hash_type, mapped_type > value_type; + + struct entry_type + { + value_type value; + }; + + static constexpr hash_type get_hash( const key_type& t ) { return t; } + static constexpr hash_type get_hash( const value_type& t ) { return t.first; } + static constexpr hash_type get_entry_hash( const entry_type* entry ) { return entry->value.first; } + static constexpr hash_type get_value_hash( const value_type& value ) { return value.first; } + + static constexpr bool entry_compare( const entry_type* entry, hash_type h, const key_type& ) + { + return entry->value.first == h; + } + static constexpr bool entry_compare( const entry_type* entry, hash_type h, const value_type& ) + { + return entry->value.first == h; + } + + template < typename... Args > + static void entry_construct( entry_type* entry, hash_type hash_code, Args&&... params ) + { + construct_object( &( entry->value ), ::nv::forward( params )... ); + entry->value.first = hash_code; + } + + static void entry_destroy( entry_type* entry ) + { + destroy_object( &( entry->value ) ); + } + + }; + + template < typename H, typename T > + class hash_store + : public hash_table_base< + hash_store_entry_policy< T, H > + > + { + public: + typedef hash_table_base< hash_store_entry_policy< T, H > > base_type; + typedef H key_type; + typedef H query_type; + typedef T mapped_type; + typedef H hash_type; + + using base_type::base_type; + + mapped_type& operator[]( const key_type& key ) + { + return ( *base_type::insert_key( key ).first ).second; + } + + mapped_type& at( const query_type& key ) + { + iterator it = base_type::find( key ); + NV_ASSERT_ALWAYS( it != base_type::end(), "Key not found in map!" ); + return it->second; + } + + const mapped_type& at( const query_type& key ) const + { + const_iterator it = base_type::find( key ); + NV_ASSERT_ALWAYS( it != base_type::cend(), "Key not found in map!" ); + return it->second; + } + + template < typename M > + insert_return_type assign( hash_type& k, M&& obj ) + { + insert_return_type result = base_type::try_insert( k, nv::forward( obj ) ); + if ( !result.second ) result.first->second = obj; + return result; + } + + }; + +} + +#endif // NV_STL_HASH_STORE_HH Index: trunk/nv/stl/string_table.hh =================================================================== --- trunk/nv/stl/string_table.hh (revision 431) +++ trunk/nv/stl/string_table.hh (revision 432) @@ -16,5 +16,5 @@ #include #include -#include +#include #include @@ -30,5 +30,5 @@ 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; Index: trunk/nv/stl/unordered_map.hh =================================================================== --- trunk/nv/stl/unordered_map.hh (revision 431) +++ trunk/nv/stl/unordered_map.hh (revision 432) @@ -230,5 +230,5 @@ > class unordered_map - : public hash_table< + : public hash_table_base< HashEntryPolicy, hash_table_no_extra_types_policy, @@ -238,5 +238,5 @@ { public: - typedef hash_table< + typedef hash_table_base< HashEntryPolicy, hash_table_no_extra_types_policy, @@ -324,52 +324,4 @@ }; - // 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; - } - }; - - } Index: trunk/src/formats/assimp_loader.cc =================================================================== --- trunk/src/formats/assimp_loader.cc (revision 431) +++ trunk/src/formats/assimp_loader.cc (revision 432) @@ -8,5 +8,5 @@ #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,5 +288,5 @@ const aiScene* scene = reinterpret_cast( 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 ) {