Changeset 438

Timestamp:

07/23/15 17:29:49 (10 years ago)

Author:

epyon

Message:

• massive amount of std::string removal
• removed slurp, use filesystem::slurp instead
• lua_values const_string support
• several bugfixes
• program_manager and shader loading without std::string/std::stream

Location:

trunk

Files:

• nv/core/random.hh (modified) (2 diffs)
• nv/core/time.hh (modified) (1 diff)
• nv/core/types.hh (modified) (1 diff)
• nv/engine/program_manager.hh (modified) (1 diff)
• nv/gfx/texture_font.hh (modified) (2 diffs)
• nv/gl/gl_device.hh (modified) (2 diffs)
• nv/gl/gl_enum.hh (modified) (1 diff)
• nv/interface/device.hh (modified) (1 diff)
• nv/io/c_file_system.hh (modified) (1 diff)
• nv/io/c_stream.hh (modified) (1 diff)
• nv/lua/lua_values.hh (modified) (1 diff)
• nv/stl/container/contiguous_storage.hh (modified) (1 diff)
• nv/stl/container/growing_storage.hh (modified) (3 diffs)
• nv/stl/file_system.hh (modified) (2 diffs)
• nv/stl/string.hh (modified) (2 diffs)
• nv/stl/string/const_string.hh (modified) (2 diffs)
• nv/stl/string/short_string.hh (modified) (5 diffs)
• src/core/library.cc (modified) (2 diffs)
• src/engine/program_manager.cc (modified) (5 diffs)
• src/gfx/texture_font.cc (modified) (2 diffs)
• src/gl/gl_device.cc (modified) (1 diff)
• src/gl/gl_enum.cc (modified) (1 diff)
• src/io/c_file_system.cc (modified) (3 diffs)
• src/lua/lua_raw.cc (modified) (1 diff)
• src/stl/string.cc (modified) (1 diff)

trunk/nv/core/random.hh

@@ -18 +18 @@
         {
         public:
-                typedef unsigned int result_type; // std::mt19937::result_type
+                typedef unsigned int result_type; // mt19937::result_type
                 typedef unsigned int seed_type;
 
@@ -174 +174 @@
                 }
         private:
-                // temporary solution until we get rid of std::random
+                // temporary solution until we get rid of ::random
                 char m_data[16 * 1024];
         };

trunk/nv/core/time.hh

@@ -34 +34 @@
 
         /**
-         * Get millisecond count based on std::clock
+         * Get millisecond count based on ::clock
          */
         uint32 get_cpu_ms();
 
         /**
-         * Get microsecond count based on std::clock
+         * Get microsecond count based on ::clock
          */
         uint64 get_cpu_us();

trunk/nv/core/types.hh

@@ -33 +33 @@
         };
 
-        template<>
-        struct is_container < std::string >
-        {
-                static const bool value = false;
-        };
+//      template<>
+//      struct is_container < string_view >
+//      {
+//              static const bool value = false;
+//      };
 
         struct type_entry;

trunk/nv/engine/program_manager.hh

@@ -28 +28 @@
         protected:
                 virtual resource_id load_resource( lua::table_guard& table );
-                void load_source( lua::table_guard& table, std::string& out, const std::string& append );
+                string_buffer load_source( lua::table_guard& table, const string_view& append );
                 virtual void release( program p );
         private:
                 context* m_context;
-                std::string   m_vertex_head;
-                std::string   m_fragment_head;
+                const_string m_shader_head;
         };
 

trunk/nv/gfx/texture_font.hh

@@ -43 +43 @@
         {
                 public:
-                        texture_font( texture_atlas* atlas, const char * filename, float size );
+                        texture_font( texture_atlas* atlas, const string_view& filename, float size );
                         const texture_glyph* get_glyph( uint16 charcode ) const;
                         bool load_glyphs( string_view codes );
@@ -54 +54 @@
 
                         texture_atlas* m_atlas; //!< Atlas Image object for this font.
-                        std::string m_filename; //!< Name of the file.
+                        string128 m_filename;//!< Filename
                         float m_size;           //!< Font size.
                         float m_height;         //!< Height of the font. (x-height?)

trunk/nv/gl/gl_device.hh

@@ -56 +56 @@
                 virtual int get_attribute_location( program p, const std::string& name, bool fatal = true ) const;
                 virtual void prepare_program( program p );
-                virtual const std::string& get_shader_header() const { return m_shader_header; }
+                virtual string_view get_shader_header() const { return m_shader_header; }
                 virtual ~gl_device();
         protected:
                 uniform_base* get_uniform( program p, const std::string& name, bool fatal = true ) const;
 
-        
         private:
                 bool compile( gl_program_info* p, string_view vertex_program, string_view fragment_program );
@@ -68 +67 @@
                 void load_attributes( gl_program_info* p );
                 void load_uniforms( gl_program_info* p );
-                std::string m_shader_header;
+                string_buffer m_shader_header;
                 handle_store< gl_texture_info, texture >         m_textures;
                 handle_store< gl_buffer_info,  buffer >          m_buffers;

trunk/nv/gl/gl_enum.hh

@@ -45 +45 @@
         unsigned int datatype_to_gl_enum( datatype type );
         datatype gl_enum_to_datatype( unsigned int gl_enum );
-        std::string datatype_to_glsl_type( datatype type );
+        string_view datatype_to_glsl_type( datatype type );
 
 } // namespace nv

