Changeset 442 for trunk

Timestamp:

07/24/15 12:52:05 (10 years ago)

Author:

epyon

Message:

• more std removal - only <random> left

Location:

trunk

Files:

• legacy/std_stream.cc (moved) (moved from trunk/src/io/std_stream.cc)
• legacy/std_stream.hh (moved) (moved from trunk/nv/io/std_stream.hh)
• nv/base/capi.hh (modified) (6 diffs)
• nv/gui/gui_element.hh (modified) (1 diff)
• nv/io/c_stream.hh (modified) (1 diff)
• nv/stl/algorithm.hh (modified) (2 diffs)
• nv/stl/stream.hh (modified) (1 diff)
• nv/stl/string/short_string.hh (modified) (1 diff)
• nv/stl/string/string_base.hh (modified) (2 diffs)
• src/formats/nmd_loader.cc (modified) (1 diff)
• src/formats/obj_loader.cc (modified) (8 diffs)
• src/io/c_stream.cc (modified) (1 diff)
• src/stl/string.cc (modified) (1 diff)

trunk/nv/base/capi.hh

@@ -102 +102 @@
         inline void* nvmemcpy( void *dest, const void *src, size_t count )
         {
+                NV_ASSERT( dest && src, "Bad parameter to nvmemcpy!" );
                 if ( dest == src ) return dest;
                 return NV_CAPI_CALL( memcpy )( dest, src, count );
@@ -108 +109 @@
         inline void* nvmemmove( void *dest, const void *src, size_t count )
         {
+                NV_ASSERT( dest && src, "Bad parameter to nvmemmove!" );
                 if ( dest == src ) return dest;
                 return NV_CAPI_CALL( memmove )( dest, src, count );
@@ -114 +116 @@
         inline void* nvmemset( void *dest, unsigned char value, size_t count )
         {
+                NV_ASSERT( dest, "Bad parameter to nvmemset!" );
                 return NV_CAPI_CALL( memset )( dest, static_cast<int>( value ), count );
         }
@@ -119 +122 @@
         inline void* nvmemchr( const void *src, unsigned char value, size_t max_count )
         {
+                NV_ASSERT( src, "Bad parameter to nvmemchr!" );
                 return NV_CAPI_CALL( memchr )( src, static_cast<int>( value ), max_count );
         }
@@ -124 +128 @@
         inline int nvmemcmp( const void * m1, const void * m2, nv::size_t max_count )
         {
+                NV_ASSERT( m1 && m2, "Bad parameter to nvmemcmp!" );
                 return NV_CAPI_CALL( memcmp )( m1, m2, max_count );
         }
@@ -129 +134 @@
         inline int nvstrcmp( const char * s1, const char * s2 )
         {
+                NV_ASSERT( s1 && s2, "Bad parameter to nvstrcmp!" );
                 return NV_CAPI_CALL( strcmp )( s1, s2 );
         }       

trunk/nv/gui/gui_element.hh

@@ -19 +19 @@
 #include <nv/stl/string.hh>
 #include <nv/gui/gui_common.hh>
-#include <list>
 
 namespace nv

trunk/nv/io/c_stream.hh

@@ -32 +32 @@
                 virtual size_t read( void* buffer, size_t size, size_t count );
                 virtual size_t write( const void* buffer, size_t size, size_t count );
+                virtual bool gets( char* buffer, size_t max_count );
                 virtual bool seek( long offset, origin orig );
                 virtual size_t tell();

trunk/nv/stl/algorithm.hh

@@ -63 +63 @@
                         for ( ForwardIterator it = first2; it != last2; ++it )
                                 if ( *first1 == *it )
-                                        break;
+                                        return ( first1 );
                 return ( first1 );
         }
@@ -73 +73 @@
                         for ( ForwardIterator it = first2; it != last2; ++it )
                                 if ( comp_op( *first1, *it ) )
-                                        break;
+                                        return ( first1 );
                 return ( first1 );
         }

