lua/basic_types.h

   1 #ifndef AWFUL_LUA_BASIC_TYPES_H
   2 #define AWFUL_LUA_BASIC_TYPES_H
   3
   4 namespace awful { namespace LuaImpl
   5 {
   6         template< typename category, typename T > struct TypeConverter
   7         {
   8         };
   9
  10         template< typename T > struct NumericTypeConverter
  11         {
  12                 NumericTypeConverter( lua_State* pLS_ ) :
  13                         m_pLS( pLS_ )
  14                 {
  15                 }
  16
  17                 bool CheckType_nothrow( int Index_ )
  18                 {
  19                         return LuaImpl::CheckType_nothrow( m_pLS, Index_, LUA_TNUMBER );
  20                 }
  21
  22                 void ConvertFromLua_nocheck( int Index_, T& Dest_ )
  23                 {
  24                         Dest_ = static_cast< T >( lua_tonumber( m_pLS, Index_ ) );
  25                 }
  26
  27                 void ConvertFromLua( int Index_, T& Dest_ )
  28                 {
  29                         CheckType( m_pLS, Index_, LUA_TNUMBER );
  30                         ConvertFromLua_nocheck( Index_, Dest_ );
  31                 }
  32
  33                 void ConvertToLua( const T& Value_ )
  34                 {
  35                         lua_pushnumber( m_pLS, static_cast< lua_Number >( Value_ ) );
  36                 }
  37
  38                 lua_State*      m_pLS;
  39         };
  40
  41         template<> struct TypeConverter< NormalType, int32_t > : NumericTypeConverter< int32_t >
  42         {
  43                 TypeConverter( lua_State* pLS_ ) : NumericTypeConverter< int32_t >( pLS_ ) {}
  44         };
  45
  46
  47         template<> struct TypeConverter< NormalType, uint32_t > : NumericTypeConverter< uint32_t >
  48         {
  49                 TypeConverter( lua_State* pLS_ ) : NumericTypeConverter< uint32_t >( pLS_ ) {}
  50         };
  51
  52
  53         template<> struct TypeConverter< NormalType, float > : NumericTypeConverter< float >
  54         {
  55                 TypeConverter( lua_State* pLS_ ) : NumericTypeConverter< float >( pLS_ ) {}
  56         };
  57
  58         // bool
  59         template<> struct TypeConverter< NormalType, bool >
  60         {
  61                 TypeConverter( lua_State* pLS_ ) :
  62                         m_pLS( pLS_ )
  63                 {
  64                 }
  65
  66                 bool CheckType_nothrow( int Index_ )
  67                 {
  68                         return LuaImpl::CheckType_nothrow( m_pLS, Index_, LUA_TBOOLEAN );
  69                 }
  70
  71                 void ConvertFromLua_nocheck( int Index_, bool& Dest_ )
  72                 {
  73                         Dest_ = !!lua_toboolean( m_pLS, Index_ );
  74                 }
  75
  76                 void ConvertFromLua( int Index_, bool& Dest_ )
  77                 {
  78                         CheckType( m_pLS, Index_, LUA_TBOOLEAN );
  79                         ConvertFromLua_nocheck( Index_, Dest_ );
  80                 }
  81
  82                 void ConvertToLua( const bool& Value_ )
  83                 {
  84                         lua_pushboolean( m_pLS, Value_ );
  85                 }
  86
  87                 lua_State*      m_pLS;
  88         };
  89
  90         // string
  91         template<> struct TypeConverter< NormalType, std::string >
  92         {
  93                 TypeConverter( lua_State* pLS_ ) :
  94                         m_pLS( pLS_ )
  95                 {
  96                 }
  97
  98                 bool CheckType_nothrow( int Index_ )
  99                 {
 100                         return LuaImpl::CheckType_nothrow( m_pLS, Index_, LUA_TSTRING );
 101                 }
 102
 103                 void ConvertFromLua_nocheck( int Index_, std::string& Dest_ )
 104                 {
 105                         Dest_ = lua_tostring( m_pLS, Index_ );
 106                 }
 107
 108                 void ConvertFromLua( int Index_, std::string& Dest_ )
 109                 {
 110                         CheckType( m_pLS, Index_, LUA_TSTRING );
 111                         ConvertFromLua_nocheck( Index_, Dest_ );
 112                 }
 113
 114                 void ConvertToLua( const std::string& Value_ )
 115                 {
 116                         lua_pushstring( m_pLS, Value_.c_str() );
 117                 }
 118
 119                 lua_State*      m_pLS;
 120         };
 121
 122         // TODO: all other types
 123 }}
 124
 125 #endif