trunk/nv/interface/device.hh

@@ -182 +182 @@
                 virtual const texture_info* get_texture_info( texture ) const = 0;
                 virtual const buffer_info* get_buffer_info( buffer ) const = 0;
-                virtual const std::string& get_shader_header() const = 0;
+                virtual string_view get_shader_header() const = 0;
 
                 virtual texture create_texture( image_data* data, sampler asampler ) 

trunk/nv/io/c_file_system.hh

@@ -25 +25 @@
                 c_file_system();
                 virtual ~c_file_system();
-                virtual bool exists( const char* fpath );
-                virtual stream* open( const char* fpath, const char* fmode = "rb" );
+                virtual const_string slurp( const string_view& path );
+                virtual bool exists( const string_view& );
+                virtual stream* open( const string_view&, const string_view& = "rb" );
         };
 

trunk/nv/io/c_stream.hh

@@ -26 +26 @@
         protected:
                 c_stream();
+                // TODO: const char* is prone to deletion - don't store it, or store differently!
                 c_stream( void* pfile, const char* filename );
         public:

trunk/nv/lua/lua_values.hh

@@ -167 +167 @@
 
                 template <>
+                struct pass_traits < const_string >
+                {
+                        static void push( lua_State *L, const const_string& s ) { detail::push_string_view( L, s ); }
+                        static const_string to( lua_State *L, int index ) { return const_string( detail::to_string_view( L, index ) ); }
+                        static const_string to( lua_State *L, int index, const_string def ) { return const_string( detail::to_string_view( L, index, def ) ); }
+                };
+
+                template <>
                 struct pass_traits<ref>
                 {

trunk/nv/stl/container/contiguous_storage.hh

@@ -83 +83 @@
                                 reallocate( 0, false );
                                 m_data = other.m_data;
+                                other.m_data = nullptr;
                         }
                         return *this;

trunk/nv/stl/container/growing_storage.hh

@@ -112 +112 @@
                 inline growing_storage& operator=( growing_storage&& other )
                 {
-                        Storage::reallocate( 0, false );
-                        m_size = other.m_size;
-                        Storage::operator=( nv::move( other ) );
-                        other.m_size = size_impl_type();
+                        if ( this != &other )
+                        {
+                                m_size = other.m_size;
+                                Storage::operator=( nv::move( other ) );
+                                other.m_size = size_impl_type();
+                        }
                         return *this;
                 }
@@ -179 +181 @@
                 void insert( iterator position, const value_type& value )
                 {
-                        iterator iend = Storage::data() + m_size;
+                        ptrdiff_t offset = position - Storage::data();
                         if ( try_grow( 1 ) )
                         {
-                                raw_alias_copy( position, iend, position + 1 );
-                                copy_construct_object( position, value );
+                                iterator iposition = Storage::data() + offset;
+                                iterator iend = Storage::data() + m_size - 1;
+                                raw_alias_copy( iposition, iend, iposition + 1 );
+                                copy_construct_object( iposition, value );
                         }
                 }
@@ -192 +196 @@
                         // TODO: distance can't be called on destructive iterators - check 
                         //   and use pushback if needed?
-                        iterator iend = Storage::data() + m_size;
+                        ptrdiff_t offset = position - Storage::data();
                         size_type d = distance( first, last );
                         if ( try_grow( d ) )
                         {
-                                raw_alias_copy( position, iend, position + d );
-                                InitializePolicy::copy( first, last, position );
+                                iterator iposition = Storage::data() + offset;
+                                iterator iend = Storage::data() + m_size - d;
+                                raw_alias_copy( iposition, iend, iposition + d );
+                                InitializePolicy::copy( first, last, iposition );
                         }
                 }

