Changeset 399

Timestamp:

06/13/15 11:47:09 (10 years ago)

Author:

epyon

Message:

• naming cleanup
• string_ref -> string_view (compatible with C++17 standard!)
• *_ref and const_*_ref, renamed to _ref and _view for consistency

Location:

trunk

Files:

• nv/core/library.hh (modified) (5 diffs)
• nv/core/logger.hh (modified) (6 diffs)
• nv/core/logging.hh (modified) (2 diffs)
• nv/core/profiler.hh (modified) (4 diffs)
• nv/engine/program_manager.hh (modified) (1 diff)
• nv/engine/resource_system.hh (modified) (1 diff)
• nv/fmod/fmod_audio.hh (modified) (1 diff)
• nv/formats/md3_loader.hh (modified) (1 diff)
• nv/formats/md5_loader.hh (modified) (1 diff)
• nv/gfx/texture_font.hh (modified) (1 diff)
• nv/gl/gl_device.hh (modified) (2 diffs)
• nv/interface/audio.hh (modified) (1 diff)
• nv/interface/context.hh (modified) (1 diff)
• nv/interface/device.hh (modified) (2 diffs)
• nv/interface/mesh_data.hh (modified) (1 diff)
• nv/interface/uniform.hh (modified) (1 diff)
• nv/lua/lua_nova.hh (modified) (1 diff)
• nv/lua/lua_path.hh (modified) (1 diff)
• nv/lua/lua_state.hh (modified) (8 diffs)
• nv/lua/lua_values.hh (modified) (4 diffs)
• nv/sdl/sdl_audio.hh (modified) (1 diff)
• nv/stl/container/contiguous_storage_policy.hh (modified) (3 diffs)
• nv/stl/memory.hh (modified) (5 diffs)
• nv/stl/string.hh (modified) (11 diffs)
• src/core/library.cc (modified) (6 diffs)
• src/core/logger.cc (modified) (5 diffs)
• src/core/profiler.cc (modified) (5 diffs)
• src/engine/program_manager.cc (modified) (1 diff)
• src/engine/resource_system.cc (modified) (1 diff)
• src/fmod/fmod_audio.cc (modified) (1 diff)
• src/formats/assimp_loader.cc (modified) (1 diff)
• src/formats/md3_loader.cc (modified) (3 diffs)
• src/formats/md5_loader.cc (modified) (1 diff)
• src/formats/nmd_loader.cc (modified) (1 diff)
• src/gfx/texture_font.cc (modified) (1 diff)
• src/gl/gl_device.cc (modified) (4 diffs)
• src/lua/lua_nova.cc (modified) (1 diff)
• src/lua/lua_path.cc (modified) (2 diffs)
• src/lua/lua_state.cc (modified) (27 diffs)
• src/lua/lua_values.cc (modified) (2 diffs)
• src/sdl/sdl_audio.cc (modified) (1 diff)

trunk/nv/core/library.hh

@@ -39 +39 @@
                  * Throws library_error on failure
                  */
-                void open( string_ref name );
+                void open( string_view name );
 
                 /**
@@ -46 +46 @@
                  * returns true if succeeded, false otherwise
                  */
-                bool try_open( string_ref name );
+                bool try_open( string_view name );
 
                 /**
@@ -56 +56 @@
                  * Returns library name
                  */
-                string_ref get_name() const;
+                string_view get_name() const;
 
                 /**
@@ -63 +63 @@
                  * Throws on symbol not found
                  */
-                void* get( string_ref symbol );
+                void* get( string_view symbol );
 
                 /**
@@ -70 +70 @@
                  * Returns null if symbol not found
                  */
-                void* try_get( string_ref symbol );
+                void* try_get( string_view symbol );
 
                 /**

trunk/nv/core/logger.hh

@@ -34 +34 @@
                  * @param message message to be logged.
                  */
-                virtual void log( log_level level, const string_ref& message ) = 0;
+                virtual void log( log_level level, const string_view& message ) = 0;
                 /**
                  * Enforcement of virtual destructor.
@@ -47 +47 @@
                 * Log level name (unpadded)
                 */
-                string_ref level_name( log_level level ) const;
+                string_view level_name( log_level level ) const;
                 /**
                 * Log level name (padded)
                 */
-                string_ref padded_level_name( log_level level ) const;
+                string_view padded_level_name( log_level level ) const;
         };
 
@@ -86 +86 @@
                  * @param message message to be logged.
                  */
-                virtual void log( log_level level, const string_ref& message );
+                virtual void log( log_level level, const string_view& message );
 
                 /** 
@@ -144 +144 @@
                  * Logging function.
                  */
-                virtual void log( log_level level, const string_ref& message );
+                virtual void log( log_level level, const string_view& message );
 
         private:
@@ -176 +176 @@
                  * Logging function.
                  */
-                virtual void log( log_level level, const string_ref& message );
+                virtual void log( log_level level, const string_view& message );
 
         protected:
@@ -201 +201 @@
                 * @param flush_always if set to false, wont flush after each line.
                 */
