Changeset 422 for trunk/src/io/string_table.cc

Timestamp:

07/16/15 19:22:35 (10 years ago)

Author:

epyon

Message:

• stream and file_system moved to stl
• hash literal operator
• string table rewrite

File:

• trunk/src/io/string_table.cc (modified) (1 diff)

trunk/src/io/string_table.cc

@@ -7 +7 @@
 #include "nv/io/string_table.hh"
 
-nv::string_table_creator::string_table_creator()
+nv::string_table::string_table( stream& in )
 {
-        insert(""); // 0 always is empty string
+        uint32 entry_count = 0;
+        in.read( &entry_count, sizeof( entry_count ), 1 );
+        m_map.reserve( entry_count );
+        indexer_type::value_type entry;
+        for ( uint32 i = 0; i < entry_count; )
+        {
+                in.read( &entry, sizeof( entry ), 1 );
+                // TODO: this performs a existence check -
+                //   using a per-container stream implementation would avoid this!
+                m_map.insert( entry );
+        }
+
+        uint32 data_size = 0;
+        in.read( &data_size, sizeof( data_size ), 1 );
+        // TODO: either no-init resize, or per-container implementation?
+        m_data.resize( data_size );
+        in.read( m_data.data(), data_size, 1 );
 }
 
-nv::string_table_creator::index nv::string_table_creator::insert( const string_view& s )
+void nv::string_table::insert( string_table* in )
 {
-        uint64 hash_value = hash_string< uint64 >( s.data() );
-        auto i = m_map.find( hash_value );
-        if ( i != m_map.end() )
+        m_data.reserve( m_data.size() + in->m_data.size() );
+        m_map.reserve( m_map.size() + in->m_map.size() );
+        for ( const auto& hash_index : in->m_map )
         {
-                return i->second;
+                insert( hash_index.first, in->extract_raw( hash_index.second ) );
         }
-        const char* cs = s.data();
-        uint32 cs_size = s.size() + 1;
-        NV_ASSERT( m_offsets.size() < index(-1), "Too many strings!" );
-        index  result = index( m_offsets.size() );
-        size_t dsize = m_data.size();
-        m_offsets.push_back( dsize );
-        m_data.resize( dsize + cs_size );
-        raw_copy( cs, cs + cs_size, m_data.data() + dsize );
-        m_map[ hash_value ] = result;
-        return result;
 }
 
-nv::string_table* nv::string_table_creator::create_table() const
+nv::uint32 nv::string_table::dump_size() const
 {
-        offset* offsets = new offset[m_offsets.size()];
-        char*   data    = new char [m_data.size()];
-        raw_copy( m_offsets.begin(), m_offsets.end(), offsets );
-        raw_copy( m_data.begin(),    m_data.end(),    data );
-        return new string_table( data, m_data.size(), offsets, index( m_offsets.size() ) );
+        return sizeof( uint32 ) + sizeof( indexer_type::value_type ) * m_map.size() +
+                sizeof( uint32 ) + m_data.size();
 }
 
-void nv::string_table_creator::dump( nv::stream* out ) const
+void nv::string_table::dump( nv::stream& out ) const
 {
-        index  count = index( m_offsets.size() );
-        uint32 size  = m_data.size();
-        out->write( &count,  sizeof( count ), 1 );
-        out->write( &size,   sizeof( size ), 1 );
-        out->write( m_offsets.data(), sizeof( offset ), count );
-        out->write( m_data.data(),    sizeof( char ),  size );
+        // TODO these should be generic stream operations
+        uint32 entry_count = m_map.size();
+        out.write( &entry_count, sizeof( entry_count ), 1 );
+        for ( const auto& entry : m_map )
+        {
+                out.write( &entry, sizeof( entry ), 1 );
+        }
+
+        uint32 data_size = m_data.size();
+        out.write( &data_size, sizeof( data_size ), 1 );
+        // TODO: either no-init resize, or per-container implementation?
+        out.write( m_data.data(), data_size, 1 );
 }
 
-const char* nv::string_table_creator::get( index i ) const
+nv::string_table::size_type  nv::string_table::insert_raw( hash_type h, const char* str, length_type length )
 {
-        return i < m_offsets.size() ? m_data.data() + m_offsets[i] : nullptr;
+        size_type dsize  = static_cast<uint32>( m_data.size() );
+        // TODO : resize without init!
+        m_data.resize( dsize + 2 + length + 1 );
+        *reinterpret_cast<uint16*>( m_data.data() + dsize ) = length;
+        raw_copy( str, str + length + 1, m_data.data() + dsize + 2 );
+        m_map[h] = dsize;
+        return dsize;
 }
 
-nv::string_table_creator::index nv::string_table_creator::get( const string_view& s ) const
-{
-        uint64 hash_value = hash_string< uint64 >( s.data() );
-        auto i = m_map.find( hash_value );
-        if ( i != m_map.end() )
-        {
-                return i->second;
-        }
-        return 0;
-}
-
-void nv::string_table_creator::clear()
-{
-        m_map.clear();
-        m_offsets.clear();
-        m_data.clear();
-}
-
-nv::uint32 nv::string_table_creator::dump_size() const
-{
-        return sizeof( index ) + sizeof( uint32 ) +
-                sizeof( offset ) * m_offsets.size() +
-                sizeof( char ) * m_data.size();
-}
-