Changeset 360 for trunk

Timestamp:

05/04/15 16:30:44 (10 years ago)

Author:

epyon

Message:

• more string_ref usage
• string_ref moved to string.hh
• initial const_string implemenation

Location:

trunk

Files:

• nv/core/string.hh (modified) (2 diffs)
• nv/core/string_ref.hh (deleted)
• nv/lua/lua_path.hh (modified) (1 diff)
• nv/lua/lua_state.hh (modified) (10 diffs)
• nv/lua/lua_values.hh (modified) (1 diff)
• src/lua/lua_map_area.cc (modified) (3 diffs)
• src/lua/lua_path.cc (modified) (1 diff)
• src/lua/lua_state.cc (modified) (27 diffs)
• src/lua/lua_values.cc (modified) (1 diff)

trunk/nv/core/string.hh

@@ -2 +2 @@
 // This file is part of NV Libraries.
 // For conditions of distribution and use, see copyright notice in nv.hh
+//
+// TODO: tests for string_length
+//  * performance tests
+//  * matching tests
+//  * compatibility tests
+//  * check if we can get rid of const templates
+//
+// String reference implementation based of string_ref proposal and boost::string_ref
+//
+// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
+// http://www.boost.org/doc/libs/1_58_0/libs/utility/doc/html/string_ref.html
+//
+// TODO: WARNING: this code is centered around 8bit char. In particular, 
+//   const_string wont work with non-8bit chars.
+// TODO: remove templating on char type and TRAITS, make a string_utf8 instead.
 
 #ifndef NV_CORE_STRING_HH
@@ -225 +240 @@
         }
 
+        namespace detail
+        {
+                template< typename T >
+                struct string_length_impl
+                {
+                        static size_t get( T ) { return 0; }
+                };
+                template< size_t S >
+                struct string_length_impl < char[S] >
+                {
+                        static size_t get( const char[S] ) { return S - 1; }
+                };
+                template< size_t S >
+                struct string_length_impl < const char[S] >
+                {
+                        static size_t get( const char[S] ) { return S - 1; }
+                };
+                template<>
+                struct string_length_impl < char* >
+                {
+                        static size_t get( const char* s ) { return std::strlen( s ); }
+                };
+                template<>
+                struct string_length_impl < const char* >
+                {
+                        static size_t get( const char* s ) { return std::strlen( s ); }
+                };
+                template<>
+                struct string_length_impl < std::string >
+                {
+                        static size_t get( const std::string& s ) { return s.length(); }
+                };
+                template<>
+                struct string_length_impl < const std::string >
+                {
+                        static size_t get( const std::string& s ) { return s.length(); }
+                };
+        }
+
         template< typename T >