-                log_file_sink( const string_ref& file_name, bool flush_always = true );
+                log_file_sink( const string_view& file_name, bool flush_always = true );
 
                 /**

trunk/nv/core/logging.hh

@@ -50 +50 @@
                         m_level = level;
                 }
-                virtual void log( log_level level, const string_ref& message ) = 0;
-                void log_append( string_ref ref )
+                virtual void log( log_level level, const string_view& message ) = 0;
+                void log_append( string_view ref )
                 {
                         nvmemcpy( m_pos, ref.data(), ref.size() );
@@ -84 +84 @@
                 {
                         *m_pos = '\0';
-                        log( level, string_ref( m_message, (size_t)( m_pos - m_message ) ) );
+                        log( level, string_view( m_message, (size_t)( m_pos - m_message ) ) );
                         m_pos = m_message;
                 }

trunk/nv/core/profiler.hh

@@ -44 +44 @@
                         }
                 protected:
-                        node( const string_ref& tag, node* parent );
-                        node* request_child( const string_ref& tag );
+                        node( const string_view& tag, node* parent );
+                        node* request_child( const string_view& tag );
                         void start();
                         bool stop();
@@ -66 +66 @@
                 ~profiler();
 
-                void start_profile( const string_ref& tag );
+                void start_profile( const string_view& tag );
                 void stop_profile();
         public:
@@ -82 +82 @@
         {
         public:
-                profiler_guard( string_ref tag )
+                profiler_guard( string_view tag )
                 {
                         profiler::pointer()->start_profile( tag );
@@ -96 +96 @@
         {
         public:
-                profiler_condition_guard( string_ref tag, bool condition )
+                profiler_condition_guard( string_view tag, bool condition )
                         : m_active( condition )
                 {

trunk/nv/engine/program_manager.hh

@@ -24 +24 @@
         public:
                 program_manager( context* a_context );
-                virtual string_ref get_storage_name() const { return "programs"; }
-                virtual string_ref get_resource_name() const { return "program"; }
+                virtual string_view get_storage_name() const { return "programs"; }
+                virtual string_view get_resource_name() const { return "program"; }
         protected:
                 virtual resource_id load_resource( lua::table_guard& table );

trunk/nv/engine/resource_system.hh

@@ -33 +33 @@
                 resource_manager_base() : m_lua( nullptr ) {}
                 void initialize( lua::state* state );
-                virtual string_ref get_storage_name() const = 0;
-                virtual string_ref get_resource_name() const = 0;
+                virtual string_view get_storage_name() const = 0;
+                virtual string_view get_resource_name() const = 0;
                 virtual void clear() { m_names.clear(); }
                 void load_all();

trunk/nv/fmod/fmod_audio.hh

@@ -35 +35 @@
                         virtual channel play_sound( sound a_sound, float volume = 1.0f, float pan = 0.0f );
                         virtual channel play_sound( sound a_sound, vec3 position );
-                        virtual sound load_sound( const string_ref& a_path );
+                        virtual sound load_sound( const string_view& a_path );
                         virtual void release( sound a_sound );
                         virtual void set_orientation( vec3 forward, vec3 up );

trunk/nv/formats/md3_loader.hh

@@ -41 +41 @@
         private:
                 void release_mesh_frame( mesh_data* data, sint32 frame, sint32 surface );
-                key_raw_channel* load_tags( const string_ref& tag );
+                key_raw_channel* load_tags( const string_view& tag );
                 bool m_merge_all;
                 void* m_md3;

trunk/nv/formats/md5_loader.hh

@@ -83 +83 @@
         protected:
                 void reset();
-                void build_frame_skeleton( mesh_node_data* nodes, uint32 index, const const_array_ref<md5_joint_info>& joint_info, const const_array_ref<transform>& base_frames, const const_array_ref<float>& frame_data );
+                void build_frame_skeleton( mesh_node_data* nodes, uint32 index, const array_view<md5_joint_info>& joint_info, const array_view<transform>& base_frames, const array_view<float>& frame_data );
                 bool prepare_mesh( mesh_node_data* nodes, uint32 vtx_count, mesh_data* mdata, md5_weight* weights, md5_weight_info* weight_info );
         protected:

trunk/nv/gfx/texture_font.hh

@@ -45 +45 @@
                         texture_font( texture_atlas* atlas, const char * filename, float size );
                         const texture_glyph* get_glyph( uint16 charcode ) const;
-                        bool load_glyphs( string_ref codes );
+                        bool load_glyphs( string_view codes );
                         float get_size() const { return m_size; }
                         ~texture_font();

trunk/nv/gl/gl_device.hh

@@ -41 +41 @@
 
                 gl_device();
-                virtual image_data* create_image_data( string_ref filename ); // temporary
+                virtual image_data* create_image_data( string_view filename ); // temporary
                 virtual image_data* create_image_data( const uint8* data, uint32 size ); // temporary
 
-                virtual program create_program( string_ref vs_source, string_ref fs_source );
+                virtual program create_program( string_view vs_source, string_view fs_source );
                 virtual buffer create_buffer( buffer_type type, buffer_hint hint, size_t size, const void* source = nullptr );
                 virtual texture create_texture( texture_type type, ivec2 size, image_format aformat, sampler asampler, void* data = nullptr );
@@ -63 +63 @@
         
         private:
-                bool compile( gl_program_info* p, string_ref vertex_program, string_ref fragment_program );
-                bool compile( uint32 sh_type, string_ref shader_code, unsigned& glid );
+                bool compile( gl_program_info* p, string_view vertex_program, string_view fragment_program );
+                bool compile( uint32 sh_type, string_view shader_code, unsigned& glid );
                 void update_uniforms( gl_program_info* p );
                 void load_attributes( gl_program_info* p );

trunk/nv/interface/audio.hh

@@ -33 +33 @@
                 virtual channel play_sound( sound a_sound, vec3 position ) = 0;
                 // temporary - use streams later
-                virtual sound load_sound( const string_ref& a_path ) = 0;
+                virtual sound load_sound( const string_view& a_path ) = 0;
                 virtual void release( sound a_sound ) = 0;
                 virtual void set_orientation( vec3 forward, vec3 up ) = 0;

trunk/nv/interface/context.hh

@@ -300 +300 @@
                 {
                         vertex_array  va = create_vertex_array();
-                        const_array_ref< mesh_raw_channel* > channels = data->get_raw_channels();
+                        array_view< mesh_raw_channel* > channels = data->get_raw_channels();
                         for ( uint32 ch = 0; ch < channels.size(); ++ch )
                         {

trunk/nv/interface/device.hh

@@ -157 +157 @@
                         initialize_engine_uniforms();
                 }
-                virtual program create_program( string_ref vs_source, string_ref fs_source ) = 0;
+                virtual program create_program( string_view vs_source, string_view fs_source ) = 0;
                 virtual buffer create_buffer( buffer_type type, buffer_hint hint, size_t size, const void* source = nullptr ) = 0;
                 virtual texture create_texture( texture_type type, ivec2 size, image_format aformat, sampler asampler, void* data = nullptr ) = 0;
                 // TODO: remove?
                 virtual texture create_texture( ivec2 size, image_format aformat, sampler asampler, void* data = nullptr ) { return create_texture( TEXTURE_2D, size, aformat, asampler, data ); }
-                virtual image_data* create_image_data( string_ref filename ) = 0; // temporary
+                virtual image_data* create_image_data( string_view filename ) = 0; // temporary
                 virtual image_data* create_image_data( const uint8* data, uint32 size ) = 0; // temporary
                 virtual void release( texture ) = 0;
@@ -205 +205 @@
 
                 template < typename T >
-                void set_opt_uniform_array( program p, const std::string& name, const const_array_ref<T>& value )
+                void set_opt_uniform_array( program p, const std::string& name, const array_view<T>& value )
                 {
                         set_uniform_array( p, name, (const T*)value.data(), value.size(), false );

trunk/nv/interface/mesh_data.hh

@@ -106 +106 @@
                 }
 
-                const_array_ref< mesh_raw_channel* > get_raw_channels()  const { return m_channels; }
-                const mesh_raw_channel*              get_index_channel() const { return m_index_channel; }
+                array_view< mesh_raw_channel* > get_raw_channels()  const { return m_channels; }
+                const mesh_raw_channel*         get_index_channel() const { return m_index_channel; }
                 size_t get_channel_count() const { return m_channels.size(); }
                 const mesh_raw_channel* get_channel( size_t index ) const 

trunk/nv/interface/uniform.hh

@@ -152 +152 @@
         typedef nv::vector< engine_uniform_base* >                        engine_uniform_list;
         // TODO - change to literal type map
-        typedef nv::unordered_map< string_ref, engine_uniform_factory_base* > engine_uniform_factory_map;
-        typedef nv::unordered_map< string_ref, engine_link_uniform_base* >    engine_link_uniform_factory_map;
+        typedef nv::unordered_map< string_view, engine_uniform_factory_base* > engine_uniform_factory_map;
+        typedef nv::unordered_map< string_view, engine_link_uniform_base* >    engine_link_uniform_factory_map;
 
         class engine_uniform_m_view : public engine_uniform< mat4 >

trunk/nv/lua/lua_nova.hh

@@ -14 +14 @@
         namespace lua
         {
-                void register_storage( state* a_state, string_ref name, string_ref constructor_name );
+                void register_storage( state* a_state, string_view name, string_view constructor_name );
                 void register_nova( state* a_state );
         }

trunk/nv/lua/lua_path.hh

@@ -55 +55 @@
                         void parse();
                         void push( uint32 value );
-                        void push( string_ref p );
+                        void push( string_view p );
 
                 private:

trunk/nv/lua/lua_state.hh

@@ -129 +129 @@
                         }
                         bool is_defined( const path& p ) { return is_defined( p, m_global ); }
-                        void register_native_function( lfunction f, string_ref name );
+                        void register_native_function( lfunction f, string_view name );
 
                         template < typename F, F f >
-                        void register_function( string_ref name )
+                        void register_function( string_view name )
                         {
                                 register_native_function( detail::function_wrapper< F, f >, name );
@@ -138 +138 @@
 
                         template < typename C, typename F, F f >
-                        void register_function( string_ref name )
+                        void register_function( string_view name )
                         {
                                 register_native_function( detail::object_method_wrapper< C, F, f >, name );
@@ -192 +192 @@
                         explicit state( bool load_libs = false );
                         explicit state( lua_State* state );
-                        bool do_string( string_ref code, string_ref name, int rvalues = 0 );
-                        bool do_file( string_ref filename );
+                        bool do_string( string_view code, string_view name, int rvalues = 0 );
+                        bool do_file( string_view filename );
                         int get_stack_size();
                         void log_stack();
                         lua_State* get_raw();
-                        ref register_object( void* o, string_ref lua_name );
-                        ref register_proto( string_ref id, string_ref storage );
-                        void store_metadata( ref object_index, string_ref metaname, void* pointer );
+                        ref register_object( void* o, string_view lua_name );
+                        ref register_proto( string_view id, string_view storage );
+                        void store_metadata( ref object_index, string_view metaname, void* pointer );
                         void unregister_object( ref object_index );
 
-                        void register_enum( string_ref name, int value );
-                        void register_singleton( string_ref name, void* o );
-
-                        void register_native_object_method( string_ref lua_name, string_ref name, lfunction f );
+                        void register_enum( string_view name, int value );
+                        void register_singleton( string_view name, void* o );
+
+                        void register_native_object_method( string_view lua_name, string_view name, lfunction f );
                         template < typename F, F f >
-                        void register_object_method( string_ref lua_name, string_ref name )
+                        void register_object_method( string_view lua_name, string_view name )
                         {
                                 register_native_object_method( lua_name, name, detail::object_method_wrapper< typename memfn_class_type<F>::type, F, f > );
@@ -224 +224 @@
                         }
                         template < typename H >
-                        ref register_handle_component( const H& handle, string_ref id )
+                        ref register_handle_component( const H& handle, string_view id )
                         {
                                 nv::lua::push_handle( m_state, handle );
@@ -230 +230 @@
                         }
                         template < typename H >
-                        ref register_handle_component( const H& handle, string_ref id, const path& proto )
+                        ref register_handle_component( const H& handle, string_view id, const path& proto )
                         {
                                 if ( !proto.resolve( m_state, true ) )
@@ -240 +240 @@
                         }
                         template < typename H >
-                        void unregister_handle_component( const H& handle, string_ref id )
+                        void unregister_handle_component( const H& handle, string_view id )
                         {
                                 nv::lua::push_handle( m_state, handle );
@@ -277 +277 @@
 
                 private:
-                        ref register_handle_component_impl( string_ref id, bool empty );
-                        void unregister_handle_component_impl( string_ref id );
-
-                        int load_string( string_ref code, string_ref name );
-                        int load_file( string_ref filename );
-                        int do_current( string_ref name, int rvalues = 0 );
+                        ref register_handle_component_impl( string_view id, bool empty );
+                        void unregister_handle_component_impl( string_view id );
+
+                        int load_string( string_view code, string_view name );
+                        int load_file( string_view filename );
+                        int do_current( string_view name, int rvalues = 0 );
                         void deep_pointer_copy( int index, void* obj );
                 };
@@ -293 +293 @@
                         virtual ~table_guard();
                         size_t get_size();
-                        bool has_field( string_ref element );
-                        std::string get_std_string( string_ref element, string_ref defval = string_ref() );
-                        const_string get_string( string_ref element, string_ref defval = string_ref() );
-                        char get_char( string_ref element, char defval = ' ' );
-                        int get_integer( string_ref element, int defval = 0 );
-                        unsigned get_unsigned( string_ref element, unsigned defval = 0 );
-                        double get_double( string_ref element, double defval = 0.0 );
-                        float get_float( string_ref element, float defval = 0.0 );
-                        bool get_boolean( string_ref element, bool defval = false );
-                        bool is_table( string_ref element );
-                        bool is_number( string_ref element );
-                        bool is_boolean( string_ref element );
-                        bool is_string( string_ref element );
+                        bool has_field( string_view element );
+                        std::string get_std_string( string_view element, string_view defval = string_view() );
+                        const_string get_string( string_view element, string_view defval = string_view() );
+                        char get_char( string_view element, char defval = ' ' );
+                        int get_integer( string_view element, int defval = 0 );
+                        unsigned get_unsigned( string_view element, unsigned defval = 0 );
+                        double get_double( string_view element, double defval = 0.0 );
+                        float get_float( string_view element, float defval = 0.0 );
+                        bool get_boolean( string_view element, bool defval = false );
+                        bool is_table( string_view element );
+                        bool is_number( string_view element );
+                        bool is_boolean( string_view element );
+                        bool is_string( string_view element );
                 private:
                         int m_level;

trunk/nv/lua/lua_values.hh

@@ -74 +74 @@
                         void push_bool       ( lua_State *L, bool v );
                         void push_string     ( lua_State *L, const std::string& s );
-                        void push_string_ref ( lua_State *L, string_ref s );
+                        void push_string_view( lua_State *L, string_view s );
                         void push_cstring    ( lua_State *L, const char* s );
                         void push_pointer    ( lua_State *L, void* p );
@@ -85 +85 @@
                         std::string to_string     ( lua_State *L, int index );
                         const char* to_cstring    ( lua_State *L, int index );
-                        string_ref  to_string_ref ( lua_State *L, int index );
+                        string_view to_string_view( lua_State *L, int index );
                         void*       to_pointer    ( lua_State *L, int index );
                         void*       to_ref_object ( lua_State *L, int index );
@@ -95 +95 @@
                         std::string to_string     ( lua_State *L, int index, const std::string& def );
                         const char* to_cstring    ( lua_State *L, int index, const char* def );
-                        string_ref  to_string_ref ( lua_State *L, int index, string_ref def );
+                        string_view to_string_view( lua_State *L, int index, string_view def );
                         void*       to_pointer    ( lua_State *L, int index, void* def );
                         void*       to_ref_object ( lua_State *L, int index, void* def );
@@ -159 +159 @@
 
                 template <>
-                struct pass_traits < string_ref >
-                {
-                        static void push( lua_State *L, string_ref s ) { detail::push_string_ref( L, s ); }
-                        static string_ref to( lua_State *L, int index ) { return detail::to_string_ref( L, index ); }
-                        static string_ref to( lua_State *L, int index, string_ref def ) { return detail::to_string_ref( L, index, def ); }
+                struct pass_traits < string_view >
+                {
+                        static void push( lua_State *L, string_view s ) { detail::push_string_view( L, s ); }
+                        static string_view to( lua_State *L, int index ) { return detail::to_string_view( L, index ); }
+                        static string_view to( lua_State *L, int index, string_view def ) { return detail::to_string_view( L, index, def ); }
                 };
 

trunk/nv/sdl/sdl_audio.hh

@@ -33 +33 @@
                         virtual channel play_sound( sound a_sound, float volume = 1.0f, float pan = 0.0f );
                         virtual channel play_sound( sound a_sound, vec3 position );
-                        virtual sound load_sound( const string_ref& a_path );
+                        virtual sound load_sound( const string_view& a_path );
                         virtual void release( sound a_sound );
                         virtual void set_orientation( vec3 forward, vec3 up );

trunk/nv/stl/container/contiguous_storage_policy.hh

@@ -45 +45 @@
 
                 operator array_ref< value_type >() { return array_ref< value_type >( Storage::data(), size() ); }
-                operator const_array_ref< value_type >() const { return const_array_ref< value_type >( Storage::data(), size() ); }
+                operator array_view< value_type >() const { return array_view< value_type >( Storage::data(), size() ); }
 
                 // allow move
@@ -72 +72 @@
 
                 operator array_ref< value_type >() { return array_ref< value_type >( Storage::data(), size() ); }
-                operator const_array_ref< value_type >() const { return const_array_ref< value_type >( Storage::data(), size() ); }
+                operator array_view< value_type >() const { return array_view< value_type >( Storage::data(), size() ); }
         protected:
                 constexpr resizable_storage() : m_size( 0 ) {}
@@ -141 +141 @@
 
                 operator array_ref< value_type >() { return array_ref< value_type >( Storage::data(), size() ); }
-                operator const_array_ref< value_type >() const { return const_array_ref< value_type >( Storage::data(), size() ); }
+                operator array_view< value_type >() const { return array_view< value_type >( Storage::data(), size() ); }
         protected:
                 constexpr growable_storage() : m_size( 0 ), m_capacity( 0 ) {}

trunk/nv/stl/memory.hh

@@ -34 +34 @@
 
         template< typename T >
-        class storage_view
+        class storage_ref
         {
         public:
@@ -43 +43 @@
                 static constexpr bool is_const    = false;
 
-                constexpr storage_view() 
+                constexpr storage_ref() 
                         : m_data( nullptr ), m_size( 0 ) {}
-                constexpr storage_view( value_type* a_data, size_type a_size )
+                constexpr storage_ref( value_type* a_data, size_type a_size )
                         : m_data( a_data ), m_size( a_size ) {}
 
@@ -67 +67 @@
 
         template< typename T >
-        class const_storage_view
+        class storage_view
         {
         public:
@@ -76 +76 @@
                 static constexpr bool is_const    = true;
 
-                constexpr const_storage_view()
+                constexpr storage_view()
                         : m_data( nullptr ), m_size( 0 ) {}
-                constexpr const_storage_view( const value_type* a_data, size_type a_size )
+                constexpr storage_view( const value_type* a_data, size_type a_size )
                         : m_data( a_data ), m_size( a_size ) {}
-                constexpr const_storage_view( const storage_view<T>& view )
+                constexpr storage_view( const storage_ref<T>& view )
                         : m_data( view.data() ), m_size( view.size() ) {}
 
@@ -474 +474 @@
 
         template < typename T > 
-        using const_array_ref = detail::add_random_access< detail::add_iterators < const_storage_view< T > > >;
-        template < typename T >
-        using array_ref       = detail::add_random_access< detail::add_iterators < storage_view< T > > >;
-        using const_mem_ref = const_array_ref< char >;
+        using array_view    = detail::add_random_access< detail::add_iterators < storage_view< T > > >;
+        template < typename T >
+        using array_ref     = detail::add_random_access< detail::add_iterators < storage_ref< T > > >;
+        using mem_view      = array_view< char >;
         using mem_ref       = array_ref< char >;
 

trunk/nv/stl/string.hh

@@ -77 +77 @@
         };
         
-        class string_ref;
+        class string_view;
 
         // string base class - will become a base for a string class later
-        class string_base : public detail::add_iterators< const_storage_view< char > >
-        {
-                typedef detail::add_iterators< const_storage_view< char > > inherited;
+        class string_base : public detail::add_iterators< storage_view< char > >
+        {
+                typedef detail::add_iterators< storage_view< char > > inherited;
         public:
                 typedef char           value_type;
@@ -197 +197 @@
 
                 // string operations
-                string_ref substr( size_type p, size_type n = npos ) const;
+                string_view substr( size_type p, size_type n = npos ) const;
 
                 inline size_t hash() const
@@ -245 +245 @@
 
 
-        class string_ref : public string_base
+        class string_view : public string_base
         {
         public:
-                inline string_ref() {}
-                inline string_ref( const string_ref& rhs )
+                inline string_view() {}
+                inline string_view( const string_view& rhs )
                         : string_base( rhs.data(), rhs.size() )
                 {
                 }
-                inline string_ref( const string_base& rhs )
+                inline string_view( const string_base& rhs )
                         : string_base( rhs.data(), rhs.size() )
                 {
                 }
 
-                inline string_ref( const std::string& str )
+                inline string_view( const std::string& str )
                         : string_base( str.data(), str.size() )
                 {
                 }
 
-                inline string_ref( const char* str, size_type len )
+                inline string_view( const char* str, size_type len )
                         : string_base( str, len )
                 {
@@ -270 +270 @@
                 // Literal constructors
                 template< size_t N >
-                inline string_ref( char( &s )[N] ) : string_base( s, N - 1 ) {}
-                template< size_t N >
-                inline string_ref( const char( &s )[N] ) : string_base( s, N - 1 ) {}
+                inline string_view( char( &s )[N] ) : string_base( s, N - 1 ) {}
+                template< size_t N >
+                inline string_view( const char( &s )[N] ) : string_base( s, N - 1 ) {}
 
                 // Non-literal constructors
                 template< typename U >
-                inline string_ref( U str, typename enable_if<is_same<U, const char*>::value>::type* = nullptr ) : string_base( str, nvstrlen( str ) ) {}
+                inline string_view( U str, typename enable_if<is_same<U, const char*>::value>::type* = nullptr ) : string_base( str, nvstrlen( str ) ) {}
 
                 // Non-literal constructors
                 template< typename U >
-                inline string_ref( U str, typename enable_if<is_same<U, char*>::value>::type* = nullptr ) : string_base( str, nvstrlen( str ) ) {}
-
-                inline string_ref& operator=( const string_ref &rhs )
+                inline string_view( U str, typename enable_if<is_same<U, char*>::value>::type* = nullptr ) : string_base( str, nvstrlen( str ) ) {}
+
+                inline string_view& operator=( const string_view &rhs )
                 {
                         assign( rhs.data(), rhs.size() );
@@ -309 +309 @@
 
         template< typename H >
-        struct hash< string_ref, H > : hash< string_base, H >{};
+        struct hash< string_view, H > : hash< string_base, H >{};
 
         // const string is movable but not copyable
@@ -364 +364 @@
         };
 
-        inline string_ref string_base::substr( size_type p, size_type n ) const
-        {
-                if ( p > size() ) return string_ref(); // NV_THROW( out_of_range( "substr" ) );
+        inline string_view string_base::substr( size_type p, size_type n ) const
+        {
+                if ( p > size() ) return string_view(); // NV_THROW( out_of_range( "substr" ) );
                 if ( n == p || p + n > size() ) n = size() - p;
-                return string_ref( data() + p, n );
+                return string_view( data() + p, n );
         }
 
@@ -374 +374 @@
 inline bool operator OPERATOR ( const string_base& lhs, const std::string& rhs )\
 {\
-        return lhs OPERATOR string_ref( rhs );\
+        return lhs OPERATOR string_view( rhs );\
 }\
 inline bool operator OPERATOR ( const std::string& lhs, const string_base& rhs )\
 {\
-        return string_ref( lhs ) OPERATOR rhs;\
+        return string_view( lhs ) OPERATOR rhs;\
 }\
 inline bool operator OPERATOR ( const string_base& lhs, const char* rhs )\
 {\
-        return lhs OPERATOR string_ref( rhs );\
+        return lhs OPERATOR string_view( rhs );\
 }\
 inline bool operator OPERATOR ( const char* lhs, const string_base& rhs )\
 {\
-        return string_ref( lhs ) OPERATOR rhs;\
+        return string_view( lhs ) OPERATOR rhs;\
 }\
 
@@ -432 +432 @@
 size_t f64_to_buffer( f64 n, char* str );
 
-inline string_ref trimmed( const string_ref& str )
+inline string_view trimmed( const string_view& str )
 {
         size_t endpos = str.find_last_not_of( " \r\n\t" );
         size_t startpos = str.find_first_not_of( " \r\n\t" );
 
-        if ( string_ref::npos != endpos || string_ref::npos != startpos )
-        {
-                if ( string_ref::npos == startpos ) startpos = 0;
-                if ( string_ref::npos != endpos )   endpos = endpos + 1 - startpos;
+        if ( string_view::npos != endpos || string_view::npos != startpos )
+        {
+                if ( string_view::npos == startpos ) startpos = 0;
+                if ( string_view::npos != endpos )   endpos = endpos + 1 - startpos;
                 return str.substr( startpos, endpos );
         }
@@ -446 +446 @@
 }
 
-inline string_ref rtrimmed( const string_ref& str )
+inline string_view rtrimmed( const string_view& str )
 {
         size_t endpos = str.find_last_not_of( " \r\n\t" );
-        if ( string_ref::npos != endpos )
+        if ( string_view::npos != endpos )
         {
                 return str.substr( 0, endpos + 1 );
@@ -456 +456 @@
 }
 
-inline string_ref ltrimmed( const string_ref& str )
+inline string_view ltrimmed( const string_view& str )
 {
         size_t startpos = str.find_first_not_of( " \r\n\t" );
-        if ( string_ref::npos != startpos )
+        if ( string_view::npos != startpos )
         {
                 return str.substr( startpos );
@@ -467 +467 @@
 
 
-inline string_ref extract_extension( string_ref filename )
+inline string_view extract_extension( string_view filename )
 {
         size_t lastdot = filename.find_last_of( '.' );
-        if ( string_ref::npos != lastdot )
+        if ( string_view::npos != lastdot )
                 return filename.substr( lastdot + 1 );
         return filename;

trunk/src/core/library.cc

@@ -41 +41 @@
 }
 
-void library::open( string_ref name )
+void library::open( string_view name )
 {
         m_name.assign( name.data(), name.size() );
@@ -51 +51 @@
 }
 
-bool nv::library::try_open( string_ref name )
+bool nv::library::try_open( string_view name )
 {
         m_name.assign( name.data(), name.size() );
@@ -62 +62 @@
 }
 
-string_ref library::get_name() const
+string_view library::get_name() const
 {
-    return string_ref( m_name );
+    return string_view( m_name );
 }
 
@@ -76 +76 @@
 
         std::string name = m_name;
-        string_ref ext( NV_LIB_EXT );
+        string_view ext( NV_LIB_EXT );
 
         if ( name.length() < ext.length() || name.substr( name.length() - ext.length(), ext.length() ) != ext )
@@ -94 +94 @@
 }
 
-void* library::get( string_ref symbol )
+void* library::get( string_view symbol )
 {
         void* result = (void*) NV_LIB_GET( (NV_LIB_HANDLE) m_handle, symbol.data() );
@@ -104 +104 @@
 }
 
-void* nv::library::try_get( string_ref symbol )
+void* nv::library::try_get( string_view symbol )
 {
         return (void*) NV_LIB_GET( (NV_LIB_HANDLE) m_handle, symbol.data() );

trunk/src/core/logger.cc

@@ -85 +85 @@
 
 // log function
-void logger::log( log_level level, const string_ref& message )
+void logger::log( log_level level, const string_view& message )
 {
         for ( auto& sink_info : m_log_sinks )
@@ -141 +141 @@
 
 // console logging
-void log_console_sink::log( log_level level, const string_ref& message )
+void log_console_sink::log( log_level level, const string_view& message )
 {
         char stamp[16];
@@ -177 +177 @@
 
 // handle logging
-void log_handle_sink::log( log_level level, const string_ref& message )
+void log_handle_sink::log( log_level level, const string_view& message )
 {
         char stamp[16];
@@ -204 +204 @@
 }
 
-nv::log_file_sink::log_file_sink( const string_ref& file_name, bool flush_always /*= true */ )
+nv::log_file_sink::log_file_sink( const string_view& file_name, bool flush_always /*= true */ )
         : log_handle_sink( nullptr, flush_always )
 {
@@ -257 +257 @@
 }
 