trunk/nv/stl/file_system.hh

@@ -14 +14 @@
 
 #include <nv/common.hh>
+#include <nv/stl/string.hh>
 #include <nv/stl/stream.hh>
 
@@ -25 +26 @@
         public:
                 virtual ~file_system() {}
-                virtual bool exists( const char* fpath ) = 0;
-                virtual stream* open( const char* fpath, const char* fmode = "rb" ) = 0;
+                virtual const_string slurp( const string_view& path ) = 0;
+                virtual bool exists( const string_view& path ) = 0;
+                virtual stream* open( const string_view& path, const string_view& mode = "rb" ) = 0;
+
         };
 

trunk/nv/stl/string.hh

@@ -29 +29 @@
 #include <nv/stl/string/short_string.hh>
 #include <string>
-#include <sstream>
 #include <nv/stl/type_traits/primary.hh>
 #include <nv/stl/memory.hh>
@@ -47 +46 @@
                 inline H operator()( const std::string& value ) const { return get( value ); }
         };
-
-
-        /**
-        * Simple function for slurping a file into a string.
-        */
-        std::string slurp( const std::string& filename );
 
         namespace detail

trunk/nv/stl/string/const_string.hh

@@ -41 +41 @@
                         initialize( s, N - 1 );
                 }
+                // TODO : implement
+                //              inline string_buffer_base( const string_twine& twine );
+
                 ~const_string()
                 {
@@ -74 +77 @@
                 {
                         char* new_data = new char[s + 1];
-                        nvmemcpy( new_data, p, s );
+                        if (p) nvmemcpy( new_data, p, s );
                         new_data[s] = 0;
                         assign( new_data, s );

trunk/nv/stl/string/short_string.hh

@@ -10 +10 @@
 #include <nv/stl/string/common.hh>
 #include <nv/stl/string/string_base.hh>
+#include <nv/stl/string/string_twine.hh>
 #include <nv/stl/container/random_access.hh>
 #include <nv/stl/container/contiguous_storage.hh>
@@ -32 +33 @@
                 }
 
+
+                template < typename Base >
+                inline explicit string_buffer_base( const string_base< Base >& s ) : this_type( s.data(), s.size() ) {}
                 inline explicit string_buffer_base( const string_view& s ) : this_type( s.data(), s.size() ) {}
-                template < typename S >
-                inline string_buffer_base( const string_base<S>& rhs ) : this_type( rhs.data(), rhs.size() ) {}
+
+                inline string_buffer_base( const string_twine& twine )
+                {
+                        append( twine );
+                }
                 inline string_buffer_base( string_buffer_base&& copy ) = default;
                 inline string_buffer_base& operator=( string_buffer_base&& other ) = default;
-                inline string_buffer_base& operator=( const string_view& other )
-                {
-                        clear();
-                        append( other );
-                }
 
                 size_t append( const char* data, size_t sz )
@@ -49 +51 @@
                         raw_copy_n( data, amount, this->begin() + pos );
                         return amount;
+                }
+
+                size_t append( const string_twine& twine )
+                {
+                        size_t pos = size();
+                        size_t dump_size = twine.dump_size();
+                        expand_by( dump_size );
+                        twine.dump( array_ref< char >( data() + pos, size() - pos ) );
+                        return size() - pos;
                 }
 
@@ -111 +122 @@
                 void reserve( size_type new_capacity )
                 {
-                        Storage::reserve( new_capacity + 1, true );
+                        Storage::reserve( new_capacity + 1 );
                         this->data()[this->size()] = 0;
                 }
