src/services/lua/structboxing.h

   1 /*
   2     Fail game engine
   3     Copyright 2007 Antoine Chavasse <a.chavasse@gmail.com>
   4
   5     This file is part of Fail.
   6
   7     Fail is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License version 3
   9     as published by the Free Software Foundation.
  10
  11     Fail is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19 #ifndef FAIL_LUA_STRUCTBOXING_H
  20 #define FAIL_LUA_STRUCTBOXING_H
  21
  22 namespace fail { namespace LuaImpl
  23 {
  24         template< class S > struct StructRefWrapper
  25         {
  26                 StructRefWrapper( const GenericPointer& pOwner_, S* pStruct_ )  :
  27                         pOwner( pOwner_ ),
  28                         pStruct( pStruct_ )
  29                 {
  30                 }
  31
  32                 GenericPointer  pOwner;
  33                 S*                              pStruct;
  34         };
  35
  36         template< class C > struct StructRefFinalizer
  37         {
  38                 static int Finalize( lua_State* pLS )
  39                 {
  40                         void* pData = lua_touserdata( pLS, 1 );
  41                         StructRefWrapper< C >* pWrapper =
  42                                 static_cast< StructRefWrapper< C >* >( pData );
  43                         pWrapper->~StructRefWrapper< C >();
  44                         return 0;
  45                 }
  46         };
  47
  48         template< class C > struct StructValFinalizer
  49         {
  50                 static int Finalize( lua_State* pLS )
  51                 {
  52                         void* pData = lua_touserdata( pLS, 1 );
  53                         C* pObj = static_cast< C* >( pData );
  54                         pObj->~C();
  55                         return 0;
  56                 }
  57         };
  58
  59         template< class C, e_CheckingPolicy Checking >
  60         struct TypeConverter< StructType, C*, Checking >
  61         {
  62                 TypeConverter( lua_State* pLS_ ) :
  63                         m_pLS( pLS_ ),
  64                         m_bByRef( true )
  65                 {
  66                 }
  67
  68                 bool CheckType( int Index_ )
  69                 {
  70                         if( lua_type( m_pLS, Index_ ) != LUA_TUSERDATA )
  71                         {
  72                                 // TODO: better error reporting
  73                                 TypeCheckHelpers< Checking >::ThrowTypeMismatch();
  74                                 return false;
  75                         }
  76
  77                         if( !lua_getmetatable( m_pLS, Index_ ) )
  78                         {
  79                                 TypeCheckHelpers< Checking >::ThrowTypeMismatch();
  80                                 return false;
  81                         }
  82
  83                         // Check if it's a struct wrapped by reference
  84                         lua_pushlightuserdata( m_pLS, &type_tag< C* >::dummy );
  85                         lua_gettable( m_pLS, LUA_REGISTRYINDEX );
  86
  87                         bool bRes = lua_rawequal( m_pLS, -1, -2 );
  88                         if( bRes )
  89                         {
  90                                 lua_pop( m_pLS, 2 );
  91                                 return true;
  92                         }
  93
  94                         lua_pop( m_pLS, 1 );
  95
  96                         // Check if it's a struct wrapped by value
  97                         lua_pushlightuserdata( m_pLS, &type_tag< C& >::dummy );
  98                         lua_gettable( m_pLS, LUA_REGISTRYINDEX );
  99
 100                         bRes = lua_rawequal( m_pLS, -1, -2 );
 101                         lua_pop( m_pLS, 2 );
 102                         if( bRes )
 103                         {
 104                                 m_bByRef = false;
 105                                 return true;
 106                         }
 107
 108                         TypeCheckHelpers< Checking >::ThrowTypeMismatch();
 109                         return false;
 110                 }
 111
 112                 bool ConvertFromLua( int Index_, C*& pDest_ )
 113                 {
 114                         // Workaround for a warning occuring because the compiler apparently
 115                         // fails to detect that when using a typeconverter with cp_Throw,
 116                         // any code path not setting Dest_ throws
 117                         pDest_ = 0;
 118
 119                         if( !CheckType( Index_ ) )
 120                                 return false;
 121
 122                         if( m_bByRef )
 123                         {
 124                                 StructRefWrapper< C >* pWrapper =
 125                                         static_cast< StructRefWrapper< C >* >( lua_touserdata( m_pLS, Index_ ) );
 126                                 pDest_ = pWrapper->pStruct;
 127                         }
 128                         else
 129                                 pDest_ = static_cast< C* >( lua_touserdata( m_pLS, Index_ ) );
 130
 131                         return true;
 132                 }
 133
 134                 lua_State*      m_pLS;
 135                 bool            m_bByRef;
 136         };
 137
 138         template< class C >
 139         struct TypeConverter< StructType, C*, cp_NoCheck >
 140         {
 141                 TypeConverter( lua_State* pLS_ ) :
 142                         m_pLS( pLS_ ),
 143                         m_bByRef( true )
 144                 {
 145                 }
 146
 147                 bool CheckType( int Index_ )
 148                 {
 149                         return true;
 150                 }
 151
 152                 bool ConvertFromLua( int Index_, C*& pDest_ )
 153                 {
 154                         lua_getmetatable( m_pLS, Index_ );
 155
 156                         // Check if it's a struct wrapped by reference
 157                         lua_pushlightuserdata( m_pLS, &type_tag< C* >::dummy );
 158                         lua_gettable( m_pLS, LUA_REGISTRYINDEX );
 159
 160                         m_bByRef = lua_rawequal( m_pLS, -1, -2 );
 161                         lua_pop( m_pLS, 2 );
 162
 163                         if( m_bByRef )
 164                         {
 165                                 m_pWrapper = static_cast< StructRefWrapper< C >* >( lua_touserdata( m_pLS, Index_ ) );
 166                                 pDest_ = m_pWrapper->pStruct;
 167                         }
 168                         else
 169                                 pDest_ = static_cast< C* >( lua_touserdata( m_pLS, Index_ ) );
 170
 171                         return true;
 172                 }
 173
 174                 lua_State*      m_pLS;
 175                 bool            m_bByRef;
 176                 StructRefWrapper< C >* m_pWrapper;
 177         };
 178
 179         template< class C, e_CheckingPolicy Checking >
 180         struct TypeConverter< StructType, C, Checking >
 181         {
 182                 TypeConverter( lua_State* pLS_ ) :
 183                         m_pLS( pLS_ ),
 184                         m_bByRef( true )
 185                 {
 186                 }
 187
 188                 bool CheckType( int Index_ )
 189                 {
 190                         if( lua_type( m_pLS, Index_ ) != LUA_TUSERDATA )
 191                         {
 192                                 // TODO: better error reporting
 193                                 TypeCheckHelpers< Checking >::ThrowTypeMismatch();
 194                                 return false;
 195                         }
 196
 197                         if( !lua_getmetatable( m_pLS, Index_ ) )
 198                         {
 199                                 TypeCheckHelpers< Checking >::ThrowTypeMismatch();
 200                                 return false;
 201                         }
 202
 203                         // Check if it's a struct wrapped by reference
 204                         lua_pushlightuserdata( m_pLS, &type_tag< C* >::dummy );
 205                         lua_gettable( m_pLS, LUA_REGISTRYINDEX );
 206
 207                         bool bRes = lua_rawequal( m_pLS, -1, -2 );
 208                         if( bRes )
 209                         {
 210                                 lua_pop( m_pLS, 2 );
 211                                 return true;
 212                         }
 213
 214                         lua_pop( m_pLS, 1 );
 215
 216                         // Check if it's a struct wrapped by value
 217                         lua_pushlightuserdata( m_pLS, &type_tag< C& >::dummy );
 218                         lua_gettable( m_pLS, LUA_REGISTRYINDEX );
 219
 220                         bRes = lua_rawequal( m_pLS, -1, -2 );
 221                         lua_pop( m_pLS, 2 );
 222                         if( bRes )
 223                         {
 224                                 m_bByRef = false;
 225                                 return true;
 226                         }
 227
 228                         TypeCheckHelpers< Checking >::ThrowTypeMismatch();
 229                         return false;
 230                 }
 231
 232                 bool ConvertFromLua( int Index_, C& Dest_ )
 233                 {
 234                         if( !CheckType( Index_ ) )
 235                                 return false;
 236
 237                         if( m_bByRef )
 238                         {
 239                                 StructRefWrapper< C >* pWrapper =
 240                                         static_cast< StructRefWrapper< C >* >( lua_touserdata( m_pLS, Index_ ) );
 241                                 Dest_ = *pWrapper->pStruct;
 242                         }
 243                         else
 244                                 Dest_ = *static_cast< C* >( lua_touserdata( m_pLS, Index_ ) );
 245
 246                         return true;
 247                 }
 248
 249                 void ConvertToLua( const C& Obj_ ) const
 250                 {
 251                         void* pData = lua_newuserdata( m_pLS, sizeof( C ) );
 252                         if( !pData )
 253                                 throw std::bad_alloc();
 254
 255                         new( pData ) C( Obj_ );
 256
 257                         lua_pushlightuserdata( m_pLS, &type_tag< C& >::dummy );
 258                         lua_gettable( m_pLS, LUA_REGISTRYINDEX );
 259
 260                         lua_setmetatable( m_pLS, -2 );
 261                 }
 262
 263                 void ConvertToLuaByRef( GenericPointer pOwner_, C& Obj_ ) const
 264                 {
 265                         void* pData = lua_newuserdata( m_pLS, sizeof( StructRefWrapper< C > ) );
 266                         if( !pData )
 267                                 throw std::bad_alloc();
 268
 269                         new( pData ) StructRefWrapper< C >( pOwner_, &Obj_ );
 270
 271                         lua_pushlightuserdata( m_pLS, &type_tag< C* >::dummy );
 272                         lua_gettable( m_pLS, LUA_REGISTRYINDEX );
 273
 274                         lua_setmetatable( m_pLS, -2 );
 275                 }
 276
 277                 lua_State*      m_pLS;
 278                 bool            m_bByRef;
 279         };
 280
 281         template< class C >
 282         struct TypeConverter< StructType, C, cp_NoCheck >
 283         {
 284                 TypeConverter( lua_State* pLS_ ) :
 285                         m_pLS( pLS_ )
 286                 {
 287                 }
 288
 289                 bool CheckType( int Index_ )
 290                 {
 291                         return true;
 292                 }
 293
 294                 bool ConvertFromLua( int Index_, C& Dest_ )
 295                 {
 296                         lua_getmetatable( m_pLS, Index_ );
 297
 298                         // Check if it's a struct wrapped by reference
 299                         lua_pushlightuserdata( m_pLS, &type_tag< C* >::dummy );
 300                         lua_gettable( m_pLS, LUA_REGISTRYINDEX );
 301
 302                         bool bRes = lua_rawequal( m_pLS, -1, -2 );
 303                         lua_pop( m_pLS, 2 );
 304
 305                         if( bRes )
 306                         {
 307                                 StructRefWrapper< C >* pWrapper =
 308                                         static_cast< StructRefWrapper< C >* >( lua_touserdata( m_pLS, Index_ ) );
 309                                 Dest_ = *pWrapper->pStruct;
 310                         }
 311                         else
 312                                 Dest_ = *static_cast< C* >( lua_touserdata( m_pLS, Index_ ) );
 313
 314                         return true;
 315                 }
 316
 317                 lua_State*      m_pLS;
 318         };
 319 }}
 320
 321 #endif