-string_ref nv::log_sink::level_name( log_level level ) const
+string_view nv::log_sink::level_name( log_level level ) const
 {
         return NV_LOG_LEVEL_NAME( level );
 }
 
-string_ref nv::log_sink::padded_level_name( log_level level ) const
-{
-        return string_ref( NV_LOG_LEVEL_NAME_PAD( level ), 8 );
-}
-
+string_view nv::log_sink::padded_level_name( log_level level ) const
+{
+        return string_view( NV_LOG_LEVEL_NAME_PAD( level ), 8 );
+}
+

trunk/src/core/profiler.cc

@@ -30 +30 @@
 }
 
-void profiler::start_profile( const string_ref& tag )
+void profiler::start_profile( const string_view& tag )
 {
         if ( tag != m_current->m_tag )
@@ -47 +47 @@
 }
 
-profiler::node::node( const string_ref& tag, node* parent )
+profiler::node::node( const string_view& tag, node* parent )
         : m_tag( tag.to_string() )
         , m_parent( parent )
@@ -58 +58 @@
 }
 
-profiler::node* profiler::node::request_child( const string_ref& tag )
+profiler::node* profiler::node::request_child( const string_view& tag )
 {
         std::string stag( tag.to_string() );
@@ -110 +110 @@
         char buffer[128];
         snprintf( buffer, 128, "%-23s %6s %6s %9s %6s", "TAG", "%PARNT", "CALLS", "TOTAL(ms)", "AVG(ms)" );
-        NV_LOG_INFO( string_ref( buffer, nvstrlen( buffer ) ) );
+        NV_LOG_INFO( string_view( buffer, nvstrlen( buffer ) ) );
         log_node_children( 0, m_root );
         NV_LOG_INFO( "-- PROFILER REPORT END ---------------------------------" );
@@ -131 +131 @@
                         snprintf( buffer + indent, 128 - indent, "%*.*s %6.2f %6d %9.2f %6.2f", indent - 23, 23 - indent,
                                 c->m_tag.c_str(), pparent, calls, total_ms, avg_ms );
-                        NV_LOG_INFO( string_ref( buffer, nvstrlen( buffer ) ) );
+                        NV_LOG_INFO( string_view( buffer, nvstrlen( buffer ) ) );
                         if ( c->m_children.size() > 0 )
                         {

trunk/src/engine/program_manager.cc

@@ -37 +37 @@
         }
 
-        nv::program program = m_context->get_device()->create_program( string_ref( vsource ), string_ref( fsource ) );
+        nv::program program = m_context->get_device()->create_program( string_view( vsource ), string_view( fsource ) );
         return add( program );
 }

