Changeset 359 for trunk

Timestamp:

04/29/15 18:46:16 (10 years ago)

Author:

epyon

Message:

• rewrite of lua_path: doesn't use dynamic memory anymore variadic constructor and perfect forwarding leverages string_ref general cleanup

Location:

trunk

Files:

• nv/lua/lua_path.hh (modified) (3 diffs)
• src/lua/lua_path.cc (modified) (4 diffs)

trunk/nv/lua/lua_path.hh

@@ -4 +4 @@
 // This file is part of NV Libraries.
 // For conditions of distribution and use, see copyright notice in nv.hh
+//
+// TODO : prepare tests:
+//  * correctness tests
+//  * compatibility tests
+//  * performance tests
+// TODO : resolve should not take a lua_State
 
 #ifndef NV_LUA_PATH_HH
@@ -10 +16 @@
 #include <nv/core/common.hh>
 #include <nv/core/string.hh>
+#include <nv/core/string_ref.hh>
 #include <cstring>
 
@@ -21 +28 @@
                 class path
                 {
-                        struct element 
+                public:
+                        template < typename... Args >
+                        path( Args&&... args ) : m_count(0)
                         {
-                                size_t value;
-                                size_t length;
-                                element() : value( 0 ), length( 0 ) {}
-                        };
-
-
-                public:
-                        path( nv::string p );
-                        path( const char* p );
-                        path( unsigned i );
-
-                        template < typename T1, typename T2 >
-                        path( const T1& p1, const T2& p2 ) : m_count( 0 )
-                        {
-                                const size_t l1 = string_length<T1>::get( p1 );
-                                const size_t l2 = string_length<T2>::get( p2 );
-                                m_path.reserve( l1 + l2 + 1 );
-                                push( p1, l1 );
-                                push( p2, l2 );
-                        }
-
-                        template < typename T1, typename T2, typename T3 >
-                        path( const T1& p1, const T2& p2, const T3& p3 ) : m_count( 0 )
-                        {
-                                const size_t l1 = string_length<T1>::get( p1 );
-                                const size_t l2 = string_length<T2>::get( p2 );
-                                const size_t l3 = string_length<T3>::get( p3 );
-                                m_path.reserve( l1 + l2 + l3 + 1 );
-                                push( p1, l1 );
-                                push( p2, l2 );
-                                push( p3, l3 );
-                        }
-
-                        template < typename T1, typename T2, typename T3, typename T4 >
-                        path( const T1& p1, const T2& p2, const T3& p3, const T4& p4 ) : m_count( 0 )
-                        {
-                                const size_t l1 = string_length<T1>::get( p1 );
-                                const size_t l2 = string_length<T2>::get( p2 );
-                                const size_t l3 = string_length<T3>::get( p3 );
-                                const size_t l4 = string_length<T4>::get( p4 );
-                                m_path.reserve( l1 + l2 + l3 + l4 + 1 );
-                                push( p1, l1 );
-                                push( p2, l2 );
-                                push( p3, l3 );
-                                push( p4, l4 );
-                        }
-
-                        template < typename T1, typename T2, typename T3, typename T4, typename T5 >
-                        path( const T1& p1, const T2& p2, const T3& p3, const T4& p4, const T5& p5 ) : m_count( 0 )
-                        {
-                                const size_t l1 = string_length<T1>::get( p1 );
-                                const size_t l2 = string_length<T2>::get( p2 );
-                                const size_t l3 = string_length<T3>::get( p3 );
-                                const size_t l4 = string_length<T4>::get( p4 );
-                                const size_t l5 = string_length<T5>::get( p5 );
-                                m_path.reserve( l1 + l2 + l3 + l4 + l5 + 1 );
-                                push( p1, l1 );
-                                push( p2, l2 );
-                                push( p3, l3 );
-                                push( p4, l4 );
-                                push( p4, l5 );
+                                static_assert( sizeof...( Args ) < 8, "Path can only take up to 8 arguments!" );
+                                initialize( std::forward<Args>( args )... );
                         }
 
                         std::string to_string() const;
                         bool resolve( lua_State* L, bool global = true ) const;
+                
                 private:
+                        template < typename T >
+                        void initialize( T&& arg ) 
+                        {
+                                push( std::forward<T>( arg ) );
+                                if ( m_count == 1 && m_elements[0].length ) parse();
+                        }
+
+                        template < typename T, typename... Args >
+                        void initialize( T&& arg, Args&&... args )
+                        { 
+                                push( std::forward<T>( arg ) );
+                                initialize( std::forward<Args>( args )... );
+                        }
 
                         void parse();
-                        void push( size_t start, size_t length );
-                        void push( size_t e );
-                        void push( const nv::string& p, size_t lenght );
-                        void push( const char* s, size_t length );
+                        void push( size_t value );
+                        void push( string_ref p );
+
                 private:
-                        element     m_elements[8];
-                        sint32      m_count;
-                        std::string m_path;
+                        struct element
+                        {
+                                union
+                                {
+                                        size_t      value;
+                                        const char* str;
+                                };
+                                size_t      length;
+                        };
+
+                        element m_elements[8];
+                        sint32  m_count;
                 };
 

