Index: trunk/src/formats/assimp_loader.cc
===================================================================
--- trunk/src/formats/assimp_loader.cc	(revision 427)
+++ trunk/src/formats/assimp_loader.cc	(revision 428)
@@ -305,6 +305,6 @@
 				if ( iname == names.end() )
 				{
-					NV_ASSERT( result->get_count() < MAX_BONES, "Too many bones to merge!" );
-					uint16 index = uint16( result->get_count() );
+					NV_ASSERT( result->size() < MAX_BONES, "Too many bones to merge!" );
+					uint16 index = uint16( result->size() );
 					result->push_back( bone );
 					names[ bone->get_name() ] = index;
Index: trunk/src/formats/md5_loader.cc
===================================================================
--- trunk/src/formats/md5_loader.cc	(revision 427)
+++ trunk/src/formats/md5_loader.cc	(revision 428)
@@ -112,5 +112,5 @@
 			m_nodes = new mesh_nodes_data( make_name( "md5_bones") );
 			discard( sstream, "{" );
-			for ( size_t i = 0; i < m_nodes->get_count(); ++i )
+			for ( size_t i = 0; i < m_nodes->size(); ++i )
 			{
 				std::string name;
@@ -245,5 +245,5 @@
 
 			discard( sstream, "{" );
-			for ( size_t i = 0; i < m_nodes->get_count(); ++i )
+			for ( size_t i = 0; i < m_nodes->size(); ++i )
 			{
 				std::string    name;
@@ -288,5 +288,5 @@
 			next_line( sstream ); 
 
-			for ( size_t i = 0; i < m_nodes->get_count(); ++i )
+			for ( size_t i = 0; i < m_nodes->size(); ++i )
 			{
 				transform base_frame;
Index: trunk/src/formats/nmd_loader.cc
===================================================================
--- trunk/src/formats/nmd_loader.cc	(revision 427)
+++ trunk/src/formats/nmd_loader.cc	(revision 428)
@@ -206,5 +206,5 @@
 	nmd_element_header header;
 	header.type = nmd_type::ANIMATION;
-	header.children = static_cast<uint16>( nodes.get_count() );
+	header.children = static_cast<uint16>( nodes.size() );
 	header.size = total;
 	header.name = nodes.get_name();
Index: trunk/src/gfx/keyframed_mesh.cc
===================================================================
--- trunk/src/gfx/keyframed_mesh.cc	(revision 427)
+++ trunk/src/gfx/keyframed_mesh.cc	(revision 428)
@@ -40,5 +40,5 @@
 	m_pbuffer      = buffer();
 
-	if ( m_tag_map && m_tag_map->get_count() > 0 )
+	if ( m_tag_map && m_tag_map->size() > 0 )
 	{
 		m_interpolation_key = (*m_tag_map)[ 0 ]->get_interpolation_key();
@@ -54,5 +54,5 @@
 {
 	if ( !m_tag_map ) return transform();
-	NV_ASSERT( node_id < m_tag_map->get_count(), "TAGMAP FAIL" );
+	NV_ASSERT( node_id < m_tag_map->size(), "TAGMAP FAIL" );
 	NV_ASSERT( (*m_tag_map)[node_id]->size() > 0, "TAG FAIL" );
 	raw_channel_interpolator interpolator( ( *m_tag_map )[node_id], m_interpolation_key );
Index: trunk/src/gfx/mesh_creator.cc
===================================================================
--- trunk/src/gfx/mesh_creator.cc	(revision 427)
+++ trunk/src/gfx/mesh_creator.cc	(revision 428)
@@ -16,7 +16,6 @@
 	merge_keys();
 	uint32 max_frames = 0;
-	for ( size_t i = 0; i < m_data->get_count(); ++i )
-	{
-		data_channel_set* keys = m_data->m_data[i];
+	for ( auto keys : m_data->m_data )
+	{
 		sint16 parent_id = keys->get_parent_id();
 		data_channel_set* pkeys  = ( parent_id != -1 ? m_data->m_data[parent_id] : nullptr );
@@ -49,5 +48,5 @@
 void nv::mesh_nodes_creator::merge_keys()
 {
-	for ( size_t i = 0; i < m_data->get_count(); ++i )
+	for ( size_t i = 0; i < m_data->size(); ++i )
 	{
 		data_channel_set* old_keys = m_data->m_data[i];
@@ -100,7 +99,6 @@
 	mat4 post_transform( 1.f/scale * ri33 ); 
 
-	for ( size_t i = 0; i < m_data->get_count(); ++i )
-	{
-		data_channel_set* node = m_data->m_data[i];
+	for ( auto node : m_data->m_data )
+	{
 		node->m_transform = pre_transform * node->m_transform * post_transform;
 
Index: trunk/src/gfx/skeletal_mesh.cc
===================================================================
--- trunk/src/gfx/skeletal_mesh.cc	(revision 427)
+++ trunk/src/gfx/skeletal_mesh.cc	(revision 428)
@@ -18,8 +18,8 @@
 
 	m_pntdata.assign( pnt_chan->data_cast< md5_vtx_pnt >(), pnt_chan->size() );
-	m_bone_offset.resize( bones->get_count() );
-	m_transform.resize( bones->get_count() );
-
-	for ( uint32 i = 0; i < bones->get_count(); ++i )
+	m_bone_offset.resize( bones->size() );
+	m_transform.resize( bones->size() );
+
+	for ( uint32 i = 0; i < bones->size(); ++i )
 	{
 		m_bone_offset[i] = transform( (*bones)[i]->get_transform() );
@@ -110,5 +110,5 @@
 
 	float frame_num = new_time * m_node_data->get_frame_rate();
-	for ( size_t i = 0; i < m_node_data->get_count(); ++i )
+	for ( size_t i = 0; i < m_node_data->size(); ++i )
 	{
 		raw_channel_interpolator interpolator( (*m_node_data)[i], m_interpolation_key );
@@ -122,6 +122,5 @@
 	m_children  = nullptr;
 	m_offsets   = nullptr;
-	uint32 node_count = m_node_data->get_count();
-	m_bone_ids  = new sint16[ node_count ];
+	m_bone_ids  = new sint16[m_node_data->size()];
 
 	NV_ASSERT( m_node_data, "node data empty!" );
@@ -129,6 +128,6 @@
 	if ( !m_node_data->is_flat() )
 	{
-		m_children = new vector< uint32 >[ node_count ];
-		for ( uint32 n = 0; n < node_count; ++n )
+		m_children = new vector< uint32 >[m_node_data->size()];
+		for ( uint32 n = 0; n < m_node_data->size(); ++n )
 		{
 			const data_channel_set* node = (*m_node_data)[n];
@@ -153,8 +152,8 @@
 	}
 
-	for ( uint32 n = 0; n < m_node_data->get_count(); ++n )
+	for ( uint32 n = 0; n < m_node_data->size(); ++n )
 		if ( m_bone_ids[n] >= 0 )
 		{
-			const data_channel_set* node = m_node_data->get_node(n);
+			const data_channel_set* node = (*m_node_data)[n];
 			nv::mat4 node_mat( node->get_transform() );
 
@@ -174,15 +173,15 @@
 	if ( m_prepared ) return;
 	unordered_map< uint64, uint16 > bone_names;
-	m_offsets = new mat4[ bones->get_count() ];
-	for ( nv::uint16 bi = 0; bi < bones->get_count(); ++bi )
-	{
-		const data_channel_set* bone = bones->get_node( bi );
+	m_offsets = new mat4[ bones->size() ];
+	for ( nv::uint16 bi = 0; bi < bones->size(); ++bi )
+	{
+		const data_channel_set* bone = (*bones)[ bi ];
 		bone_names[ bone->get_name() ] = bi;
 		m_offsets[bi] = bone->get_transform();
 	}
 
-	for ( uint32 n = 0; n < m_node_data->get_count(); ++n )
-	{
-		const data_channel_set* node = m_node_data->get_node( n );
+	for ( uint32 n = 0; n < m_node_data->size(); ++n )
+	{
+		const data_channel_set* node = (*m_node_data)[ n ];
 		sint16 bone_id = -1;
 
@@ -205,5 +204,5 @@
 	// TODO: fix transforms, which are now embedded,
 	//       see note in assimp_loader.cc:load_node
-	const data_channel_set* node = m_node_data->get_node( node_id );
+	const data_channel_set* node = ( *m_node_data )[ node_id ];
 	mat4 node_mat( node->get_transform() );
 
@@ -242,5 +241,5 @@
 	if ( m_bone_data )
 	{
-		m_transform = new mat4[ m_bone_data->get_count() ];
+		m_transform = new mat4[ m_bone_data->size() ];
 	}
 }
@@ -259,5 +258,5 @@
 {
 	if ( m_bone_data )
-		m_context->get_device()->set_opt_uniform_array( a_program, "nv_m_bones", m_transform, m_bone_data->get_count() );
+		m_context->get_device()->set_opt_uniform_array( a_program, "nv_m_bones", m_transform, m_bone_data->size() );
 }
 
Index: trunk/src/io/string_table.cc
===================================================================
--- trunk/src/io/string_table.cc	(revision 427)
+++ 	(revision )
@@ -1,74 +1,0 @@
-// Copyright (C) 2014-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.
-
-#include "nv/io/string_table.hh"
-
-nv::string_table::string_table( stream& in )
-{
-	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; i++ )
-	{
-		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 );
-}
-
-void nv::string_table::insert( string_table* in )
-{
-	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 )
-	{
-		insert( hash_index.first, in->extract_raw( hash_index.second ) );
-	}
-}
-
-nv::uint32 nv::string_table::dump_size() const
-{
-	return sizeof( uint32 ) + sizeof( indexer_type::value_type ) * m_map.size() +
-		sizeof( uint32 ) + m_data.size();
-}
-
-void nv::string_table::dump( nv::stream& out ) const
-{
-	// 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 );
-}
-
-nv::string_table::size_type  nv::string_table::insert_raw( hash_type h, const char* str, length_type length )
-{
-	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;
-	if ( length > 0 )
-		raw_copy( str, str + length, m_data.data() + dsize + 2 );
-	m_data[dsize + 2 + length] = 0;
-	m_map[h] = dsize;
-	return dsize;
-}
-
Index: trunk/src/stl/string_table.cc
===================================================================
--- trunk/src/stl/string_table.cc	(revision 428)
+++ trunk/src/stl/string_table.cc	(revision 428)
@@ -0,0 +1,74 @@
+// Copyright (C) 2014-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.
+
+#include "nv/stl/string_table.hh"
+
+nv::string_table::string_table( stream& in )
+{
+	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; i++ )
+	{
+		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 );
+}
+
+void nv::string_table::insert( string_table* in )
+{
+	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 )
+	{
+		insert( hash_index.first, in->extract_raw( hash_index.second ) );
+	}
+}
+
+nv::uint32 nv::string_table::dump_size() const
+{
+	return sizeof( uint32 ) + sizeof( indexer_type::value_type ) * m_map.size() +
+		sizeof( uint32 ) + m_data.size();
+}
+
+void nv::string_table::dump( nv::stream& out ) const
+{
+	// 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 );
+}
+
+nv::string_table::size_type  nv::string_table::insert_raw( hash_type h, const char* str, length_type length )
+{
+	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;
+	if ( length > 0 )
+		raw_copy( str, str + length, m_data.data() + dsize + 2 );
+	m_data[dsize + 2 + length] = 0;
+	m_map[h] = dsize;
+	return dsize;
+}
+