Changeset 162

Timestamp:

07/15/13 20:13:27 (12 years ago)

Author:

epyon

Message:

• flags - flags support, essentially a std::bitset implementation with .data() method and enum class support

Location:

trunk

Files:

• nv/array2d.hh (modified) (1 diff)
• nv/flags.hh (added)
• nv/lua/lua_raw.hh (modified) (1 diff)
• nv/lua/lua_state.hh (modified) (2 diffs)
• src/lua/lua_raw.cc (modified) (1 diff)
• src/lua/lua_state.cc (modified) (1 diff)

trunk/nv/array2d.hh

@@ -184 +184 @@
                 inline reference operator[] ( const ivec2& c )
                 {
-                        NV_ASSERT( x >= 0 && y >= 0 && x < m_size.x && y < m_size.y, "Bad parameters passed to array2d[]" );
+                        NV_ASSERT( c.x >= 0 && c.y >= 0 && c.x < m_size.x && c.y < m_size.y, "Bad parameters passed to array2d[]" );
                         return m_data[ c.y * m_size.x + c.x ];
                 }

trunk/nv/lua/lua_raw.hh

@@ -11 +11 @@
 #include <istream>
 #include <string>
-#include <bitset>
 #include <map>
+
+void nlua_toflags_flat( lua_State *L, int index, nv::uint8* data, nv::uint32 count );
+void nlua_toflags_array( lua_State *L, int index, nv::uint8* data, nv::uint32 count );
+void nlua_toflags( lua_State *L, int index, nv::uint8* data, nv::uint32 count );
 
 std::string nlua_typecontent( lua_State* L, int idx );

trunk/nv/lua/lua_state.hh

@@ -11 +11 @@
 #include <map>
 #include <nv/common.hh>
+#include <nv/flags.hh>
 #include <string>
 
@@ -52 +53 @@
                         double get_double( const std::string& element, double defval = 0.0 );
                         bool get_boolean( const std::string& element, bool defval = false );
-                public:
+
+                        template< uint32 SIZE, typename T >
+                        flags< SIZE, T > get_flags( const std::string& element )
+                        {
+                                flags< SIZE, T > result;
+                                get_raw_flags( element, result.data(), result.size() );
+                                return result;
+                        }
+
+                        template< uint32 SIZE, typename T >
+                        void load_flags( const std::string& element, flags< SIZE, T >& flags )
+                        {
+                                get_raw_flags( element, flags.data(), flags.size() );
+                        }
+                private:
+                        void get_raw_flags( const std::string& element, uint8* data, uint32 count );
+
                         state* L;
                         stack_guard m_guard;

trunk/src/lua/lua_raw.cc

@@ -188 +188 @@
         lua_pop( L, 1 );
 }
+
+void nlua_toflags( lua_State *L, int index, nv::uint8* data, nv::uint32 count )
+{
+        index = lua_absindex( L, index );
+        nv::uint32 flag;
+        if ( lua_istable( L, index ) )
+        {
+                lua_pushnil( L );
+                while ( lua_next( L, index ) != 0 )
+                {
+                        if ( lua_type( L, -1 ) == LUA_TBOOLEAN )
+                                flag = static_cast< nv::uint32 >( lua_tointeger( L ,-2 ) );
+                        else
+                                flag = static_cast< nv::uint32 >( lua_tointeger( L ,-1 ) );
+                        lua_pop( L, 1 );
+                        if ( flag < count )
+                        {
+                                data[ flag / 8 ] |= ( 1 << static_cast< nv::uint8 >( flag % 8 ) );
+                        }
+                }
+        }
+}
+
+void nlua_toflags_set( lua_State *L, int index, nv::uint8* data, nv::uint32 count )
+{
+        index = lua_absindex( L, index );
+        nv::uint32 flag;
+        if ( lua_istable( L, index ) )
+        {
+                lua_pushnil( L );
+                while ( lua_next( L, index ) != 0 )
+                {
+                        flag = static_cast< nv::uint32 >( lua_tointeger( L ,-2 ) );
+                        lua_pop( L, 1 );
+                        if ( flag < count )
+                        {
+                                data[ flag / 8 ] |= ( 1 << static_cast< nv::uint8 >( flag % 8 ) );
+                        }
+                }
+        }
+}
+
+void nlua_toflags_array( lua_State *L, int index, nv::uint8* data, nv::uint32 count )
+{
+        index = lua_absindex( L, index );
+        nv::uint32 flag;
+        if ( lua_istable( L, index ) )
+        {
+                lua_pushnil( L );
+                while ( lua_next( L, index ) != 0 )
+                {
+                        flag = static_cast< nv::uint32 >( lua_tointeger( L ,-1 ) );
+                        lua_pop( L, 1 );
+                        if ( flag < count )
+                        {
+                                data[ flag / 8 ] |= ( 1 << static_cast< nv::uint8 >( flag % 8 ) );
+                        }
+                }
+        }
+}

trunk/src/lua/lua_state.cc

@@ -279 +279 @@
 }
 
+void lua::table_guard::get_raw_flags( const std::string& element, uint8* data, uint32 count )
+{
+        lua_getfield( L->L, -1, element.c_str() );
+        if ( lua_type( L->L, -1 ) != LUA_TTABLE )
+        {
+                lua_pop( L->L, 1 );
+                return;
+        }
+        nlua_toflags( L->L, -1, data, count );
+        lua_pop( L->L, 1 );
+}
+
+
 void lua::state::log_stack()
 {