trunk/src/lua/lua_path.cc

@@ -11 +11 @@
 using namespace nv;
 
-lua::path::path( nv::string p )
-        : m_count(0), m_path( std::move( p ) )
+void lua::path::parse()
 {
-        parse();
+        if ( m_elements[0].length == 0 || m_elements[0].str == nullptr ) return;
+        string_ref spath( m_elements[0].str, m_elements[0].length );
+        m_count = 0;
+        size_t point = spath.find( '.' );
+
+        while ( point != std::string::npos )
+        {
+                m_elements[m_count].str    = spath.data();
+                m_elements[m_count].length = point;
+                m_count++;
+                spath.remove_prefix( point + 1 );
+                point = spath.find( '.' );
+        }
+
+        m_elements[m_count].str    = spath.data();
+        m_elements[m_count].length = spath.length();
+        m_count++;
 }
 
-lua::path::path( const char* p )
-        : m_count(0), m_path( p )
+void lua::path::push( size_t value )
 {
-        parse();
-}
-
-lua::path::path( unsigned i )
-        : m_count(0)
-{
-        push( i );
-}
-
-void lua::path::parse()
-{
-        size_t start = 0;
-        size_t point = m_path.find('.');
-
-        while( point != std::string::npos )
-        {
-                push( start, point-start );
-                start = point+1;
-                point = m_path.find( '.', start );
-        }
-
-        push( start, m_path.length() - start );
-}
-
-void lua::path::push( size_t e )
-{
-        m_elements[ m_count ].value  = e;
+        m_elements[ m_count ].value  = value;
         m_elements[ m_count ].length = 0;
         m_count++;
 }
 
-void lua::path::push( size_t start, size_t length )
+void nv::lua::path::push( string_ref p )
 {
-        m_elements[ m_count ].value  = start;
-        m_elements[ m_count ].length = length;
-        m_count++;
-}
-
-void lua::path::push( const char* p, size_t length )
-{
-        m_elements[ m_count ].value  = m_path.length();
-        m_elements[ m_count ].length = length;
-        m_path.append( p, length );
-        m_count++;
-}
-
-void lua::path::push( const std::string& s, size_t length )
-{
-        m_elements[ m_count ].value  = m_path.length();
-        m_elements[ m_count ].length = length;
-        m_path.append( s, 0, length );
+        m_elements[ m_count ].str    = p.data();
+        m_elements[ m_count ].length = p.length();
         m_count++;
 }
@@ -84 +56 @@
                         if ( m_elements[i].length > 0 )
                         {
-                                lua_pushlstring( L, m_path.c_str() + m_elements[i].value, m_elements[i].length );
+                                lua_pushlstring( L, m_elements[i].str, m_elements[i].length );
                         }
                         else
@@ -105 +77 @@
 {
         std::string result;
-        result.reserve( 2 * m_path.length() );
+        result.reserve( 64 );
         bool dot = false;
         for ( const element& e : m_elements )
@@ -117 +89 @@
                 else
                 {
-                        result.append( m_path, e.value, e.length );
+                        result.append( e.str, e.length );
                         dot = true;
                 }