trunk/nv/stl/stream.hh

@@ -34 +34 @@
                 virtual size_t read( void* buffer, size_t size, size_t count ) = 0;
                 virtual size_t write( const void* buffer, size_t size, size_t count ) = 0;
+                virtual bool gets( char* buffer, size_t max_count ) = 0;
                 virtual bool seek( long offset, origin orig ) = 0;
                 virtual size_t tell() = 0;

trunk/nv/stl/string/short_string.hh

@@ -59 +59 @@
                 size_t append( const char* data, size_t sz )
                 {
+                        if ( !data ) return 0;
                         size_t pos    = size();
                         size_t amount = expand_by( sz );

trunk/nv/stl/string/string_base.hh

@@ -74 +74 @@
                 // string operations
                 string_view substr( size_type p, size_type n = npos ) const;
+                string_view without_prefix( size_type p ) const;
+                string_view without_suffix( size_type p ) const;
 
                 template < typename H = size_type >
@@ -278 +280 @@
                 return string_view( this->data() + p, n );
         }
+
+        template < typename Storage >
+        inline string_view string_base< Storage >::without_prefix( size_type p ) const
+        {
+                string_view result( this->data(), this->size() );
+                result.remove_prefix( p );
+                return result;
+        }
+
+        template < typename Storage >
+        inline string_view string_base< Storage >::without_suffix( size_type p ) const
+        {
+                string_view result( this->data(), this->size() );
+                result.remove_suffix( p );
+                return result;
+        }
+
 
 #define NV_STRING_BASE_CAST_OPERATORS( OPERATOR )\

trunk/src/formats/nmd_loader.cc

@@ -6 +6 @@
 
 #include "nv/formats/nmd_loader.hh"
-#include "nv/io/std_stream.hh"
 #include "nv/stl/string.hh"
 #include "nv/interface/data_channel_access.hh"

trunk/src/formats/obj_loader.cc

@@ -6 +6 @@
 
 #include "nv/formats/obj_loader.hh"
-#include "nv/io/std_stream.hh"
 #include "nv/interface/data_channel_access.hh"
 
-#include <sstream>
+#include <cstdio>
 
 using namespace nv;
@@ -50 +49 @@
         vector< vec2 > t;
 
-        std::string line;
-        std::string cmd;
-        std::string name;
-        std::string next_name;
+        string32 name;
+        string32 next_name;
 
         nv::size_t size;
@@ -59 +56 @@
 
         obj_reader();
-        bool read_stream( std::istream& stream );
+        bool read_stream( stream& str );
         virtual nv::size_t add_face( uint32* vi, uint32* ti, uint32* ni, nv::size_t count ) = 0;
         virtual nv::size_t raw_size() const = 0;
@@ -79 +76 @@
 }
 
