Index: trunk/nv/gui/gui_environment.hh =================================================================== --- trunk/nv/gui/gui_environment.hh (revision 432) +++ trunk/nv/gui/gui_environment.hh (revision 433) @@ -31,5 +31,5 @@ environment( renderer* r ); // temporary - void load_style( const std::string& filename ); + void load_style( const string_view& filename ); handle create_element( const rectangle& r ); handle create_element( handle parent, const rectangle& r ); Index: trunk/nv/gui/gui_gfx_renderer.hh =================================================================== --- trunk/nv/gui/gui_gfx_renderer.hh (revision 432) +++ trunk/nv/gui/gui_gfx_renderer.hh (revision 433) @@ -56,8 +56,8 @@ const image_info* get_image( size_t name ) const; - size_t load_font( const std::string& filename, size_t size ); - size_t load_image( const std::string& filename ); + size_t load_font( const string_view& filename, size_t size ); + size_t load_image( const string_view& filename ); - typedef unordered_map< std::string, size_t > names; + typedef hash_store< shash64, size_t > names; typedef vector< texture_font* > font_vector; typedef vector< image_info > image_vector; Index: trunk/nv/gui/gui_renderer.hh =================================================================== --- trunk/nv/gui/gui_renderer.hh (revision 432) +++ trunk/nv/gui/gui_renderer.hh (revision 433) @@ -28,5 +28,5 @@ public: renderer() {} - virtual void load_style( const std::string& filename ); + virtual void load_style( const string_view& filename ); virtual void redraw( element* e, uint32 ) = 0; virtual void draw( element* e ) = 0; Index: trunk/nv/gui/gui_style.hh =================================================================== --- trunk/nv/gui/gui_style.hh (revision 432) +++ trunk/nv/gui/gui_style.hh (revision 433) @@ -27,5 +27,5 @@ public: style(); - void load_style( const std::string& filename ); + void load_style( const string_view& filename ); bool get( element* e, const char* centry, const char* cselector, std::string& s ); bool get( element* e, const char* centry, const char* cselector, vec4& vec ); Index: trunk/nv/stl/hash_store.hh =================================================================== --- trunk/nv/stl/hash_store.hh (revision 432) +++ trunk/nv/stl/hash_store.hh (revision 433) Index: trunk/nv/stl/memory.hh =================================================================== --- trunk/nv/stl/memory.hh (revision 432) +++ trunk/nv/stl/memory.hh (revision 433) @@ -161,5 +161,4 @@ size_type m_size; }; - template < typename T > Index: trunk/nv/stl/string.hh =================================================================== --- trunk/nv/stl/string.hh (revision 432) +++ trunk/nv/stl/string.hh (revision 433) @@ -23,5 +23,9 @@ #define NV_STL_STRING_HH -#include +#include +#include +#include +#include +#include #include #include @@ -33,13 +37,5 @@ namespace nv { - - template < typename Storage > class string_base; - class string_view; - - // short_string< size_t > - // string32 - // string64 - // string - + template< typename H > struct hash< std::string, H > : detail::hash_base< std::string, H > @@ -70,19 +66,7 @@ }; - template < typename T, typename Enable = void > - struct is_string_base_impl : false_type {}; - template < typename T > - struct is_string_base_impl < T, - typename enable_if< - is_base_of< string_base< typename T::storage_type >, T >::value, - void >::type > : true_type{}; + } - // Stronger version - // template < typename T > - // struct is_string_base : is_template_base_of< T, string_base > {}; - - template < typename T > - struct is_string_base : detail::is_string_base_impl< T > {}; template < typename T > @@ -91,323 +75,4 @@ }; - - // string base class - will become a base for a string class later - template < typename Storage > - class string_base : public Storage - { - typedef Storage base_type; - typedef string_base< base_type > this_type; - public: - typedef Storage storage_type; - typedef typename base_type::value_type value_type; - typedef typename base_type::pointer pointer; - typedef typename base_type::const_pointer const_pointer; - typedef typename base_type::reference reference; - typedef typename base_type::const_reference const_reference; - typedef typename base_type::iterator iterator; - typedef typename base_type::const_iterator const_iterator; - typedef typename base_type::reverse_iterator reverse_iterator; - typedef typename base_type::const_reverse_iterator const_reverse_iterator; - typedef typename base_type::size_type size_type; - typedef typename base_type::difference_type difference_type; - - static constexpr size_type npos = size_type( -1 ); - - // conversion to std::string - inline std::string to_string() const - { - return std::string( this->data(), this->size() ); - } - - inline size_type length() const { return this->size(); } - - // string operations - int compare( const string_view& rhs ) const; - bool starts_with( value_type c ) const; - bool starts_with( const string_view& s ) const; - bool ends_with( value_type c ) const; - bool ends_with( const string_view& s ) const; - auto find( value_type c, size_type pos = 0 ) const->size_type; - auto find( const string_view& s, size_type pos = 0 ) const->size_type; - auto rfind( value_type c, size_type pos = 0 ) const->size_type; - auto rfind( const string_view& s, size_type pos = 0 ) const->size_type; - auto find_first_of( value_type c ) const->size_type; - auto find_first_of( const string_view& s ) const->size_type; - auto find_last_of( value_type c ) const->size_type; - auto find_last_of( const string_view& s ) const->size_type; - auto find_first_not_of( value_type c ) const->size_type; - auto find_first_not_of( const string_view& s ) const->size_type; - auto find_last_not_of( value_type c ) const->size_type; - auto find_last_not_of( const string_view& s ) const->size_type; - - // string operations - string_view substr( size_type p, size_type n = npos ) const; - - template < typename H = size_type > - inline H get_hash() const - { - return hash_string< H >( this->data(), this->size() ); - } - - protected: - using base_type::base_type; - constexpr string_base() : base_type() {} - constexpr string_base( pointer str, size_type len ) : base_type( str, len ) {} - - template < typename ReverseIterator > - size_type reverse_distance( ReverseIterator first, ReverseIterator last ) const - { - return this->size() - 1 - static_cast( nv::distance( first, last ) ); - } - }; - - template< typename T, typename H > - struct hash< T, H, typename enable_if< is_string_base::value, void >::type > - : detail::hash_base< T, H > - { - static H get( const T& value ) - { - return value.template get_hash< H >(); - } - inline H operator()( const T& value ) const { return get( value ); } - }; - - class string_view : public string_base< array_view< char > > - { - public: - typedef string_base< array_view< char > > this_type; - - constexpr string_view() : this_type() {} - inline string_view( const string_view& rhs ) : this_type( rhs.data(), rhs.size() ) {} - template < typename S > - inline string_view( const string_base& rhs ) : this_type( rhs.data(), rhs.size() ) {} - inline string_view( const std::string& str ) : this_type( str.data(), str.size() ) {} - constexpr string_view( const char* str, size_type len ) : this_type( str, len ) {} - - // Literal constructors - template< size_t N > - constexpr string_view( char( &s )[N] ) : this_type( s, N - 1 ) {} - template< size_t N > - constexpr string_view( const char( &s )[N] ) : this_type( s, N - 1 ) {} - - // Non-literal constructors - template< typename U > - inline string_view( U str, typename enable_if::value>::type* = nullptr ) : this_type( str, nvstrlen( str ) ) {} - - // Non-literal constructors - template< typename U > - inline string_view( U str, typename enable_if::value>::type* = nullptr ) : this_type( str, nvstrlen( str ) ) {} - - inline string_view& operator=( const string_view &rhs ) - { - assign( rhs.data(), rhs.size() ); - return *this; - } - - // modifiers - inline void clear() - { - assign( nullptr, 0 ); - } - inline void remove_prefix( size_type n ) - { - size_type s = size(); - if ( n > s ) n = s; - assign( data() + n, s - n ); - } - inline void remove_suffix( size_type n ) - { - size_type s = size(); - if ( n > s ) n = s; - assign( data(), s - n ); - } - - }; - - template < typename Storage > - inline int string_base< Storage >::compare( const string_view& rhs ) const - { - size_type this_size = this->size(); - int cmp = nvmemcmp( this->data(), rhs.data(), nv::min( this_size, rhs.size() ) ); - return cmp != 0 ? cmp : ( this_size == rhs.size() ? 0 : this_size < rhs.size() ? -1 : 1 ); - } - - template < typename Storage > - inline bool string_base< Storage >::starts_with( value_type c ) const - { - return !this->empty() && c == this->front(); - } - template < typename Storage > - inline bool string_base< Storage >::starts_with( const string_view& s ) const - { - return this->size() >= s.size() && nvmemcmp( this->data(), s.data(), s.size() ) == 0; - } - - template < typename Storage > - inline bool string_base< Storage >::ends_with( value_type c ) const - { - return !this->empty() && c == this->back(); - } - template < typename Storage > - inline bool string_base< Storage >::ends_with( const string_view& s ) const - { - return this->size() >= s.size() && nvmemcmp( this->data() + this->size() - s.size(), s.data(), s.size() ) == 0; - } - - template < typename Storage > - inline auto string_base< Storage >::find( value_type c, size_type pos /*= 0*/ ) const -> size_type - { - if ( pos >= this->size() ) return npos; - const_iterator it = nv::find_if( this->cbegin() + static_cast( pos ), this->cend(), [=] ( value_type val ) { return val == c; } ); - return it == this->cend() ? npos : static_cast( nv::distance( this->cbegin(), it ) ); - } - template < typename Storage > - inline auto string_base< Storage >::find( const string_view& s, size_type pos /*= 0*/ ) const -> size_type - { - if ( pos >= this->size() ) return npos; - const_iterator it = nv::search( this->cbegin() + static_cast( pos ), this->cend(), s.cbegin(), s.cend() ); - return it == this->cend() ? npos : static_cast( nv::distance( this->cbegin(), it ) ); - } - - template < typename Storage > - inline auto string_base< Storage >::rfind( value_type c, size_type pos /*= 0*/ ) const -> size_type - { - if ( pos >= this->size() ) return npos; - const_reverse_iterator it = nv::find_if( this->crbegin() + static_cast( pos ), this->crend(), [=] ( value_type val ) { return val == c; } ); - return it == this->crend() ? npos : this->reverse_distance( this->crbegin(), it ); - } - template < typename Storage > - inline auto string_base< Storage >::rfind( const string_view& s, size_type pos /*= 0*/ ) const -> size_type - { - if ( pos >= this->size() ) return npos; - const_reverse_iterator it = nv::search( this->crbegin() + static_cast( pos ), this->crend(), s.crbegin(), s.crend() ); - return it == this->crend() ? npos : this->reverse_distance( this->crbegin(), it ); - } - - template < typename Storage > - inline auto string_base< Storage >::find_first_of( value_type c ) const -> size_type - { - return this->find( c ); - } - template < typename Storage > - inline auto string_base< Storage >::find_first_of( const string_view& s ) const -> size_type - { - const_iterator it = nv::find_first_of( this->cbegin(), this->cend(), s.cbegin(), s.cend() ); - return it == this->cend() ? npos : static_cast( nv::distance( this->cbegin(), it ) ); - } - - template < typename Storage > - inline auto string_base< Storage >::find_last_of( value_type c ) const -> size_type - { - return this->rfind( c ); - } - template < typename Storage > - inline auto string_base< Storage >::find_last_of( const string_view& s ) const -> size_type - { - const_reverse_iterator it = nv::find_first_of( this->crbegin(), this->crend(), s.cbegin(), s.cend() ); - return it == this->crend() ? npos : this->reverse_distance( this->crbegin(), it ); - } - - template < typename Storage > - inline auto string_base< Storage >::find_first_not_of( value_type c ) const -> size_type - { - for ( const_iterator it = this->cbegin(); it != this->cend(); ++it ) - if ( c != *it ) - return static_cast( nv::distance( this->cbegin(), it ) ); - return npos; - } - template < typename Storage > - inline auto string_base< Storage >::find_first_not_of( const string_view& s ) const -> size_type - { - for ( const_iterator it = this->cbegin(); it != this->cend(); ++it ) - if ( 0 == nvmemchr( s.data(), static_cast( *it ), s.size() ) ) - return static_cast( nv::distance( this->cbegin(), it ) ); - return npos; - } - - template < typename Storage > - inline auto string_base< Storage >::find_last_not_of( value_type c ) const -> size_type - { - for ( const_reverse_iterator it = this->crbegin(); it != this->crend(); ++it ) - if ( c != *it ) - return this->reverse_distance( this->crbegin(), it ); - return npos; - } - template < typename Storage > - inline auto string_base< Storage >::find_last_not_of( const string_view& s ) const -> size_type - { - for ( const_reverse_iterator it = this->crbegin(); it != this->crend(); ++it ) - if ( 0 == nvmemchr( s.data(), static_cast( *it ), s.size() ) ) - return this->reverse_distance( this->crbegin(), it ); - return npos; - } - - template < typename Storage > - inline string_view string_base< Storage >::substr( size_type p, size_type n ) const - { - if ( p > this->size() ) return string_view(); // NV_THROW( out_of_range( "substr" ) ); - if ( n == npos || n == p || p + n > this->size() ) n = this->size() - p; - return string_view( this->data() + p, n ); - } - -#define NV_STRING_BASE_CAST_OPERATORS( OPERATOR )\ -template < typename S > inline bool operator OPERATOR ( const string_base< S >& lhs, const std::string& rhs )\ -{\ - return lhs OPERATOR string_view( rhs );\ -}\ -template < typename S > inline bool operator OPERATOR ( const std::string& lhs, const string_base< S >& rhs )\ -{\ - return string_view( lhs ) OPERATOR rhs;\ -}\ -template < typename S > inline bool operator OPERATOR ( const string_base< S >& lhs, const char* rhs )\ -{\ - return lhs OPERATOR string_view( rhs );\ -}\ -template < typename S > inline bool operator OPERATOR ( const char* lhs, const string_base< S >& rhs )\ -{\ - return string_view( lhs ) OPERATOR rhs;\ -}\ - - // Base operators - template < typename S1, typename S2 > - inline bool operator==( const string_base< S1 >& lhs, const string_base< S2 >& rhs ) - { - return lhs.size() != rhs.size() ? false : ( lhs.compare( rhs ) == 0 ); - } - template < typename S1, typename S2 > - inline bool operator!=( const string_base< S1 >& lhs, const string_base< S2 >& rhs ) - { - return lhs.size() != rhs.size() ? true : ( lhs.compare( rhs ) != 0 ); - } - template < typename S1, typename S2 > - inline bool operator<( const string_base< S1 >& lhs, const string_base< S2 >& rhs ) - { - return lhs.compare( rhs ) < 0; - } - template < typename S1, typename S2 > - inline bool operator>( const string_base< S1 >& lhs, const string_base< S2 >& rhs ) - { - return lhs.compare( rhs ) > 0; - } - template < typename S1, typename S2 > - inline bool operator<=( const string_base< S1 >& lhs, const string_base< S2 >& rhs ) - { - return lhs.compare( rhs ) <= 0; - } - template < typename S1, typename S2 > - inline bool operator>=( const string_base< S1 >& lhs, const string_base< S2 >& rhs ) - { - return lhs.compare( rhs ) >= 0; - } - - NV_STRING_BASE_CAST_OPERATORS( == ) - NV_STRING_BASE_CAST_OPERATORS( != ) - NV_STRING_BASE_CAST_OPERATORS( < ) - NV_STRING_BASE_CAST_OPERATORS( > ) - NV_STRING_BASE_CAST_OPERATORS( <= ) - NV_STRING_BASE_CAST_OPERATORS( >= ) - - -#undef NV_STRING_REF_CAST_OPERATORS size_t sint32_to_buffer( sint32 n, char* str ); @@ -423,153 +88,4 @@ float buffer_to_f32( const char* s, char** end ); double buffer_to_f64( const char* s, char** end ); - - // const string is movable but not copyable - class const_string : public string_base< array_view< char > > - { - public: - inline const_string() {} - inline const_string( const char* str, size_type len ) - { - initialize( str, len ); - } - inline explicit const_string( const char* str ) - { - initialize( str, nvstrlen( str ) ); - } - inline const_string( const string_view& rhs ) - { - initialize( rhs.data(), rhs.size() ); - } - template< size_t N > - inline const_string( char( &s )[N] ) - { - initialize( s, N-1 ); - } - template< size_t N > - inline const_string( const char( &s )[N] ) - { - initialize( s, N - 1 ); - } - ~const_string() - { - if ( data() ) - { - delete data(); - } - } - - inline const_string( const_string&& other ) - { - assign( other.data(), other.size() ); - other.assign( nullptr, 0 ); - } - - inline const_string& operator=( const_string&& other ) - { - pointer old_data = data(); - size_type old_size = size(); - assign( other.data(), other.size() ); - other.assign( old_data, old_size ); - return *this; - } - - // blocked copy constructor - const_string( const const_string & ) = delete; - // blocked copy operator - const_string& operator=( const const_string& ) = delete; - - private: - - void initialize( const char* p, size_type s ) - { - char* new_data = new char[s + 1]; - nvmemcpy( new_data, p, s ); - new_data[s] = 0; - assign( new_data, s ); - } - }; - - class literal_string : public string_base< array_view< char > > - { - constexpr literal_string( const char* str, size_t len ) : this_type( str, len ) {} - public: - typedef string_base< array_view< char > > this_type; - friend constexpr literal_string operator "" _ls( const char* str, size_t len ); - - template< size_t N > - constexpr literal_string( char( &s )[N] ) : this_type( s, N - 1 ) {} - template< size_t N > - constexpr literal_string( const char( &s )[N] ) : this_type( s, N - 1 ) {} - }; - - constexpr literal_string operator "" _ls( const char* str, size_t len ) - { - return literal_string( str, len ); - } - - template < typename H > - class hashed_literal_string; - using hashed_literal_string_32 = hashed_literal_string< uint32 >; - using hashed_literal_string_64 = hashed_literal_string< uint64 >; - - template < typename H > - class hashed_literal_string : public string_base< array_view< char > > - { - constexpr hashed_literal_string( const char* str, size_t len, H hash_code ) - : this_type( str, len ), m_hash( hash_code ) {} - public: - typedef string_base< array_view< char > > this_type; - - template< size_t N > - constexpr hashed_literal_string( char( &s )[N] ) - : this_type( s, N - 1 ), m_hash( detail::fnv_hash::hash( s, N - 1 ) ) {} - template< size_t N > - constexpr hashed_literal_string( const char( &s )[N] ) - : this_type( s, N - 1 ), m_hash( detail::fnv_hash::hash( s, N - 1 ) ) {} - - template < typename H2 > - constexpr H get_hash() const - { - static_assert( is_same< H, H2 >::value, "32/64 bit hash mismatch on hash_literal_string!" ); - return m_hash; - } - - friend constexpr hashed_literal_string_32 operator "" _hls32( const char* str, size_t len ); - friend constexpr hashed_literal_string_64 operator "" _hls64( const char* str, size_t len ); - protected: - H m_hash; - }; - - constexpr hashed_literal_string_32 operator "" _hls32( const char* str, size_t len ) - { - return hashed_literal_string_32( str, len, detail::fnv_hash< uint32 >::hash( str, len ) ); - } - - constexpr hashed_literal_string_64 operator "" _hls64( const char* str, size_t len ) - { - return hashed_literal_string_64( str, len, detail::fnv_hash< uint64 >::hash( str, len ) ); - } - - template< typename H > - struct hash< hashed_literal_string_32, H > - { - static_assert( is_same< uint32, H >::value, "hashed_literal_string_32 used with non-32 bit hash!" ); - static constexpr H get( const hashed_literal_string_32& value ) - { - return value.get_hash< H >(); - } - constexpr H operator()( const hashed_literal_string_32& value ) const { return get( value ); } - }; - - template< typename H > - struct hash< hashed_literal_string_64, H > - { - static_assert( is_same< uint64, H >::value, "hashed_literal_string_64 used with non-64 bit hash!" ); - static constexpr H get( const hashed_literal_string_64& value ) - { - return value.get_hash< H >(); - } - constexpr H operator()( const hashed_literal_string_64& value ) const { return get( value ); } - }; inline string_view trimmed( const string_view& str ) @@ -648,7 +164,3 @@ } -using nv::operator "" _ls; -using nv::operator "" _hls32; -using nv::operator "" _hls64; - #endif // NV_STL_STRING_HH Index: trunk/nv/stl/string/common.hh =================================================================== --- trunk/nv/stl/string/common.hh (revision 433) +++ trunk/nv/stl/string/common.hh (revision 433) @@ -0,0 +1,41 @@ +// Copyright (C) 2012-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. + +#ifndef NV_STL_STRING_COMMON_HH +#define NV_STL_STRING_COMMON_HH + +#include +#include +#include + +namespace nv +{ + + template < typename Storage > class string_base; + class string_view; + + namespace detail + { + + template < typename T, typename Enable = void > + struct is_string_base_impl : false_type {}; + template < typename T > + struct is_string_base_impl < T, + typename enable_if< + is_base_of< string_base< typename T::storage_type >, T >::value, + void >::type > : true_type{}; + } + + + // Stronger version + // template < typename T > + // struct is_string_base : is_template_base_of< T, string_base > {}; + template < typename T > + struct is_string_base : detail::is_string_base_impl< T > {}; + +} + +#endif // NV_STL_STRING_COMMON_HH Index: trunk/nv/stl/string/const_string.hh =================================================================== --- trunk/nv/stl/string/const_string.hh (revision 433) +++ trunk/nv/stl/string/const_string.hh (revision 433) @@ -0,0 +1,84 @@ +// Copyright (C) 2012-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. + +#ifndef NV_STL_STRING_CONST_STRING_HH +#define NV_STL_STRING_CONST_STRING_HH + +#include +#include + +namespace nv +{ + + // const string is movable but not copyable + class const_string : public string_base< array_view< char > > + { + public: + inline const_string() {} + inline const_string( const char* str, size_type len ) + { + initialize( str, len ); + } + inline explicit const_string( const char* str ) + { + initialize( str, nvstrlen( str ) ); + } + inline const_string( const string_view& rhs ) + { + initialize( rhs.data(), rhs.size() ); + } + template< size_t N > + inline const_string( char( &s )[N] ) + { + initialize( s, N-1 ); + } + template< size_t N > + inline const_string( const char( &s )[N] ) + { + initialize( s, N - 1 ); + } + ~const_string() + { + if ( data() ) + { + delete data(); + } + } + + inline const_string( const_string&& other ) + { + assign( other.data(), other.size() ); + other.assign( nullptr, 0 ); + } + + inline const_string& operator=( const_string&& other ) + { + pointer old_data = data(); + size_type old_size = size(); + assign( other.data(), other.size() ); + other.assign( old_data, old_size ); + return *this; + } + + // blocked copy constructor + const_string( const const_string & ) = delete; + // blocked copy operator + const_string& operator=( const const_string& ) = delete; + + private: + + void initialize( const char* p, size_type s ) + { + char* new_data = new char[s + 1]; + nvmemcpy( new_data, p, s ); + new_data[s] = 0; + assign( new_data, s ); + } + }; + +} + +#endif // NV_STL_STRING_CONST_STRING_HH Index: trunk/nv/stl/string/literal_string.hh =================================================================== --- trunk/nv/stl/string/literal_string.hh (revision 433) +++ trunk/nv/stl/string/literal_string.hh (revision 433) @@ -0,0 +1,105 @@ +// Copyright (C) 2012-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. + +#ifndef NV_STL_STRING_LITERAL_STRING_HH +#define NV_STL_STRING_LITERAL_STRING_HH + +#include +#include + +namespace nv +{ + + class literal_string : public string_base< array_view< char > > + { + constexpr literal_string( const char* str, size_t len ) : this_type( str, len ) {} + public: + typedef string_base< array_view< char > > this_type; + friend constexpr literal_string operator "" _ls( const char* str, size_t len ); + + template< size_t N > + constexpr literal_string( char( &s )[N] ) : this_type( s, N - 1 ) {} + template< size_t N > + constexpr literal_string( const char( &s )[N] ) : this_type( s, N - 1 ) {} + }; + + constexpr literal_string operator "" _ls( const char* str, size_t len ) + { + return literal_string( str, len ); + } + + template < typename H > + class hashed_literal_string; + using hashed_literal_string_32 = hashed_literal_string< uint32 >; + using hashed_literal_string_64 = hashed_literal_string< uint64 >; + + template < typename H > + class hashed_literal_string : public string_base< array_view< char > > + { + constexpr hashed_literal_string( const char* str, size_t len, H hash_code ) + : this_type( str, len ), m_hash( hash_code ) {} + public: + typedef string_base< array_view< char > > this_type; + + template< size_t N > + constexpr hashed_literal_string( char( &s )[N] ) + : this_type( s, N - 1 ), m_hash( detail::fnv_hash::hash( s, N - 1 ) ) {} + template< size_t N > + constexpr hashed_literal_string( const char( &s )[N] ) + : this_type( s, N - 1 ), m_hash( detail::fnv_hash::hash( s, N - 1 ) ) {} + + template < typename H2 > + constexpr H get_hash() const + { + static_assert( is_same< H, H2 >::value, "32/64 bit hash mismatch on hash_literal_string!" ); + return m_hash; + } + + friend constexpr hashed_literal_string_32 operator "" _hls32( const char* str, size_t len ); + friend constexpr hashed_literal_string_64 operator "" _hls64( const char* str, size_t len ); + protected: + H m_hash; + }; + + constexpr hashed_literal_string_32 operator "" _hls32( const char* str, size_t len ) + { + return hashed_literal_string_32( str, len, detail::fnv_hash< uint32 >::hash( str, len ) ); + } + + constexpr hashed_literal_string_64 operator "" _hls64( const char* str, size_t len ) + { + return hashed_literal_string_64( str, len, detail::fnv_hash< uint64 >::hash( str, len ) ); + } + + template< typename H > + struct hash< hashed_literal_string_32, H > + { + static_assert( is_same< uint32, H >::value, "hashed_literal_string_32 used with non-32 bit hash!" ); + static constexpr H get( const hashed_literal_string_32& value ) + { + return value.get_hash< H >(); + } + constexpr H operator()( const hashed_literal_string_32& value ) const { return get( value ); } + }; + + template< typename H > + struct hash< hashed_literal_string_64, H > + { + static_assert( is_same< uint64, H >::value, "hashed_literal_string_64 used with non-64 bit hash!" ); + static constexpr H get( const hashed_literal_string_64& value ) + { + return value.get_hash< H >(); + } + constexpr H operator()( const hashed_literal_string_64& value ) const { return get( value ); } + }; + +} + +using nv::operator "" _ls; +using nv::operator "" _hls32; +using nv::operator "" _hls64; + +#endif // NV_STL_STRING_LITERAL_STRING_HH Index: trunk/nv/stl/string/short_string.hh =================================================================== --- trunk/nv/stl/string/short_string.hh (revision 433) +++ trunk/nv/stl/string/short_string.hh (revision 433) @@ -0,0 +1,12 @@ +// Copyright (C) 2012-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. + +#ifndef NV_STL_STRING_SHORT_STRING_HH +#define NV_STL_STRING_SHORT_STRING_HH + +#include + +#endif // NV_STL_STRING_SHORT_STRING_HH Index: trunk/nv/stl/string/string_base.hh =================================================================== --- trunk/nv/stl/string/string_base.hh (revision 433) +++ trunk/nv/stl/string/string_base.hh (revision 433) @@ -0,0 +1,322 @@ +// Copyright (C) 2012-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. + +#ifndef NV_STL_STRING_STRING_BASE_HH +#define NV_STL_STRING_STRING_BASE_HH + +#include +#include +#include // TODO: /stl/memory/array_ref? + +namespace nv +{ + + // string base class - will become a base for a string class later + template < typename Storage > + class string_base : public Storage + { + typedef Storage base_type; + typedef string_base< base_type > this_type; + public: + typedef Storage storage_type; + typedef typename base_type::value_type value_type; + typedef typename base_type::pointer pointer; + typedef typename base_type::const_pointer const_pointer; + typedef typename base_type::reference reference; + typedef typename base_type::const_reference const_reference; + typedef typename base_type::iterator iterator; + typedef typename base_type::const_iterator const_iterator; + typedef typename base_type::reverse_iterator reverse_iterator; + typedef typename base_type::const_reverse_iterator const_reverse_iterator; + typedef typename base_type::size_type size_type; + typedef typename base_type::difference_type difference_type; + + static constexpr size_type npos = size_type( -1 ); + + inline size_type length() const { return this->size(); } + + // string operations + int compare( const string_view& rhs ) const; + bool starts_with( value_type c ) const; + bool starts_with( const string_view& s ) const; + bool ends_with( value_type c ) const; + bool ends_with( const string_view& s ) const; + auto find( value_type c, size_type pos = 0 ) const->size_type; + auto find( const string_view& s, size_type pos = 0 ) const->size_type; + auto rfind( value_type c, size_type pos = 0 ) const->size_type; + auto rfind( const string_view& s, size_type pos = 0 ) const->size_type; + auto find_first_of( value_type c ) const->size_type; + auto find_first_of( const string_view& s ) const->size_type; + auto find_last_of( value_type c ) const->size_type; + auto find_last_of( const string_view& s ) const->size_type; + auto find_first_not_of( value_type c ) const->size_type; + auto find_first_not_of( const string_view& s ) const->size_type; + auto find_last_not_of( value_type c ) const->size_type; + auto find_last_not_of( const string_view& s ) const->size_type; + + // string operations + string_view substr( size_type p, size_type n = npos ) const; + + template < typename H = size_type > + inline H get_hash() const + { + return hash_string< H >( this->data(), this->size() ); + } + + protected: + using base_type::base_type; + constexpr string_base() : base_type() {} + constexpr string_base( pointer str, size_type len ) : base_type( str, len ) {} + + template < typename ReverseIterator > + size_type reverse_distance( ReverseIterator first, ReverseIterator last ) const + { + return this->size() - 1 - static_cast( nv::distance( first, last ) ); + } + }; + + template< typename T, typename H > + struct hash< T, H, typename enable_if< is_string_base::value, void >::type > + : detail::hash_base< T, H > + { + static H get( const T& value ) + { + return value.template get_hash< H >(); + } + inline H operator()( const T& value ) const { return get( value ); } + }; + + class string_view : public string_base< array_view< char > > + { + public: + typedef string_base< array_view< char > > this_type; + + constexpr string_view() : this_type() {} + inline string_view( const string_view& rhs ) : this_type( rhs.data(), rhs.size() ) {} + template < typename S > + inline string_view( const string_base& rhs ) : this_type( rhs.data(), rhs.size() ) {} + constexpr string_view( const char* str, size_type len ) : this_type( str, len ) {} + + // Literal constructors + template< size_t N > + constexpr string_view( char( &s )[N] ) : this_type( s, N - 1 ) {} + template< size_t N > + constexpr string_view( const char( &s )[N] ) : this_type( s, N - 1 ) {} + + // Non-literal constructors + template< typename U > + inline string_view( U str, typename enable_if::value>::type* = nullptr ) : this_type( str, nvstrlen( str ) ) {} + + // Non-literal constructors + template< typename U > + inline string_view( U str, typename enable_if::value>::type* = nullptr ) : this_type( str, nvstrlen( str ) ) {} + + inline string_view& operator=( const string_view &rhs ) + { + assign( rhs.data(), rhs.size() ); + return *this; + } + + // modifiers + inline void clear() + { + assign( nullptr, 0 ); + } + inline void remove_prefix( size_type n ) + { + size_type s = size(); + if ( n > s ) n = s; + assign( data() + n, s - n ); + } + inline void remove_suffix( size_type n ) + { + size_type s = size(); + if ( n > s ) n = s; + assign( data(), s - n ); + } + + }; + + template < typename Storage > + inline int string_base< Storage >::compare( const string_view& rhs ) const + { + size_type this_size = this->size(); + int cmp = nvmemcmp( this->data(), rhs.data(), nv::min( this_size, rhs.size() ) ); + return cmp != 0 ? cmp : ( this_size == rhs.size() ? 0 : this_size < rhs.size() ? -1 : 1 ); + } + + template < typename Storage > + inline bool string_base< Storage >::starts_with( value_type c ) const + { + return !this->empty() && c == this->front(); + } + template < typename Storage > + inline bool string_base< Storage >::starts_with( const string_view& s ) const + { + return this->size() >= s.size() && nvmemcmp( this->data(), s.data(), s.size() ) == 0; + } + + template < typename Storage > + inline bool string_base< Storage >::ends_with( value_type c ) const + { + return !this->empty() && c == this->back(); + } + template < typename Storage > + inline bool string_base< Storage >::ends_with( const string_view& s ) const + { + return this->size() >= s.size() && nvmemcmp( this->data() + this->size() - s.size(), s.data(), s.size() ) == 0; + } + + template < typename Storage > + inline auto string_base< Storage >::find( value_type c, size_type pos /*= 0*/ ) const -> size_type + { + if ( pos >= this->size() ) return npos; + const_iterator it = nv::find_if( this->cbegin() + static_cast( pos ), this->cend(), [=] ( value_type val ) { return val == c; } ); + return it == this->cend() ? npos : static_cast( nv::distance( this->cbegin(), it ) ); + } + template < typename Storage > + inline auto string_base< Storage >::find( const string_view& s, size_type pos /*= 0*/ ) const -> size_type + { + if ( pos >= this->size() ) return npos; + const_iterator it = nv::search( this->cbegin() + static_cast( pos ), this->cend(), s.cbegin(), s.cend() ); + return it == this->cend() ? npos : static_cast( nv::distance( this->cbegin(), it ) ); + } + + template < typename Storage > + inline auto string_base< Storage >::rfind( value_type c, size_type pos /*= 0*/ ) const -> size_type + { + if ( pos >= this->size() ) return npos; + const_reverse_iterator it = nv::find_if( this->crbegin() + static_cast( pos ), this->crend(), [=] ( value_type val ) { return val == c; } ); + return it == this->crend() ? npos : this->reverse_distance( this->crbegin(), it ); + } + template < typename Storage > + inline auto string_base< Storage >::rfind( const string_view& s, size_type pos /*= 0*/ ) const -> size_type + { + if ( pos >= this->size() ) return npos; + const_reverse_iterator it = nv::search( this->crbegin() + static_cast( pos ), this->crend(), s.crbegin(), s.crend() ); + return it == this->crend() ? npos : this->reverse_distance( this->crbegin(), it ); + } + + template < typename Storage > + inline auto string_base< Storage >::find_first_of( value_type c ) const -> size_type + { + return this->find( c ); + } + template < typename Storage > + inline auto string_base< Storage >::find_first_of( const string_view& s ) const -> size_type + { + const_iterator it = nv::find_first_of( this->cbegin(), this->cend(), s.cbegin(), s.cend() ); + return it == this->cend() ? npos : static_cast( nv::distance( this->cbegin(), it ) ); + } + + template < typename Storage > + inline auto string_base< Storage >::find_last_of( value_type c ) const -> size_type + { + return this->rfind( c ); + } + template < typename Storage > + inline auto string_base< Storage >::find_last_of( const string_view& s ) const -> size_type + { + const_reverse_iterator it = nv::find_first_of( this->crbegin(), this->crend(), s.cbegin(), s.cend() ); + return it == this->crend() ? npos : this->reverse_distance( this->crbegin(), it ); + } + + template < typename Storage > + inline auto string_base< Storage >::find_first_not_of( value_type c ) const -> size_type + { + for ( const_iterator it = this->cbegin(); it != this->cend(); ++it ) + if ( c != *it ) + return static_cast( nv::distance( this->cbegin(), it ) ); + return npos; + } + template < typename Storage > + inline auto string_base< Storage >::find_first_not_of( const string_view& s ) const -> size_type + { + for ( const_iterator it = this->cbegin(); it != this->cend(); ++it ) + if ( 0 == nvmemchr( s.data(), static_cast( *it ), s.size() ) ) + return static_cast( nv::distance( this->cbegin(), it ) ); + return npos; + } + + template < typename Storage > + inline auto string_base< Storage >::find_last_not_of( value_type c ) const -> size_type + { + for ( const_reverse_iterator it = this->crbegin(); it != this->crend(); ++it ) + if ( c != *it ) + return this->reverse_distance( this->crbegin(), it ); + return npos; + } + template < typename Storage > + inline auto string_base< Storage >::find_last_not_of( const string_view& s ) const -> size_type + { + for ( const_reverse_iterator it = this->crbegin(); it != this->crend(); ++it ) + if ( 0 == nvmemchr( s.data(), static_cast( *it ), s.size() ) ) + return this->reverse_distance( this->crbegin(), it ); + return npos; + } + + template < typename Storage > + inline string_view string_base< Storage >::substr( size_type p, size_type n ) const + { + if ( p > this->size() ) return string_view(); // NV_THROW( out_of_range( "substr" ) ); + if ( n == npos || n == p || p + n > this->size() ) n = this->size() - p; + return string_view( this->data() + p, n ); + } + +#define NV_STRING_BASE_CAST_OPERATORS( OPERATOR )\ +template < typename S > inline bool operator OPERATOR ( const string_base< S >& lhs, const char* rhs )\ +{\ + return lhs OPERATOR string_view( rhs );\ +}\ +template < typename S > inline bool operator OPERATOR ( const char* lhs, const string_base< S >& rhs )\ +{\ + return string_view( lhs ) OPERATOR rhs;\ +}\ + + // Base operators + template < typename S1, typename S2 > + inline bool operator==( const string_base< S1 >& lhs, const string_base< S2 >& rhs ) + { + return lhs.size() != rhs.size() ? false : ( lhs.compare( rhs ) == 0 ); + } + template < typename S1, typename S2 > + inline bool operator!=( const string_base< S1 >& lhs, const string_base< S2 >& rhs ) + { + return lhs.size() != rhs.size() ? true : ( lhs.compare( rhs ) != 0 ); + } + template < typename S1, typename S2 > + inline bool operator<( const string_base< S1 >& lhs, const string_base< S2 >& rhs ) + { + return lhs.compare( rhs ) < 0; + } + template < typename S1, typename S2 > + inline bool operator>( const string_base< S1 >& lhs, const string_base< S2 >& rhs ) + { + return lhs.compare( rhs ) > 0; + } + template < typename S1, typename S2 > + inline bool operator<=( const string_base< S1 >& lhs, const string_base< S2 >& rhs ) + { + return lhs.compare( rhs ) <= 0; + } + template < typename S1, typename S2 > + inline bool operator>=( const string_base< S1 >& lhs, const string_base< S2 >& rhs ) + { + return lhs.compare( rhs ) >= 0; + } + + NV_STRING_BASE_CAST_OPERATORS( == ) + NV_STRING_BASE_CAST_OPERATORS( != ) + NV_STRING_BASE_CAST_OPERATORS( < ) + NV_STRING_BASE_CAST_OPERATORS( > ) + NV_STRING_BASE_CAST_OPERATORS( <= ) + NV_STRING_BASE_CAST_OPERATORS( >= ) + +} + +#undef NV_STRING_BASE_CAST_OPERATORS + +#endif // NV_STL_STRING_STRING_BASE_HH Index: trunk/src/core/library.cc =================================================================== --- trunk/src/core/library.cc (revision 432) +++ trunk/src/core/library.cc (revision 433) @@ -62,5 +62,5 @@ string_view library::get_name() const { - return string_view( m_name ); + return string_view( m_name.c_str(), m_name.size() ); } @@ -71,8 +71,8 @@ return true; } - NV_LOG_NOTICE( "library \"", string_view( m_name ), "\" : loading..." ); + NV_LOG_NOTICE( "library \"", string_view( m_name.c_str(), m_name.size() ), "\" : loading..." ); std::string name = m_name; - string_view ext( NV_LIB_EXT ); + std::string ext( NV_LIB_EXT ); if ( name.length() < ext.length() || name.substr( name.length() - ext.length(), ext.length() ) != ext ) @@ -85,8 +85,8 @@ if ( m_handle == NULL ) { - NV_LOG_NOTICE( "library \"", string_view( name ), "\" : failed to open!" ); + NV_LOG_NOTICE( "library \"", string_view( m_name.c_str(), m_name.size() ), "\" : failed to open!" ); return false; } - NV_LOG_NOTICE( "library \"", string_view( name ), "\" : loaded." ); + NV_LOG_NOTICE( "library \"", string_view( m_name.c_str(), m_name.size() ), "\" : loaded." ); return true; } @@ -97,5 +97,5 @@ if ( !result ) { - NV_LOG_CRITICAL( "library \"", string_view( m_name ), "\" : can't find symbol \"", symbol, "\"" ); + NV_LOG_CRITICAL( "library \"", string_view( m_name.c_str(), m_name.size() ), "\" : can't find symbol \"", symbol, "\"" ); NV_ABORT( "Library symbol load failed!" ); } @@ -117,5 +117,5 @@ if ( ! NV_LIB_CLOSE( m_handle ) ) { - NV_LOG_ERROR( "library \"", string_view( m_name ), "\" : can't close library!" ); + NV_LOG_ERROR( "library \"", string_view( m_name.c_str(), m_name.size() ), "\" : can't close library!" ); } m_handle = nullptr; Index: trunk/src/engine/particle_engine.cc =================================================================== --- trunk/src/engine/particle_engine.cc (revision 432) +++ trunk/src/engine/particle_engine.cc (revision 433) @@ -435,5 +435,5 @@ { data.affector_count--; - NV_LOG_WARNING( "Bad data passed to ", sub_type, " affector in particle system!" ); + NV_LOG_WARNING( "Bad data passed to ", string_view( sub_type.c_str(), sub_type.size() ), " affector in particle system!" ); } } @@ -441,5 +441,5 @@ { data.affector_count--; - NV_LOG_WARNING( "Unknown affector type in particle system! (", sub_type, ")" ); + NV_LOG_WARNING( "Unknown affector type in particle system! (", string_view( sub_type.c_str(), sub_type.size() ), ")" ); } } Index: trunk/src/engine/program_manager.cc =================================================================== --- trunk/src/engine/program_manager.cc (revision 432) +++ trunk/src/engine/program_manager.cc (revision 433) @@ -37,5 +37,5 @@ } - nv::program program = m_context->get_device()->create_program( string_view( vsource ), string_view( fsource ) ); + nv::program program = m_context->get_device()->create_program( string_view( vsource.c_str(), vsource.size() ), string_view( fsource.c_str(), fsource.size() ) ); return add( program ); } Index: trunk/src/engine/resource_system.cc =================================================================== --- trunk/src/engine/resource_system.cc (revision 432) +++ trunk/src/engine/resource_system.cc (revision 433) @@ -12,5 +12,6 @@ { m_lua = a_lua_state; - lua::register_storage( m_lua, get_storage_name(), string_view( "register_" + get_resource_name().to_string() ) ); + std::string delete_me = "register_" + std::string( get_resource_name().data(), get_resource_name().size() ); + lua::register_storage( m_lua, get_storage_name(), string_view( delete_me.c_str(), delete_me.size() ) ); } Index: trunk/src/formats/md5_loader.cc =================================================================== --- trunk/src/formats/md5_loader.cc (revision 432) +++ trunk/src/formats/md5_loader.cc (revision 433) @@ -155,5 +155,5 @@ sstream >> shader; remove_quotes( shader ); - maccess.set_name( make_name( shader ) ); + maccess.set_name( make_name( shader.c_str() ) ); next_line( sstream ); } Index: trunk/src/formats/obj_loader.cc =================================================================== --- trunk/src/formats/obj_loader.cc (revision 432) +++ trunk/src/formats/obj_loader.cc (revision 433) @@ -328,5 +328,5 @@ data_channel_set* result = data_channel_set_creator::create_set( 1 ); data_channel_set_creator raccess( result ); - raccess.set_name( make_name( reader->name ) ); + raccess.set_name( make_name( reader->name.c_str() ) ); uint8* rdata = raccess.add_channel( m_descriptor, reader->size * 3 ).raw_data(); Index: trunk/src/gl/gl_device.cc =================================================================== --- trunk/src/gl/gl_device.cc (revision 432) +++ trunk/src/gl/gl_device.cc (revision 433) @@ -19,7 +19,7 @@ m_shader_header = "#version 120\n"; for ( auto& i : get_uniform_factory() ) - m_shader_header += "uniform "+datatype_to_glsl_type( i.second->get_datatype() )+" "+ i.first.to_string() +";\n"; + m_shader_header += "uniform "+datatype_to_glsl_type( i.second->get_datatype() )+" "+ std::string( i.first.data(), i.first.size() ) +";\n"; for ( auto& i : get_link_uniform_factory() ) - m_shader_header += "uniform sampler2D "+i.first.to_string() +";\n"; + m_shader_header += "uniform sampler2D "+std::string( i.first.data(), i.first.size() ) +";\n"; } @@ -212,5 +212,5 @@ for ( auto& i : *info->m_uniform_map ) { - auto j = lmap.find( i.first ); + auto j = lmap.find( i.first.c_str() ); if ( j != lmap.end() ) { @@ -218,5 +218,5 @@ } - auto k = map.find( i.first ); + auto k = map.find( i.first.c_str() ); if ( k != map.end() ) { @@ -238,5 +238,5 @@ if ( fatal ) { - NV_LOG_CRITICAL( "gl_device : uniform '", string_view( name ), "' not found in program!" ); + NV_LOG_CRITICAL( "gl_device : uniform '", string_view( name.c_str(), name.size() ), "' not found in program!" ); NV_ABORT( "gl_device : uniform not found!" ); } @@ -257,5 +257,5 @@ if ( fatal ) { - NV_LOG_CRITICAL( "gl_device : attribute '", string_view( name ), "' not found in program!" ); + NV_LOG_CRITICAL( "gl_device : attribute '", string_view( name.c_str(), name.size() ), "' not found in program!" ); NV_ABORT( "gl_device : attribute not found!" ); } Index: trunk/src/gui/gui_environment.cc =================================================================== --- trunk/src/gui/gui_environment.cc (revision 432) +++ trunk/src/gui/gui_environment.cc (revision 433) @@ -30,5 +30,5 @@ } -void nv::gui::environment::load_style( const std::string& filename ) +void nv::gui::environment::load_style( const string_view& filename ) { m_renderer->load_style( filename ); Index: trunk/src/gui/gui_gfx_renderer.cc =================================================================== --- trunk/src/gui/gui_gfx_renderer.cc (revision 432) +++ trunk/src/gui/gui_gfx_renderer.cc (revision 433) @@ -187,10 +187,11 @@ } -nv::size_t gfx_renderer::load_font( const std::string& filename, nv::size_t size ) -{ - std::string id_name( filename ); +nv::size_t gfx_renderer::load_font( const string_view& filename, nv::size_t size ) +{ + std::string id_name( filename.data(), filename.size() ); char buffer[8]; size_t len = nv::sint32_to_buffer( sint32( size ), buffer ); id_name.append( std::string( buffer, len ) ); - auto i = m_font_names.find( id_name ); + string_view id( id_name.c_str(), id_name.size() ); + auto i = m_font_names.find( id ); if ( i != m_font_names.end() ) { @@ -198,13 +199,13 @@ } size_t result = m_fonts.size(); - texture_font* f = new texture_font( &m_atlas, filename.c_str(), static_cast( size ) ); + texture_font* f = new texture_font( &m_atlas, filename.data(), static_cast( size ) ); f->load_glyphs( "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~ " ); m_fonts.push_back( f ); m_reupload = true; - m_font_names[id_name] = result; + m_font_names[ id ] = result; return result; } -nv::size_t gfx_renderer::load_image( const std::string& filename ) +nv::size_t gfx_renderer::load_image( const string_view& filename ) { auto i = m_image_names.find( filename ); @@ -253,5 +254,5 @@ if ( m_style.get( e, "skin", selector, path ) ) { - size_t image_id = load_image( path ); + size_t image_id = load_image( string_view( path.c_str(), path.size() ) ); const image_info* image = get_image( image_id ); if ( image ) @@ -318,5 +319,5 @@ if ( m_style.get( e, "text_color", selector, color ) && m_style.get( e, "text_font", selector, path ) && m_style.get( e, "text_size", selector, border ) ) { - size_t font_id = load_font( path, size_t( border ) ); + size_t font_id = load_font( string_view( path.c_str(), path.size() ), size_t( border ) ); texture_font* font = get_font( font_id ); position p = abs.ul + position( 0, border ); Index: trunk/src/gui/gui_renderer.cc =================================================================== --- trunk/src/gui/gui_renderer.cc (revision 432) +++ trunk/src/gui/gui_renderer.cc (revision 433) @@ -7,5 +7,5 @@ #include "nv/gui/gui_renderer.hh" -void nv::gui::renderer::load_style( const std::string& filename ) +void nv::gui::renderer::load_style( const string_view& filename ) { m_style.load_style( filename ); Index: trunk/src/gui/gui_style.cc =================================================================== --- trunk/src/gui/gui_style.cc (revision 432) +++ trunk/src/gui/gui_style.cc (revision 433) @@ -16,5 +16,5 @@ } -void style::load_style( const std::string& filename ) +void style::load_style( const string_view& filename ) { m_lua.do_file( filename ); Index: trunk/src/lua/lua_function.cc =================================================================== --- trunk/src/lua/lua_function.cc (revision 432) +++ trunk/src/lua/lua_function.cc (revision 433) @@ -21,5 +21,5 @@ { lua_pop( L, 1 ); - NV_LUA_ABORT( "function_base::function_base", "not a valid path - ", a_path.to_string() ); + NV_LUA_ABORT( "function_base::function_base", "not a valid path - ", a_path.to_string().c_str() ); } @@ -27,5 +27,5 @@ { lua_pop( L, 1 ); - NV_LUA_ABORT( "function_base::function_base", "not a valid function - ", a_path.to_string() ); + NV_LUA_ABORT( "function_base::function_base", "not a valid function - ", a_path.to_string().c_str() ); } m_ref = luaL_ref( L, LUA_REGISTRYINDEX ); Index: trunk/src/lua/lua_map_tile.cc =================================================================== --- trunk/src/lua/lua_map_tile.cc (revision 432) +++ trunk/src/lua/lua_map_tile.cc (revision 433) @@ -55,5 +55,6 @@ nv::map_area* map_area = nv::lua::detail::to_map_area( L, 3 ); lua_settop( L, 2 ); - std::string code = nv::trimmed( lua_tostring( L, 1 ) ).to_string(); + nv::string_view lts = nv::trimmed( lua_tostring( L, 1 ) ); + std::string code( lts.data(), lts.size() ); std::string chars( " \r\t" ); code.erase( nv::remove_if( code.begin(), code.end(), Index: trunk/src/lua/lua_state.cc =================================================================== --- trunk/src/lua/lua_state.cc (revision 432) +++ trunk/src/lua/lua_state.cc (revision 433) @@ -116,5 +116,5 @@ if ( !p.resolve( m_state, global ) ) { - NV_LOG_ERROR( "Lua error : not a valid path - ", p.to_string() ); + NV_LOG_ERROR( "Lua error : not a valid path - ", p.to_string().c_str() ); return false; } @@ -123,5 +123,5 @@ { lua_pop( m_state, 1 ); - NV_LOG_ERROR( "Lua error : not a valid function - ", p.to_string() ); + NV_LOG_ERROR( "Lua error : not a valid function - ", p.to_string().c_str() ); return false; } @@ -442,5 +442,5 @@ for ( int i = 0; i < top; ++i ) { - NV_LOG_DEBUG( "#", i+1, " - ", lua_typename(m_state, lua_type(m_state, i+1) ), " = ", nlua_typecontent(m_state, i+1) ); + NV_LOG_DEBUG( "#", i+1, " - ", lua_typename(m_state, lua_type(m_state, i+1) ), " = ", nlua_typecontent(m_state, i+1).c_str() ); } }