trunk/src/engine/resource_system.cc

@@ -12 +12 @@
 {
         m_lua = a_lua_state;
-        lua::register_storage( m_lua, get_storage_name(), string_ref( "register_" + get_resource_name().to_string() ) );
+        lua::register_storage( m_lua, get_storage_name(), string_view( "register_" + get_resource_name().to_string() ) );
 }
 

trunk/src/fmod/fmod_audio.cc

@@ -88 +88 @@
 
 
-nv::sound fmod::audio::load_sound( const string_ref& a_path )
+nv::sound fmod::audio::load_sound( const string_view& a_path )
 {
         FMOD_SYSTEM* system = (FMOD_SYSTEM*)m_system;

trunk/src/formats/assimp_loader.cc

@@ -237 +237 @@
                         aiMesh* mesh = scene->mMeshes[mc];
 
-                        NV_LOG_NOTICE( "Mesh #", mc, "   - ", string_ref( (char*)mesh->mName.data ) );
+                        NV_LOG_NOTICE( "Mesh #", mc, "   - ", string_view( (char*)mesh->mName.data ) );
                         NV_LOG_NOTICE( "  bones   - ", mesh->mNumBones );
                         NV_LOG_NOTICE( "  uvs     - ", mesh->mNumUVComponents[0] );

trunk/src/formats/md3_loader.cc

@@ -284 +284 @@
 }
 