-bool obj_reader::read_stream( std::istream& stream )
-{
-        name = next_name;
+bool obj_reader::read_stream( stream& str )
+{
+        name.assign( next_name );
         bool added_faces = false;
         f32 x, y, z;
         if ( eof ) return false;
-
-        while ( std::getline( stream, line ) )
-        {
-                if ( line.length() < 3 || line[0] == '#' )
-                {
-                        continue;
-                }
-
-                std::istringstream ss(line);
-                ss >> cmd;
-
-                if ( cmd == "v" )
-                {
-                        ss >> x >> y >> z;
+        char buffer[256];
+        while ( str.gets( buffer, 256 ) )
+        {
+                string_view cline( static_cast<const char*>( buffer ) );
+                cline = nv::trimmed( cline );
+
+                if ( cline.length() < 3 || cline[0] == '#' )
+                {
+                        continue;
+                }
+
+                if ( cline.starts_with( "vn " ) )
+                {
+                        sscanf( cline.data(), "vn %f %f %f", &x, &y, &z );
+                        n.push_back( vec3( x, y, z ) );
+                        continue;
+                }
+
+                if ( cline.starts_with( "vt " ) )
+                {
+                        sscanf( cline.data(), "vt %f %f", &x, &y );
+                        t.push_back( vec2( x, 1.0f - y ) );
+                        continue;
+                }
+
+                if ( cline.starts_with( "v " ) )
+                {
+                        sscanf( cline.data(), "v %f %f %f", &x, &y, &z );
                         v.push_back( vec3( x, y, z ) );
                         continue;
                 }
 
-                if ( cmd == "vn" )
-                {
-                        ss >> x >> y >> z;
-                        n.push_back( vec3( x, y, z ) );
-                        continue;
-                }
-
-                if ( cmd == "vt" )
-                {
-                        ss >> x >> y;
-                        t.push_back( vec2( x, 1.0f - y ) );
-                        continue;
-                }
-
-                if ( cmd == "f" )
+                if ( cline.starts_with( "f " ) )
                 {
                         added_faces = true;
-                        ss >> cmd;
 
                         uint32 vis[8];
@@ -128 +124 @@
                         uint32 count = 0;
 
-                        while ( !ss.fail() )
+                        string_view scan( cline );
+                        scan.remove_prefix( 2 );
+                        size_t pos = 0;
+                        while ( pos != string_view::npos )
                         {
-                                char ch;
-
-                                std::istringstream ss2( cmd );
-                                ss2 >> vis[count] >> ch;
-                                ss2 >> tis[count] >> ch;
-                                if ( ch == '/')
+                                scan.remove_prefix( pos );
+                                scan = nv::trimmed( scan );
+                                if ( sscanf( scan.data(), "%u/%u/%u", &vis[count], &tis[count], &nis[count] ) == 3 )
                                 {
                                         normals = true;
-                                        ss2 >> nis[count];
                                 }
-
-                                ss >> cmd;
+                                else if ( !normals && sscanf( scan.data(), "%u/%u", &vis[count], &tis[count] ) == 2 )
+                                {
+
+                                }
+                                else
+                                {
+                                        break;
+                                }
                                 count++;
+                                pos = scan.find_first_of( "\t " );
                         }
 
@@ -149 +151 @@
                 }
 
-                if ( cmd == "g" )
-                {
-                        ss >> next_name;
+                if ( cline.starts_with( "g " ) )
+                {
+                        next_name.assign( nv::trimmed( cline.without_prefix( 2 ) ) );
                         if (added_faces) 
                                 return true;
-                        name = next_name;
-                        continue;
-                }
-
-                if ( cmd == "s" )
+                        name.assign( next_name );
+                        continue;
+                }
+
+                if ( cline.starts_with( "s " ) )
                 {
                         continue;
@@ -317 +319 @@
         else
                 reader = new mesh_data_reader_vt();
-        std_stream sstream( &source );
-
-        while ( reader->read_stream( sstream ) )
+        while ( reader->read_stream( source ) )
         {
                 if ( m_tangents )
@@ -328 +328 @@
                 data_channel_set* result = data_channel_set_creator::create_set( 1 );
                 data_channel_set_creator raccess( result );
-                raccess.set_name( make_name( reader->name.c_str() ) );
+                raccess.set_name( make_name( reader->name ) );
                 uint8* rdata = raccess.add_channel( m_descriptor, reader->size * 3 ).raw_data();
 

trunk/src/io/c_stream.cc

@@ -47 +47 @@
 }
 
+bool c_stream::gets( char* buffer, size_t max_count )
+{
+        NV_ASSERT( buffer != nullptr && max_count != 0, "Bad parameter passed to write!" );
+        char* result = ::fgets( buffer, max_count, reinterpret_cast<FILE*>( m_file ) );
+        if ( !result ) return false;
+        return true;
+}
+
 bool c_stream::seek( long offset, origin orig )
 {

trunk/src/stl/string.cc

@@ -11 +11 @@
 #include <cstdio>
 #include <cstdlib>
-#include <fstream> // for slurp only
-#include <sstream> // for slurp only
 
 using namespace nv;