@@ -117 +128 @@
                 void resize( size_type new_size )
                 {
-                        Storage::reserve( new_size + 1, true );
+                        Storage::reserve( new_size + 1 );
                         Storage::resize( min( new_size, capacity() - 1 ) );
                         this->data()[this->size()] = 0;

trunk/src/core/library.cc

@@ -6 +6 @@
 
 #include "nv/core/library.hh"
-#include <string>
 
 #if NV_PLATFORM == NV_WINDOWS
@@ -74 +73 @@
     NV_LOG_NOTICE( "library \"", m_name, "\" : loading..." );
 
-        std::string name( m_name.data(), m_name.length() );
-        std::string ext( NV_LIB_EXT );
+        string128 name( m_name );
+        string_view ext( NV_LIB_EXT );
 
-        if ( name.length() < ext.length() || name.substr( name.length() - ext.length(), ext.length() ) != ext )
+        if ( name.length() < ext.length() || !name.ends_with( ext ) )
     {
-        name.append( ext.data(), ext.length() );
+        name.append( ext );
     }
 
-    m_handle = NV_LIB_OPEN( name.c_str() );
+    m_handle = NV_LIB_OPEN( name.data() );
 
     if ( m_handle == NULL )
     {
-                NV_LOG_NOTICE( "library \"", m_name, "\" : failed to open!" );
+                NV_LOG_NOTICE( "library \"", name, "\" : failed to open!" );
                 return false;
     }

trunk/src/engine/program_manager.cc

@@ -9 +9 @@
 #include "nv/core/logging.hh"
 #include "nv/lua/lua_nova.hh"
-
+#include "nv/io/c_file_system.hh"
 
 nv::program_manager::program_manager( context* a_context ) : m_context( a_context )
 {
-        m_vertex_head   = a_context->get_device()->get_shader_header();
-        m_fragment_head = a_context->get_device()->get_shader_header();
+        m_shader_head = a_context->get_device()->get_shader_header();
 }
 
@@ -20 +19 @@
 {
         NV_LOG_DEBUG( table.get_string("id") );
-        std::string vsource;
-        std::string fsource;
-        std::string csource;
+        string_buffer vsource;
+        string_buffer fsource;
+        string_buffer header( m_shader_head );
         if ( table.is_table("common") )
         {
                 lua::table_guard common( table, "common" );
-                load_source( common, csource, "" );
+                header.append( "\n" + load_source( common, "" ) + "\n" );
         }
         {
                 lua::table_guard vtable( table, "vertex" );
-                load_source( vtable, vsource, m_vertex_head+"\n"+csource+"\n");
+                vsource = load_source( vtable, header );
         }
         {
                 lua::table_guard ftable( table, "fragment" );
-                load_source( ftable, fsource, m_fragment_head+"\n"+csource+"\n" );
+                fsource = load_source( ftable, header );
         }
 
-        nv::program program = m_context->get_device()->create_program( string_view( vsource.c_str(), vsource.size() ), string_view( fsource.c_str(), fsource.size() ) );
+        nv::program program = m_context->get_device()->create_program( vsource, fsource );
         return add( program );
 }
@@ -46 +45 @@
 }
 
-void nv::program_manager::load_source( lua::table_guard& table, std::string& out, const std::string& append )
+nv::string_buffer nv::program_manager::load_source( lua::table_guard& table, const string_view& append )
 {
-        out = append;
+        c_file_system fs;
+        string_buffer out( append );
         if ( table.is_string( "files" ) )
         {
-                out += nv::slurp( table.get_std_string( "files" ) );
+                out.append( fs.slurp( table.get_string( "files" ) ) );
         }
         else if ( table.is_table( "files" ) )
@@ -59 +59 @@
                 for ( uint32 i = 1; i <= count; ++i )
                 {
-                        std::string include( inctable.get<std::string,uint32>(i) );
-                        if ( i == count ) out += "#line 1\n";
-                        out += nv::slurp( include );
+                        const_string include( inctable.get<const_string,uint32>(i) );
+                        if ( i == count ) out.append( "#line 1\n" );
+                        out.append( fs.slurp( include ) );
                 }
         }
@@ -67 +67 @@
         if ( table.is_string( "file" ) )
         {
-                out += "#line 1\n" + nv::slurp( table.get_std_string( "file" ) );
+                const_string data = fs.slurp( table.get_string( "file" ) );
+                out.append( "#line 1\n" + data );
         }
 
         if ( table.is_string( "source" ) )
         {
-                out += table.get_std_string( "source" );
+                out.append( table.get_string( "source" ) );
         }
+        return out;
 }

trunk/src/gfx/texture_font.cc

@@ -29 +29 @@
 }
 
-texture_font::texture_font( texture_atlas* atlas, const char * filename, float size )
-        : m_atlas( atlas ), m_filename(filename), m_size( size ), 
+texture_font::texture_font( texture_atlas* atlas, const string_view& filename, float size )
+        : m_atlas( atlas ), m_filename( filename ), m_size( size ),
         m_height(0), m_linegap(0), m_ascender(0), m_descender(0),
         m_hinting( true ), m_filtering( true ), m_rlibrary( nullptr ), m_rface( nullptr )