-nv::key_raw_channel* nv::md3_loader::load_tags( const string_ref& tag )
+nv::key_raw_channel* nv::md3_loader::load_tags( const string_view& tag )
 {
         md3_t* md3 = (md3_t*)m_md3;
@@ -294 +294 @@
                 {
                         const md3_tag_t& rtag = md3->tags[i + md3->header.num_tags * f];
-                        string_ref rname((char*)(rtag.name));
+                        string_view rname((char*)(rtag.name));
                         if (rname == tag)
                         {
@@ -425 +425 @@
         {
                 const md3_tag_t& rtag = md3->tags[i];
-                string_ref name( (char*)(rtag.name) );
+                string_view name( (char*)(rtag.name) );
 
                 nodes[i].transform = mat4();

trunk/src/formats/md5_loader.cc

@@ -457 +457 @@
 }
 
-void md5_loader::build_frame_skeleton( mesh_node_data* nodes, uint32 index, const const_array_ref<md5_joint_info>& joint_infos, const const_array_ref<transform>& base_frames, const const_array_ref<float>& frame_data )
+void md5_loader::build_frame_skeleton( mesh_node_data* nodes, uint32 index, const array_view<md5_joint_info>& joint_infos, const array_view<transform>& base_frames, const array_view<float>& frame_data )
 {
         assert( m_type == ANIMATION );

trunk/src/formats/nmd_loader.cc

@@ -162 +162 @@
 static void nmd_dump_mesh( const mesh_data* mesh, stream& stream_out )
 {
-        const_array_ref< mesh_raw_channel* > data  = mesh->get_raw_channels();
+        array_view< mesh_raw_channel* > data  = mesh->get_raw_channels();
 
         uint32 size = sizeof( nmd_element_header );

trunk/src/gfx/texture_font.cc

@@ -92 +92 @@
 }
 
-bool texture_font::load_glyphs( string_ref codes )
+bool texture_font::load_glyphs( string_view codes )
 {
         FT_Face face = (FT_Face)(m_rface);

trunk/src/gl/gl_device.cc

@@ -24 +24 @@
 }
 
-program gl_device::create_program( string_ref vs_source, string_ref fs_source )
+program gl_device::create_program( string_view vs_source, string_view fs_source )
 {
         program result = m_programs.create();
@@ -41 +41 @@
 // this is a temporary function that will be removed once we find a way to 
 // pass binary file data around
-image_data* gl_device::create_image_data( string_ref filename )
+image_data* gl_device::create_image_data( string_view filename )
 {
         load_sdl_image_library();
@@ -264 +264 @@
 }
 
-bool nv::gl_device::compile( gl_program_info* p, string_ref vertex_program, string_ref fragment_program )
+bool nv::gl_device::compile( gl_program_info* p, string_view vertex_program, string_view fragment_program )
 {
         if (!compile( GL_VERTEX_SHADER,   vertex_program, p->glidv ))   { return false; }
@@ -407 +407 @@
 }
 
-bool nv::gl_device::compile( uint32 sh_type, string_ref shader_code, unsigned& glid )
+bool nv::gl_device::compile( uint32 sh_type, string_view shader_code, unsigned& glid )
 {
         glid = glCreateShader( sh_type );

trunk/src/lua/lua_nova.cc

@@ -810 +810 @@
 }
 
-void nv::lua::register_storage( state* a_state, string_ref name, string_ref constructor_name )
+void nv::lua::register_storage( state* a_state, string_view name, string_view constructor_name )
 {
         // TODO: error checking

trunk/src/lua/lua_path.cc

@@ -14 +14 @@
 {
         if ( m_elements[0].length == 0 || m_elements[0].str == nullptr ) return;
-        string_ref spath( m_elements[0].str, m_elements[0].length );
+        string_view spath( m_elements[0].str, m_elements[0].length );
         m_count = 0;
         size_t point = spath.find( '.' );
 
-        while ( point != string_ref::npos )
+        while ( point != string_view::npos )
         {
                 m_elements[m_count].str    = spath.data();
@@ -39 +39 @@
 }
 
-void nv::lua::path::push( string_ref p )
+void nv::lua::path::push( string_view p )
 {
         m_elements[ m_count ].str    = p.data();

trunk/src/lua/lua_state.cc

@@ -80 +80 @@
 }
 
-void lua::state_wrapper::register_native_function( lfunction f, string_ref name )
+void lua::state_wrapper::register_native_function( lfunction f, string_view name )
 {
         if ( m_global ) push_global_table();
@@ -171 +171 @@
 }
 
-bool lua::table_guard::has_field( string_ref element )
+bool lua::table_guard::has_field( string_view element )
 {
         lua_getfield( m_state, -1, element.data() );
@@ -179 +179 @@
 }
 
-std::string lua::table_guard::get_std_string( string_ref element, string_ref defval /*= string_ref() */ )
+std::string lua::table_guard::get_std_string( string_view element, string_view defval /*= string_view() */ )
 {
         lua_getfield( m_state, -1, element.data() );
@@ -198 +198 @@
 }
 
-const_string lua::table_guard::get_string( string_ref element, string_ref defval /*= string_ref() */ )
+const_string lua::table_guard::get_string( string_view element, string_view defval /*= string_view() */ )
 {
         lua_getfield( m_state, -1, element.data() );
@@ -217 +217 @@
 }
 
-char lua::table_guard::get_char( string_ref element, char defval /*= "" */ )
+char lua::table_guard::get_char( string_view element, char defval /*= "" */ )
 {
         lua_getfield( m_state, -1, element.data() );
@@ -225 +225 @@
 }
 
-int lua::table_guard::get_integer( string_ref element, int defval /*= "" */ )
+int lua::table_guard::get_integer( string_view element, int defval /*= "" */ )
 {
         lua_getfield( m_state, -1, element.data() );
@@ -233 +233 @@
 }
 
-unsigned lua::table_guard::get_unsigned( string_ref element, unsigned defval /*= "" */ )
+unsigned lua::table_guard::get_unsigned( string_view element, unsigned defval /*= "" */ )
 {
         lua_getfield( m_state, -1, element.data() );
@@ -241 +241 @@
 }
 
-double lua::table_guard::get_double( string_ref element, double defval /*= "" */ )
+double lua::table_guard::get_double( string_view element, double defval /*= "" */ )
 {
         lua_getfield( m_state, -1, element.data() );
@@ -250 +250 @@
 
 
-float nv::lua::table_guard::get_float( string_ref element, float defval /*= 0.0 */ )
+float nv::lua::table_guard::get_float( string_view element, float defval /*= 0.0 */ )
 {
         lua_getfield( m_state, -1, element.data() );
@@ -258 +258 @@
 }
 
-bool lua::table_guard::get_boolean( string_ref element, bool defval /*= "" */ )
+bool lua::table_guard::get_boolean( string_view element, bool defval /*= "" */ )
 {
         lua_getfield( m_state, -1, element.data() );
@@ -266 +266 @@
 }
 
-bool nv::lua::table_guard::is_table( string_ref element )
+bool nv::lua::table_guard::is_table( string_view element )
 {
         lua_getfield( m_state, -1, element.data() );
@@ -274 +274 @@
 }
 
-bool nv::lua::table_guard::is_number( string_ref element )
+bool nv::lua::table_guard::is_number( string_view element )
 {
         lua_getfield( m_state, -1, element.data() );
@@ -282 +282 @@
 }
 
-bool nv::lua::table_guard::is_boolean( string_ref element )
+bool nv::lua::table_guard::is_boolean( string_view element )
 {
         lua_getfield( m_state, -1, element.data() );
@@ -290 +290 @@
 }
 
-bool nv::lua::table_guard::is_string( string_ref element )
+bool nv::lua::table_guard::is_string( string_view element )
 {
         lua_getfield( m_state, -1, element.data() );
@@ -350 +350 @@
 }
 
-int lua::state::load_string( string_ref code, string_ref name )
+int lua::state::load_string( string_view code, string_view name )
 {
         NV_LOG_TRACE( "Loading Lua string '", name, "'");
@@ -356 +356 @@
 }
 
-int lua::state::load_file( string_ref filename )
+int lua::state::load_file( string_view filename )
 {
         NV_LOG_NOTICE( "Loading Lua file '", filename, "'");
@@ -362 +362 @@
 }
 
-bool lua::state::do_string( string_ref code, string_ref name, int rvalues )
+bool lua::state::do_string( string_view code, string_view name, int rvalues )
 {
         lua::stack_guard( this );
@@ -374 +374 @@
 }
 
-bool lua::state::do_file( string_ref filename )
+bool lua::state::do_file( string_view filename )
 {
         lua::stack_guard( this );
@@ -386 +386 @@
 }
 
-int lua::state::do_current( string_ref name, int rvalues )
+int lua::state::do_current( string_view name, int rvalues )
 {
         int result = lua_pcall(m_state, 0, rvalues, 0);
@@ -417 +417 @@
 }
 
-lua::ref lua::state::register_object( void* o, string_ref lua_name )
+lua::ref lua::state::register_object( void* o, string_view lua_name )
 {
         if ( o == nullptr ) return lua::ref( lua::ref::none );
@@ -430 +430 @@
 }
 
-lua::ref lua::state::register_proto( string_ref id, string_ref storage )
+lua::ref lua::state::register_proto( string_view id, string_view storage )
 {
         stack_guard guard( this );
@@ -446 +446 @@
 }
 
-void lua::state::register_native_object_method( string_ref lua_name, string_ref name, lfunction f )
+void lua::state::register_native_object_method( string_view lua_name, string_view name, lfunction f )
 {
         stack_guard guard( this );
@@ -508 +508 @@
 }
 
-void nv::lua::state::store_metadata( ref object_index, string_ref metaname, void* pointer )
+void nv::lua::state::store_metadata( ref object_index, string_view metaname, void* pointer )
 {
         if ( !object_index.is_valid() ) return;
@@ -518 +518 @@
 }
 
-void nv::lua::state::register_enum( string_ref name, int value )
+void nv::lua::state::register_enum( string_view name, int value )
 {
         lua_pushinteger( m_state, value );
@@ -524 +524 @@
 }
 
-nv::lua::ref nv::lua::state::register_handle_component_impl( string_ref id, bool empty )
+nv::lua::ref nv::lua::state::register_handle_component_impl( string_view id, bool empty )
 {
         int args = empty ? 1 : 2;
@@ -547 +547 @@
 }
 
-void nv::lua::state::unregister_handle_component_impl( string_ref id )
+void nv::lua::state::unregister_handle_component_impl( string_view id )
 {
         NV_LUA_STACK_ASSERT( m_state, -1 );
@@ -562 +562 @@
 }
 
-void nv::lua::state::register_singleton( string_ref name, void* o )
+void nv::lua::state::register_singleton( string_view name, void* o )
 {
         if ( o == nullptr ) return;

trunk/src/lua/lua_values.cc

@@ -75 +75 @@
 }
 
-void nv::lua::detail::push_string_ref( lua_State *L, string_ref s )
+void nv::lua::detail::push_string_view( lua_State *L, string_view s )
 {
         lua_pushlstring( L, s.data(), s.size() );
@@ -123 +123 @@
 }
 
-nv::string_ref nv::lua::detail::to_string_ref( lua_State *L, int index )
+nv::string_view nv::lua::detail::to_string_view( lua_State *L, int index )
 {
         size_t length = 0;
         const char* result = lua_tolstring( L, index, &length );
-        return string_ref( result, length );
+        return string_view( result, length );
 }
 

trunk/src/sdl/sdl_audio.cc

@@ -85 +85 @@
 }
 
-nv::sound nv::sdl::audio::load_sound( const string_ref& a_path )
+nv::sound nv::sdl::audio::load_sound( const string_view& a_path )
 {
         // TODO: this is a really weird error - if we remove this check, all hell gets loose