-        struct string_length
-        {
-                static size_t get( T ) { return 0; }
+        using string_length = detail::string_length_impl <
+                typename std::remove_cv < typename std::remove_reference< T >::type >::type >;
+
+        template<typename T, typename TRAITS = std::char_traits<T> > class basic_string_ref;
+        
+        // string base class - will become a base for a string class later
+        template<typename T, typename TRAITS = std::char_traits<T> >
+        class basic_string_base
+        {
+        public:
+                typedef T              value_type;
+                typedef const T*       pointer;
+                typedef const T&       reference;
+                typedef const T&       const_reference;
+                typedef pointer        const_iterator;
+                typedef const_iterator iterator;
+                typedef std::size_t    size_type;
+                typedef std::ptrdiff_t difference_type;
+
+                typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+                typedef const_reverse_iterator                reverse_iterator;
+
+                static NV_CONSTEXPR_CONST size_type npos = size_type( -1 );
+
+                // conversion to std::string
+                std::basic_string<T, TRAITS> to_string() const
+                {
+                        return std::basic_string<T, TRAITS>( m_data, m_size );
+                }
+
+                // iterators
+                NV_CONSTEXPR const_iterator  cbegin() const { return m_data; }
+                NV_CONSTEXPR const_iterator    cend() const { return m_data + m_size; }
+                const_reverse_iterator crbegin() const { return const_reverse_iterator( end() ); }
+                const_reverse_iterator   crend() const { return const_reverse_iterator( begin() ); }
+
+                NV_CONSTEXPR size_type size()     const { return m_size; }
+                NV_CONSTEXPR size_type length()   const { return m_size; }
+                NV_CONSTEXPR size_type max_size() const { return m_size; }
+                NV_CONSTEXPR bool empty()         const { return m_size == 0; }
+
+                // access
+                NV_CONSTEXPR const T& operator[]( size_type i ) const { return m_data[i]; }
+                const T& at( size_t i ) const
+                {
+                        //      if ( i >= m_data ) NV_THROW( std::out_of_range( "string_ref::at" ) );
+                        return m_data[i];
+                }
+
+                NV_CONSTEXPR const T& front() const { return m_data[0]; }
+                NV_CONSTEXPR const T& back()  const { return m_data[m_size - 1]; }
+                NV_CONSTEXPR const T* data()  const { return m_data; }
+
+                // string operations
+                int compare( basic_string_base rhs ) const
+                {
+                        int cmp = TRAITS::compare( m_data, rhs.m_data, ( std::min )( m_size, rhs.m_size ) );
+                        return cmp != 0 ? cmp : ( m_size == rhs.m_size ? 0 : m_size < rhs.m_size ? -1 : 1 );
+                }
+                bool starts_with( T c ) const { return !empty() && TRAITS::eq( c, front() ); }
+                bool starts_with( basic_string_base s ) const
+                {
+                        return m_size >= s.m_size && TRAITS::compare( m_data, s.m_data, s.m_size ) == 0;
+                }
+                bool ends_with( T c ) const { return !empty() && TRAITS::eq( c, back() ); }
+                bool ends_with( basic_string_base s ) const
+                {
+                        return m_size >= s.m_size && TRAITS::compare( m_data + m_size - s.m_size, s.m_data, s.m_size ) == 0;
+                }
+                size_type find( basic_string_base s, size_type pos = 0 ) const
+                {
+                        if ( pos >= m_size ) return npos;
+                        const_iterator it = std::search( this->cbegin() + pos, this->cend(), s.cbegin(), s.cend(), TRAITS::eq );
+                        return it == this->cend() ? npos : std::distance( this->cbegin(), it );
+                }
+                size_type find( T c, size_type pos = 0 ) const
+                {
+                        if ( pos >= m_size ) return npos;
+                        const_iterator it = std::find_if( this->cbegin() + pos, this->cend(), [=] ( T val ) { return TRAITS::eq( val, c ); } );
+                        return it == this->cend() ? npos : std::distance( this->cbegin(), it );
+                }
+                size_type rfind( basic_string_base s, size_type pos = 0 ) const
+                {
+                        if ( pos >= m_size ) return npos;
+                        const_reverse_iterator it = std::search( this->crbegin() + pos, this->crend(), s.crbegin(), s.crend(), TRAITS::eq );
+                        return it == this->crend() ? npos : m_size - 1 - std::distance( this->crbegin(), it );
+                }
+                size_type rfind( T c, size_type pos = 0 ) const
+                {
+                        if ( pos >= m_size ) return npos;
+                        const_reverse_iterator it = std::find_if( this->crbegin() + pos, this->crend(), [=] ( T val ) { return TRAITS::eq( val, c ); } );
+                        return it == this->crend() ? npos : m_size - 1 - std::distance( this->crbegin(), it );
+                }
+                size_type find_first_of( T c ) const { return find( c ); }
+                size_type find_first_of( basic_string_base s ) const
+                {
+                        const_iterator it = std::find_first_of( this->cbegin(), this->cend(), s.cbegin(), s.cend(), TRAITS::eq );
+                        return it == this->cend() ? npos : std::distance( this->cbegin(), it );
+                }
+                size_type find_last_of( T c )  const { return rfind( c ); }
+                size_type find_last_of( basic_string_base s ) const
+                {
+                        const_reverse_iterator it = std::find_first_of( this->crbegin(), this->crend(), s.cbegin(), s.cend(), TRAITS::eq );
+                        return it == this->crend() ? npos : m_size - 1 - std::distance( this->crbegin(), it );
+                }
+                size_type find_first_not_of( basic_string_base s ) const
+                {
+                        for ( const_iterator it = this->cbegin(); it != this->cend(); ++it )
+                                if ( 0 == TRAITS::find( s.m_data, s.m_size, *first ) )
+                                        return std::distance( this->cbegin(), it );
+                        return npos;
+                }
+                size_type find_first_not_of( T c ) const
+                {
+                        for ( const_iterator it = this->cbegin(); it != this->cend(); ++it )
+                                if ( !TRAITS::eq( c, *it ) )
+                                        return std::distance( this->cbegin(), it );
+                        return npos;
+                }
+                size_type find_last_not_of( basic_string_base s ) const
+                {
+                        for ( const_reverse_iterator it = this->crbegin(); it != this->crend(); ++it )
+                                if ( 0 == TRAITS::find( s.m_data, s.m_size, *it ) )
+                                        return m_size - 1 - std::distance( this->crbegin(), it );;
+                        return npos;
+                }
+                size_type find_last_not_of( T c ) const
+                {
+                        for ( const_reverse_iterator it = this->crbegin(); it != this->crend(); ++it )
+                                if ( !TRAITS::eq( c, *it ) )
+                                        return m_size - 1 - std::distance( this->crbegin(), it );
+                        return npos;
+                }
+
+                // string operations
+                basic_string_ref< T, TRAITS > substr( size_type p, size_type n = npos ) const
+                {
+                        if ( p > size() ) return basic_string_ref< T, TRAITS >(); // NV_THROW( std::out_of_range( "substr" ) );
+                        if ( n == p || p + n > size() ) n = size() - p;
+                        return basic_string_ref< T, TRAITS >( data() + p, n );
+                }
+
+        protected:
+                NV_CONSTEXPR basic_string_base() : m_data( nullptr ), m_size( 0 ) {}
+                NV_CONSTEXPR basic_string_base( pointer a_data, size_type a_lenght )
+                        : m_data( a_data ), m_size( a_lenght ) {}
+
+        protected:
+                pointer   m_data;
+                size_type m_size;
         };
-        template< size_t S >
-        struct string_length< char[S] >
-        {
-                static size_t get( const char[S] ) { return S-1; }
+
+#define NV_STRING_BASE_CAST_OPERATORS( OPERATOR )\
+template < typename T, typename TRAITS, typename ALLOCATOR >\
+inline bool operator OPERATOR ( basic_string_base< T, TRAITS > lhs, const std::basic_string< T, TRAITS, ALLOCATOR >& rhs )\
+                {\
+        return lhs OPERATOR basic_string_base< T, TRAITS >( rhs );\
+                }\
+template < typename T, typename TRAITS, typename ALLOCATOR >\
+inline bool operator OPERATOR ( const std::basic_string< T, TRAITS, ALLOCATOR >& lhs, basic_string_base< T, TRAITS > rhs )\
+                {\
+        return basic_string_base< T, TRAITS >( lhs ) OPERATOR rhs;\
+                }\
+template < typename T, typename TRAITS >\
+inline bool operator OPERATOR ( basic_string_base<T, TRAITS> lhs, const T* rhs )\
+                {\
+        return lhs OPERATOR basic_string_base< T, TRAITS >( rhs );\
+                }\
+template < typename T, typename TRAITS >\
+inline bool operator OPERATOR ( const T* lhs, basic_string_base< T, TRAITS > rhs )\
+                {\
+        return basic_string_base< T, TRAITS >( lhs ) OPERATOR rhs;\
+                }\
+
+        // Base operators
+        template < typename T, typename TRAITS >
+        inline bool operator==( basic_string_base< T, TRAITS > lhs, basic_string_base< T, TRAITS > rhs )
+        {
+                return lhs.size() != rhs.size() ? false : ( lhs.compare( rhs ) == 0 );
+        }
+        template < typename T, typename TRAITS >
+        inline bool operator!=( basic_string_base< T, TRAITS > lhs, basic_string_base< T, TRAITS > rhs )
+        {
+                return lhs.size() != rhs.size() ? true : ( lhs.compare( rhs ) != 0 );
+        }
+        template < typename T, typename TRAITS >
+        inline bool operator<( basic_string_base< T, TRAITS > lhs, basic_string_base< T, TRAITS > rhs )
+        {
+                return lhs.compare( rhs ) < 0;
+        }
+        template < typename T, typename TRAITS >
+        inline bool operator>( basic_string_base< T, TRAITS > lhs, basic_string_base< T, TRAITS > rhs )
+        {
+                return lhs.compare( rhs ) > 0;
+        }
+        template < typename T, typename TRAITS >
+        inline bool operator<=( basic_string_base< T, TRAITS > lhs, basic_string_base< T, TRAITS > rhs )
+        {
+                return lhs.compare( rhs ) <= 0;
+        }
+        template < typename T, typename TRAITS >
+        inline bool operator>=( basic_string_base< T, TRAITS > lhs, basic_string_base< T, TRAITS > 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( >= )
+
+        template < class T, class TRAITS >
+        inline std::basic_ostream<T, TRAITS>& operator<<( std::basic_ostream<T, TRAITS>& os, const basic_string_base<T, TRAITS>& str )
+        {
+                if ( os.good() )
+                {
+                        os.write( str.data(), str.size() );
+                }
+                return os;
+        }
+
+#undef NV_STRING_REF_CAST_OPERATORS
+
+        template<typename T, typename TRAITS>
+        class basic_string_ref : public basic_string_base < T, TRAITS >
+        {
+        public:
+
+                NV_CONSTEXPR basic_string_ref() {}
+                NV_CONSTEXPR basic_string_ref( const basic_string_ref &rhs )
+                        : basic_string_base( rhs.m_data, rhs.m_size )
+                {
+                }
+                NV_CONSTEXPR basic_string_ref( const basic_string_base< T, TRAITS > &rhs )
+                        : basic_string_base( rhs.m_data, rhs.m_size )
+                {
+                }
+
+                template< typename ALLOCATOR >
+                basic_string_ref( const std::basic_string<T, TRAITS, ALLOCATOR>& str )
+                        : basic_string_base( str.data(), str.length() )
+                {
+                }
+
+                NV_CONSTEXPR basic_string_ref( const T* str, size_type len )
+                        : basic_string_base( str, len )
+                {
+                }
+
+                // Literal constructors
+                template< size_t N, typename std::enable_if<std::is_same<T, char>::value>::type* = nullptr >
+                basic_string_ref( T( &s )[N] ) : basic_string_base( s, N - 1 ) {}
+                template< size_t N, typename std::enable_if<std::is_same<T, char>::value>::type* = nullptr >
+                basic_string_ref( const T( &s )[N] ) : basic_string_base( s, N - 1 ) {}
+
+                // Non-literal constructors
+                template< typename U, typename std::enable_if<std::is_same<U, const char*>::value>::type* = nullptr >
+                basic_string_ref( U str ) : basic_string_base( str, TRAITS::length( str ) ) {}
+
+                basic_string_ref& operator=( const basic_string_ref &rhs )
+                {
+                        m_data = rhs.m_data;
+                        m_size = rhs.m_size;
+                        return *this;
+                }
+
+                // iterators
+                NV_CONSTEXPR const_iterator   begin() const { return m_data; }
+                NV_CONSTEXPR const_iterator     end() const { return m_data + m_size; }
+                const_reverse_iterator  rbegin() const { return const_reverse_iterator( end() ); }
+                const_reverse_iterator    rend() const { return const_reverse_iterator( begin() ); }
+
+                // modifiers
+                void clear()
+                {
+                        m_size = 0;
+                        m_data = nullptr;
+                }
+                void remove_prefix( size_type n )
+                {
+                        if ( n > m_size )       n = m_size;
+                        m_data += n;
+                        m_size -= n;
+                }
+                void remove_suffix( size_type n )
+                {
+                        if ( n > m_size ) n = m_size;
+                        m_size -= n;
+                }
+
         };
-        template< size_t S >
-        struct string_length< const char[S] >
-        {
-                static size_t get( const char[S] ) { return S-1; }
+
+        typedef basic_string_ref<char, std::char_traits<char> > string_ref;
+
+        // const string is movable but not copyable
+        template<typename T, typename TRAITS>
+        class basic_const_string : public basic_string_base < T, TRAITS >
+        {
+        public:
+                basic_const_string() {}
+                basic_const_string( const T* str, size_type len )
+                {
+                        initialize( str, len );
+                }
+                explicit basic_const_string( const T* str )
+                {
+                        initialize( str, TRAITS::length( str ) );
+                }
+
+                ~basic_const_string()
+                {
+                        if ( m_data ) delete m_data;
+                }
+
+                basic_const_string( const basic_const_string&& other )
+                {
+                        std::swap( m_data, other.m_data );
+                        return *this;
+                }
+
+                basic_const_string& operator=( const basic_const_string&& other )
+                {
+                        std::swap( m_data, other.m_data );
+                        return *this;
+                }
+
+        private:
+                // blocked copy constructor
+                basic_const_string( const basic_const_string & );
+                // blocked copy operator
+                basic_const_string& operator=( const basic_const_string& );
+
+                void assign( const T* p, size_type s )
+                {
+                        m_data = new T[s + 1];
+                        TRAITS::copy( m_data, p, s );
+                        m_data[s] = 0;
+                }
         };
-        template<>
-        struct string_length< char* >
-        {
-                static size_t get( const char* s ) { return std::strlen( s ); }
-        };
-        template<>
-        struct string_length< const char* >
-        {
-                static size_t get( const char* s ) { return std::strlen( s ); }
-        };
-        template<>
-        struct string_length< std::string >
-        {
-                static size_t get( const std::string& s ) { return s.length(); }
-        };
 
 

trunk/nv/lua/lua_path.hh

@@ -16 +16 @@
 #include <nv/core/common.hh>
 #include <nv/core/string.hh>
-#include <nv/core/string_ref.hh>
 #include <cstring>
 

trunk/nv/lua/lua_state.hh

@@ -15 +15 @@
 #include <nv/core/flags.hh>
 #include <nv/core/handle.hh>
-#include <nv/core/string_ref.hh>
 #include <istream>
 #include <map>
@@ -23 +22 @@
 #include <nv/lua/lua_values.hh>
 #include <nv/lua/lua_dispatch.hh>
-#include <string>
+
 
 #ifdef NV_DEBUG
@@ -130 +129 @@
                         }
                         bool is_defined( const path& p ) { return is_defined( p, m_global ); }
-                        void register_native_function( lfunction f, const char* name );
+                        void register_native_function( lfunction f, string_ref name );
 
                         template < typename F, F f >
-                        void register_function( const char* name )
+                        void register_function( string_ref name )
                         {
                                 register_native_function( detail::function_wrapper< F, f >, name );
@@ -139 +138 @@
 
                         template < typename C, typename F, F f >
-                        struct register_member
-                        {
-                                register_member( const char* ) { }
-                        };
-
-                        template < typename C, typename F, F f >
-                        void register_function( const char* name )
+                        void register_function( string_ref name )
                         {
                                 register_native_function( detail::object_method_wrapper< C, F, f >, name );
@@ -199 +192 @@
                         explicit state( bool load_libs = false );
                         explicit state( lua_State* state );
-                        bool do_string( const std::string& code, const std::string& name, int rvalues = 0 );
-                        bool do_stream( std::istream& stream, const std::string& name );
-                        bool do_file( const std::string& filename );
+                        bool do_string( string_ref code, string_ref name, int rvalues = 0 );
+                        bool do_stream( std::istream& stream, string_ref name );
+                        bool do_file( string_ref filename );
                         int get_stack_size();
                         void log_stack();
                         lua_State* get_raw();
-                        ref register_object( void* o, const char* lua_name );
-                        ref register_proto( const char* id, const char* storage );
-                        void store_metadata( ref object_index, const std::string& metaname, void* pointer );
+                        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 );
                         void unregister_object( ref object_index );
 
-                        void register_enum( const char* name, int value );
-                        void register_singleton( const char* name, void* o );
-
-                        void register_native_object_method( const char* lua_name, const char* name, lfunction f );
+                        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 );
                         template < typename F, F f >
-                        void register_object_method( const char* lua_name, const char* name )
+                        void register_object_method( string_ref lua_name, string_ref name )
                         {
                                 register_native_object_method( lua_name, name, detail::object_method_wrapper< typename memfn_class_type<F>::type, F, f > );
@@ -232 +225 @@
                         }
                         template < typename H >
-                        ref register_handle_component( const H& handle, const std::string& id )
+                        ref register_handle_component( const H& handle, string_ref id )
                         {
                                 nv::lua::push_handle( m_state, handle );
@@ -238 +231 @@
                         }
                         template < typename H >
-                        ref register_handle_component( const H& handle, const std::string& id, const path& proto )
+                        ref register_handle_component( const H& handle, string_ref id, const path& proto )
                         {
                                 if ( !proto.resolve( m_state, true ) )
@@ -248 +241 @@
                         }
                         template < typename H >
-                        void unregister_handle_component( const H& handle, const std::string& id )
+                        void unregister_handle_component( const H& handle, string_ref id )
                         {
                                 nv::lua::push_handle( m_state, handle );
@@ -285 +278 @@
 
                 private:
-                        ref register_handle_component_impl( const std::string& id, bool empty );
-                        void unregister_handle_component_impl( const std::string& id );
-
-                        int load_string( const std::string& code, const std::string& name );
-                        int load_stream( std::istream& stream, const std::string& name );
-                        int load_file( const std::string& filename );
-                        int do_current( const std::string& name, int rvalues = 0 );
+                        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_stream( std::istream& stream, string_ref name );
+                        int load_file( string_ref filename );
+                        int do_current( string_ref name, int rvalues = 0 );
                         void deep_pointer_copy( int index, void* obj );
                 };
@@ -302 +295 @@
                         virtual ~table_guard();
                         size_t get_size();
-                        bool has_field( const std::string& element );
-                        std::string get_string( const std::string& element, const std::string& defval = "" );
-                        char get_char( const std::string& element, char defval = ' ' );
-                        int get_integer( const std::string& element, int defval = 0 );
-                        unsigned get_unsigned( const std::string& element, unsigned defval = 0 );
-                        double get_double( const std::string& element, double defval = 0.0 );
-                        float get_float( const std::string& element, float defval = 0.0 );
-                        bool get_boolean( const std::string& element, bool defval = false );
-                        bool is_table( const std::string& element );
-                        bool is_number( const std::string& element );
-                        bool is_boolean( const std::string& element );
-                        bool is_string( const std::string& element );
+                        bool has_field( string_ref element );
+                        std::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 );
                 private:
                         int m_level;

trunk/nv/lua/lua_values.hh

@@ -11 +11 @@
 #include <nv/core/type_traits.hh>
 #include <nv/core/string.hh>
-#include <nv/core/string_ref.hh>
 
 struct lua_State;

trunk/src/lua/lua_map_area.cc

@@ -57 +57 @@
         if ( lua_istable( L , index ) )
         {
-                lua_pushstring( L, "__map_area_ptr" );
+                lua_pushliteral( L, "__map_area_ptr" );
                 lua_rawget( L, index );
                 if ( lua_isuserdata( L, -1 ) )
@@ -96 +96 @@
 static int nlua_map_area_tostring( lua_State* L )
 {
-        lua_pushstring( L, "map_area" );
+        lua_pushliteral ( L, "map_area" );
         return 1;
 }
@@ -236 +236 @@
 {
         lua_rawgeti( L, LUA_REGISTRYINDEX, object_index.get() );
-        lua_pushstring( L, "__map_area_ptr" );
+        lua_pushliteral( L, "__map_area_ptr" );
         lua_pushlightuserdata( L, (map_area*)area );
         lua_rawset( L, -3 );

trunk/src/lua/lua_path.cc

@@ -18 +18 @@
         size_t point = spath.find( '.' );
 
-        while ( point != std::string::npos )
+        while ( point != string_ref::npos )
         {
                 m_elements[m_count].str    = spath.data();

trunk/src/lua/lua_state.cc

@@ -80 +80 @@
 }
 
-void lua::state_wrapper::register_native_function( lfunction f, const char* name )
+void lua::state_wrapper::register_native_function( lfunction f, string_ref name )
 {
         if ( m_global ) push_global_table();
         lua_pushcfunction( m_state, f );
-        lua_setfield( m_state, -2, name );
+        lua_setfield( m_state, -2, name.data() );
         if ( m_global ) pop_global_table();
 }
@@ -129 +129 @@
         if ( status != 0 )
         {
-                std::string error = lua_tostring( m_state, -1 );
+                NV_LOG( LOG_ERROR, "Lua error : " << lua_tostring( m_state, -1 ) );
                 lua_pop( m_state, 1 );
-                NV_LOG( LOG_ERROR, "Lua error : " << error )
         }
         return status;
@@ -172 +171 @@
 }
 
-bool lua::table_guard::has_field( const string& element )
-{
-        lua_getfield( m_state, -1, element.c_str() );
+bool lua::table_guard::has_field( string_ref element )
+{
+        lua_getfield( m_state, -1, element.data() );
         bool result = !( lua_isnil( m_state, -1 ) );
         lua_pop( m_state, 1 );
@@ -180 +179 @@
 }
 
-string lua::table_guard::get_string( const string& element, const string& defval /*= "" */ )
-{
-        lua_getfield( m_state, -1, element.c_str() );
-        string result( ( lua_type( m_state, -1 ) == LUA_TSTRING ) ? lua_tostring( m_state, -1 ) : defval );
-        lua_pop( m_state, 1 );
-        return result;
-}
-
-char lua::table_guard::get_char( const string& element, char defval /*= "" */ )
-{
-        lua_getfield( m_state, -1, element.c_str() );
+string lua::table_guard::get_string( string_ref element, string_ref defval /*= string_ref() */ )
+{
+        lua_getfield( m_state, -1, element.data() );
+        string result( ( lua_type( m_state, -1 ) == LUA_TSTRING ) ? lua_tostring( m_state, -1 ) : defval.to_string() );
+        lua_pop( m_state, 1 );
+        return result;
+}
+
+char lua::table_guard::get_char( string_ref element, char defval /*= "" */ )
+{
+        lua_getfield( m_state, -1, element.data() );
         char result = ( lua_type( m_state, -1 ) == LUA_TSTRING && lua_rawlen( m_state, -1 ) > 0 ) ? lua_tostring( m_state, -1 )[0] : defval;
         lua_pop( m_state, 1 );
@@ -196 +195 @@
 }
 
-int lua::table_guard::get_integer( const string& element, int defval /*= "" */ )
-{
-        lua_getfield( m_state, -1, element.c_str() );
+int lua::table_guard::get_integer( string_ref element, int defval /*= "" */ )
+{
+        lua_getfield( m_state, -1, element.data() );
         lua_Integer result = lua_type( m_state, -1 ) == LUA_TNUMBER ? lua_tointeger( m_state, -1 ) : defval;
         lua_pop( m_state, 1 );
@@ -204 +203 @@
 }
 
-unsigned lua::table_guard::get_unsigned( const string& element, unsigned defval /*= "" */ )
-{
-        lua_getfield( m_state, -1, element.c_str() );
+unsigned lua::table_guard::get_unsigned( string_ref element, unsigned defval /*= "" */ )
+{
+        lua_getfield( m_state, -1, element.data() );
         unsigned result = lua_type( m_state, -1 ) == LUA_TNUMBER ? lua_tounsigned( m_state, -1 ) : defval;
         lua_pop( m_state, 1 );
@@ -212 +211 @@
 }
 
-double lua::table_guard::get_double( const string& element, double defval /*= "" */ )
-{
-        lua_getfield( m_state, -1, element.c_str() );
+double lua::table_guard::get_double( string_ref element, double defval /*= "" */ )
+{
+        lua_getfield( m_state, -1, element.data() );
         double result = lua_type( m_state, -1 ) == LUA_TNUMBER ? lua_tonumber( m_state, -1 ) : defval;
         lua_pop( m_state, 1 );
@@ -221 +220 @@
 
 
-float nv::lua::table_guard::get_float( const std::string& element, float defval /*= 0.0 */ )
-{
-        lua_getfield( m_state, -1, element.c_str() );
+float nv::lua::table_guard::get_float( string_ref element, float defval /*= 0.0 */ )
+{
+        lua_getfield( m_state, -1, element.data() );
         float result = lua_type( m_state, -1 ) == LUA_TNUMBER ? (float)lua_tonumber( m_state, -1 ) : defval;
         lua_pop( m_state, 1 );
@@ -229 +228 @@
 }
 
-bool lua::table_guard::get_boolean( const string& element, bool defval /*= "" */ )
-{
-        lua_getfield( m_state, -1, element.c_str() );
+bool lua::table_guard::get_boolean( string_ref element, bool defval /*= "" */ )
+{
+        lua_getfield( m_state, -1, element.data() );
         bool result = lua_type( m_state, -1 ) == LUA_TBOOLEAN ? lua_toboolean( m_state, -1 ) != 0 : defval;
         lua_pop( m_state, 1 );
@@ -237 +236 @@
 }
 
-bool nv::lua::table_guard::is_table( const std::string& element )
-{
-        lua_getfield( m_state, -1, element.c_str() );
+bool nv::lua::table_guard::is_table( string_ref element )
+{
+        lua_getfield( m_state, -1, element.data() );
         bool result = lua_type( m_state, -1 ) == LUA_TTABLE;
         lua_pop( m_state, 1 );
@@ -245 +244 @@
 }
 
-bool nv::lua::table_guard::is_number( const std::string& element )
-{
-        lua_getfield( m_state, -1, element.c_str() );
+bool nv::lua::table_guard::is_number( string_ref element )
+{
+        lua_getfield( m_state, -1, element.data() );
         bool result = lua_type( m_state, -1 ) == LUA_TNUMBER;
         lua_pop( m_state, 1 );
@@ -253 +252 @@
 }
 
-bool nv::lua::table_guard::is_boolean( const std::string& element )
-{
-        lua_getfield( m_state, -1, element.c_str() );
+bool nv::lua::table_guard::is_boolean( string_ref element )
+{
+        lua_getfield( m_state, -1, element.data() );
         bool result = lua_type( m_state, -1 ) == LUA_TBOOLEAN;
         lua_pop( m_state, 1 );
@@ -261 +260 @@
 }
 
-bool nv::lua::table_guard::is_string( const std::string& element )
-{
-        lua_getfield( m_state, -1, element.c_str() );
+bool nv::lua::table_guard::is_string( string_ref element )
+{
+        lua_getfield( m_state, -1, element.data() );
         bool result = lua_type( m_state, -1 ) == LUA_TSTRING;
         lua_pop( m_state, 1 );
@@ -321 +320 @@
 }
 
-int lua::state::load_string( const std::string& code, const std::string& name )
+int lua::state::load_string( string_ref code, string_ref name )
 {
         NV_LOG( nv::LOG_TRACE, "Loading Lua string '" << name << "'");
-        return luaL_loadbuffer( m_state, code.c_str(), code.length(), name.c_str() );
-}
-
-int lua::state::load_stream( std::istream& stream, const std::string& name )
+        return luaL_loadbuffer( m_state, code.data(), code.length(), name.data() );
+}
+
+int lua::state::load_stream( std::istream& stream, string_ref name )
 {
         NV_LOG( nv::LOG_NOTICE, "Loading Lua stream '" << name << "'");
@@ -335 +334 @@
 }
 
-int lua::state::load_file( const std::string& filename )
+int lua::state::load_file( string_ref filename )
 {
         NV_LOG( nv::LOG_NOTICE, "Loading Lua file '" << filename << "'");
-        return luaL_loadfile( m_state, filename.c_str() );
-}
-
-bool lua::state::do_string( const std::string& code, const std::string& name, int rvalues )
+        return luaL_loadfile( m_state, filename.data() );
+}
+
+bool lua::state::do_string( string_ref code, string_ref name, int rvalues )
 {
         lua::stack_guard( this );
@@ -353 +352 @@
 }
 
-bool lua::state::do_stream( std::istream& stream, const std::string& name )
+bool lua::state::do_stream( std::istream& stream, string_ref name )
 {
         lua::stack_guard( this );
@@ -365 +364 @@
 }
 
-bool lua::state::do_file( const std::string& filename )
+bool lua::state::do_file( string_ref filename )
 {
         lua::stack_guard( this );
@@ -377 +376 @@
 }
 
-int lua::state::do_current( const std::string& name, int rvalues )
+int lua::state::do_current( string_ref name, int rvalues )
 {
         int result = lua_pcall(m_state, 0, rvalues, 0);
@@ -408 +407 @@
 }
 
-lua::ref lua::state::register_object( void* o, const char* lua_name )
+lua::ref lua::state::register_object( void* o, string_ref lua_name )
 {
         if ( o == nullptr ) return lua::ref( lua::ref::none );
         stack_guard guard( this );
-        lua_getglobal( m_state, lua_name );
+        lua_getglobal( m_state, lua_name.data() );
         if ( lua_isnil( m_state, -1 ) )
         {
-                NV_THROW( runtime_error, std::string( lua_name ) + " type not registered!" );
+                NV_THROW( runtime_error, lua_name.to_string() + " type not registered!" );
         }
         deep_pointer_copy( -1, o );
@@ -421 +420 @@
 }
 
-lua::ref lua::state::register_proto( const char* id, const char* storage )
+lua::ref lua::state::register_proto( string_ref id, string_ref storage )
 {
         stack_guard guard( this );
-        lua_getglobal( m_state, storage );
+        lua_getglobal( m_state, storage.data() );
         if ( lua_isnil( m_state, -1 ) )
         {
-                NV_THROW( runtime_error, std::string( storage ) + " storage not registered!" );
-        }
-        lua_getfield( m_state, -1, id );
+                NV_THROW( runtime_error, storage.to_string() + " storage not registered!" );
+        }
+        lua_getfield( m_state, -1, id.data() );
         if ( lua_isnil( m_state, -1 ) )
         {
-                NV_THROW( runtime_error, std::string( id ) + " not found in " + std::string( storage ) + " storage!" );
+                NV_THROW( runtime_error, id.to_string() + " not found in " + storage.to_string() + " storage!" );
         }
         return lua::ref( luaL_ref( m_state, LUA_REGISTRYINDEX ) );
 }
 
-void lua::state::register_native_object_method( const char* lua_name, const char* name, lfunction f )
+void lua::state::register_native_object_method( string_ref lua_name, string_ref name, lfunction f )
 {
         stack_guard guard( this );
-        lua_getglobal( m_state, lua_name );
+        lua_getglobal( m_state, lua_name.data() );
         if ( lua_isnil( m_state, -1 ) )
         {
-                NV_THROW( runtime_error, std::string( lua_name ) + " type not registered!" );
+                NV_THROW( runtime_error, lua_name.to_string() + " type not registered!" );
         }
         lua_pushcfunction( m_state, f );
-        lua_setfield( m_state, -2, name );
+        lua_setfield( m_state, -2, name.data() );
 }
 
@@ -454 +453 @@
         stack_guard guard( this );
         lua_rawgeti( m_state, LUA_REGISTRYINDEX, object_index.get() );
-        lua_pushstring( m_state, "__ptr" );
+        lua_pushliteral( m_state, "__ptr" );
         lua_pushboolean( m_state, false );
         lua_rawset( m_state, -3 );
@@ -499 +498 @@
 }
 
-void nv::lua::state::store_metadata( ref object_index, const std::string& metaname, void* pointer )
+void nv::lua::state::store_metadata( ref object_index, string_ref metaname, void* pointer )
 {
         if ( !object_index.is_valid() ) return;
         lua_rawgeti( m_state, LUA_REGISTRYINDEX, object_index.get() );
-        lua_pushstring( m_state, metaname.c_str() );
+        lua_pushlstring( m_state, metaname.data(), metaname.size() );
         lua_pushlightuserdata( m_state, pointer );
         lua_rawset( m_state, -3 );
@@ -509 +508 @@
 }
 
-void nv::lua::state::register_enum( const char* name, int value )
+void nv::lua::state::register_enum( string_ref name, int value )
 {
         lua_pushinteger( m_state, value );
-        lua_setglobal( m_state, name );
-}
-
-nv::lua::ref nv::lua::state::register_handle_component_impl( const std::string& id, bool empty )
+        lua_setglobal( m_state, name.data() );
+}
+
+nv::lua::ref nv::lua::state::register_handle_component_impl( string_ref id, bool empty )
 {
         int args = empty ? 1 : 2;
@@ -529 +528 @@
         else
                 nlua_deepcopy( m_state, -2 );
-        lua_pushstring( m_state, id.c_str() );
+        lua_pushlstring( m_state, id.data(), id.size() );
         lua_pushvalue( m_state, -2 );
         lua_rawset( m_state, -4 );
@@ -538 +537 @@
 }
 
-void nv::lua::state::unregister_handle_component_impl( const std::string& id )
+void nv::lua::state::unregister_handle_component_impl( string_ref id )
 {
         NV_LUA_STACK_ASSERT( m_state, -1 );
@@ -547 +546 @@
                 return;
         }
-        lua_pushstring( m_state, id.c_str() );
+        lua_pushlstring( m_state, id.data(), id.size() );
         lua_pushnil( m_state );
         lua_rawset( m_state, -3 );
@@ -553 +552 @@
 }
 
-void nv::lua::state::register_singleton( const char* name, void* o )
+void nv::lua::state::register_singleton( string_ref name, void* o )
 {
         if ( o == nullptr ) return;
         stack_guard guard( this );
-        lua_getglobal( m_state, name );
+        lua_getglobal( m_state, name.data() );
         if ( lua_isnil( m_state, -1 ) )
         {
-                NV_THROW( runtime_error, std::string( name ) + " type not registered!" );
+                NV_THROW( runtime_error, name.to_string() + " type not registered!" );
         }
         deep_pointer_copy( -1, o );
-        lua_setglobal( m_state, name );
-}
-
+        lua_setglobal( m_state, name.data() );
+}
+

trunk/src/lua/lua_values.cc

@@ -191 +191 @@
         if ( lua_istable( L , index ) )
         {
-                lua_pushstring( L, "__ptr" );
+                lua_pushliteral( L, "__ptr" );
                 lua_rawget( L, index );
                 if ( lua_isuserdata( L, -1 ) )