@@ -53 +53 @@
         NV_CHECK_FREETYPE_ERROR( error, "error on FT_Init_FreeType, code - ", error );
 
-        error = FT_New_Face( reinterpret_cast<FT_Library>(m_rlibrary), filename, 0, reinterpret_cast<FT_Face*>(&m_rface) );
+        error = FT_New_Face( reinterpret_cast<FT_Library>(m_rlibrary), filename.data(), 0, reinterpret_cast<FT_Face*>(&m_rface) );
         NV_CHECK_FREETYPE_ERROR( error, "error on FT_New_Face, code - ", error );
 

trunk/src/gl/gl_device.cc

@@ -17 +17 @@
 gl_device::gl_device()
 {
-        m_shader_header  = "#version 120\n";
+        m_shader_header.append( "#version 120\n" );
         for ( auto& i : get_uniform_factory() ) 
-                m_shader_header += "uniform "+datatype_to_glsl_type( i.second->get_datatype() )+" "+ std::string( i.first.data(), i.first.size() ) +";\n";
+                m_shader_header.append( "uniform "+datatype_to_glsl_type( i.second->get_datatype() )+" "+ i.first +";\n" );
         for ( auto& i : get_link_uniform_factory() ) 
-                m_shader_header += "uniform sampler2D "+std::string( i.first.data(), i.first.size() ) +";\n";
+                m_shader_header.append( "uniform sampler2D "+i.first +";\n" );
 }
 

trunk/src/gl/gl_enum.cc

@@ -354 +354 @@
 }
 
-std::string nv::datatype_to_glsl_type( datatype type )
+string_view nv::datatype_to_glsl_type( datatype type )
 {
         switch( type )

trunk/src/io/c_file_system.cc

@@ -11 +11 @@
 using namespace nv;
 
+
 c_file_system::c_file_system()
 {
@@ -21 +22 @@
 }
 
-bool c_file_system::exists( const char* fpath )
+bool c_file_system::exists( const string_view& fpath )
 {
-        FILE* file = ::fopen( fpath, "rb" );
+        FILE* file = ::fopen( fpath.data(), "rb" );
         if ( !file )
         {
@@ -32 +33 @@
 }
 
-stream* c_file_system::open( const char* fpath, const char* fmode /*= "rb" */ )
+stream* c_file_system::open( const string_view& fpath, const string_view& fmode /*= "rb" */ )
 {
-        NV_ASSERT( fpath != nullptr && fmode != nullptr, "Bad parameters passed to open" );
-        FILE* file = ::fopen( fpath, fmode );
+        NV_ASSERT( !fpath.empty() && !fmode.empty(), "Bad parameters passed to open" );
+        FILE* file = ::fopen( fpath.data(), fmode.data() );
         if ( !file )
         {
                 return nullptr;
         }
-        return new c_stream( file, fpath );
+        return new c_stream( file, fpath.data() );
 }
+
+nv::const_string c_file_system::slurp( const string_view& path )
+{
+        stream* fstream = open( path, "rb" );
+        if ( !fstream ) return const_string();
+        uint32 size = fstream->size();
+        const_string result( nullptr, size );
+        fstream->read( const_cast<char*>( result.data() ), size, 1 );
+        delete fstream;
+        return result;
+}

trunk/src/lua/lua_raw.cc

@@ -30 +30 @@
         {
                 size_t l = nv::uint64_to_buffer( buffer, nv::uint64( lua_touserdata( L, idx ) ) );
-                return nv::string_view( buffer.data(), buffer.size() );
+                return nv::string_view( buffer.data(), l );
         }
         else if ( type == LUA_TNUMBER )
         {
                 size_t l = nv::f64_to_buffer( buffer, lua_tonumber( L, idx ) );
-                return nv::string_view( buffer.data(), buffer.size() );
+                return nv::string_view( buffer.data(), l );
         }
         return "UNKNOWN!";

trunk/src/stl/string.cc

@@ -12 +12 @@
 #include <cstdlib>
 #include <fstream> // for slurp only
+#include <sstream> // for slurp only
 
 using namespace nv;
 
 //static const double s_power_10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
-
-std::string nv::slurp( const std::string& filename )
-{
-        std::ifstream input( filename );
-        //              if ( !input.is_open() ) NV_THROW( std::runtime_error, "File "+filename+" not found!");
-        std::stringstream sstr;
-        while ( input >> sstr.rdbuf() );
-        return sstr.str();
-}
 
 static inline void string_reverse( char* begin, char* end )