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 shared_ptr< void >& pOwner_, S* pStruct_ )      :
  27                         pOwner( pOwner_ ),
  28                         pStruct( pStruct_ )
  29                 {
  30                 }
  31
  32                 shared_ptr< void >      pOwner;
  33                 S*                                      pStruct;
  34         };
  35
  36         template< class S > struct StructValWrapper
  37         {
  38                 StructValWrapper( shared_ptr< S >& pStruct_ ) :
  39                         pStruct( pStruct_ )
  40                 {
  41                 }
  42
  43                 shared_ptr< S > pStruct;
  44         };
  45
  46         template< class C > struct StructMetamethods
  47         {
  48                 static int FinalizeRef( lua_State* pLS )
  49                 {
  50                         void* pData = lua_touserdata( pLS, 1 );
  51                         StructRefWrapper< C >* pWrapper =
  52                                 static_cast< StructRefWrapper< C >* >( pData );
  53                         pWrapper->~StructRefWrapper< C >();
  54                         return 0;
  55                 }
  56
  57                 static int FinalizeVal( lua_State* pLS )
  58                 {
  59                         void* pData = lua_touserdata( pLS, 1 );
  60                         StructValWrapper< C >* pWrapper =
  61                                 static_cast< StructValWrapper< C >* >( pData );
  62                         pWrapper->~StructValWrapper< C >();
  63                         return 0;
  64                 }
  65
  66                 static int ToStringRef( lua_State* pLS )
  67                 {
  68                         void* pData = lua_touserdata( pLS, 1 );
  69                         StructRefWrapper< C >* pWrapper =
  70                                 static_cast< StructRefWrapper< C >* >( pData );
  71                         std::stringstream sstr;
  72                         sstr << "[struct " << class_traits< C >::FullName() << " " << pWrapper->pStruct
  73                                 << " (by ref, owner object: " << pWrapper->pOwner << ")]";
  74                         lua_pushstring( pLS, sstr.str().c_str() );
  75                         return 1;
  76                 }
  77
  78                 static int ToStringVal( lua_State* pLS )
  79                 {
  80                         void* pData = lua_touserdata( pLS, 1 );
  81                         StructValWrapper< C >* pWrapper =
  82                                 static_cast< StructValWrapper< C >* >( pData );
  83                         std::stringstream sstr;
  84                         sstr << "[struct " << class_traits< C >::FullName() << " " << pWrapper->pStruct
  85                                 << " (by value)]";
  86                         lua_pushstring( pLS, sstr.str().c_str() );
  87                         return 1;
  88                 }
  89         };
  90
  91         template< class C, e_CheckingPolicy Checking >
  92         struct TypeConverter< C*, Checking, tc_ValueType >
  93         {
  94                 TypeConverter( lua_State* pLS_ ) :
  95                         m_pLS( pLS_ ),
  96                         m_bByRef( true )
  97                 {
  98                 }
  99
 100                 bool CheckType( int Index_ )
 101                 {
 102                         if( lua_type( m_pLS, Index_ ) != LUA_TUSERDATA )
 103                         {
 104                                 // TODO: better error reporting
 105                                 TypeCheckHelpers< Checking >::ThrowTypeMismatch();
 106                                 return false;
 107                         }
 108
 109                         if( !lua_getmetatable( m_pLS, Index_ ) )
 110                         {
 111                                 TypeCheckHelpers< Checking >::ThrowTypeMismatch();
 112                                 return false;
 113                         }
 114
 115                         // Check if it's a struct wrapped by reference
 116                         Registry< C* >::PushMetatable( m_pLS );
 117                         if( lua_rawequal( m_pLS, -1, -2 ) )
 118                         {
 119                                 lua_pop( m_pLS, 2 );
 120                                 return true;
 121                         }
 122
 123                         lua_pop( m_pLS, 1 );
 124
 125                         // Check if it's a struct wrapped by value
 126                         Registry< C& >::PushMetatable( m_pLS );
 127                         bool bRes = lua_rawequal( m_pLS, -1, -2 );
 128                         lua_pop( m_pLS, 2 );
 129                         if( bRes )
 130                         {
 131                                 m_bByRef = false;
 132                                 return true;
 133                         }
 134
 135                         TypeCheckHelpers< Checking >::ThrowTypeMismatch();
 136                         return false;
 137                 }
 138
 139                 bool ConvertFromLua( int Index_, C*& pDest_ )
 140                 {
 141                         // Workaround for a warning occuring because the compiler apparently
 142                         // fails to detect that when using a typeconverter with cp_Throw,
 143                         // any code path not setting Dest_ throws
 144                         pDest_ = 0;
 145
 146                         if( !CheckType( Index_ ) )
 147                                 return false;
 148
 149                         if( m_bByRef )
 150                         {
 151                                 StructRefWrapper< C >* pWrapper =
 152                                         static_cast< StructRefWrapper< C >* >( lua_touserdata( m_pLS, Index_ ) );
 153                                 pDest_ = pWrapper->pStruct;
 154                         }
 155                         else
 156                         {
 157                                 StructValWrapper< C >* pWrapper =
 158                                         static_cast< StructValWrapper< C >* >( lua_touserdata( m_pLS, Index_ ) );
 159                                 pDest_ = pWrapper->pStruct.get();
 160                         }
 161
 162                         //      pDest_ = static_cast< C* >( lua_touserdata( m_pLS, Index_ ) );
 163
 164                         return true;
 165                 }
 166
 167                 lua_State*      m_pLS;
 168                 bool            m_bByRef;
 169         };
 170
 171         template< class C >
 172         struct TypeConverter< C*, cp_NoCheck, tc_ValueType >
 173         {
 174                 TypeConverter( lua_State* pLS_ ) :
 175                         m_pLS( pLS_ ),
 176                         m_bByRef( true )
 177                 {
 178                 }
 179
 180                 bool CheckType( int Index_ )
 181                 {
 182                         return true;
 183                 }
 184
 185                 bool ConvertFromLua( int Index_, C*& pDest_ )
 186                 {
 187                         lua_getmetatable( m_pLS, Index_ );
 188
 189                         // Check if it's a struct wrapped by reference
 190                         Registry< C* >::PushMetatable( m_pLS );
 191                         m_bByRef = lua_rawequal( m_pLS, -1, -2 );
 192                         lua_pop( m_pLS, 2 );
 193
 194                         if( m_bByRef )
 195                         {
 196                                 m_pRefWrapper = static_cast< StructRefWrapper< C >* >( lua_touserdata( m_pLS, Index_ ) );
 197                                 pDest_ = m_pRefWrapper->pStruct;
 198                         }
 199                         else
 200                         {
 201                                 m_pValWrapper = static_cast< StructValWrapper< C >* >( lua_touserdata( m_pLS, Index_ ) );
 202                                 pDest_ = m_pValWrapper->pStruct.get();
 203                         }
 204
 205
 206         //                      pDest_ = static_cast< C* >( lua_touserdata( m_pLS, Index_ ) );
 207
 208                         return true;
 209                 }
 210
 211                 lua_State*      m_pLS;
 212                 bool            m_bByRef;
 213                 StructRefWrapper< C >* m_pRefWrapper;
 214                 StructValWrapper< C >* m_pValWrapper;
 215         };
 216
 217         template< class C, e_CheckingPolicy Checking >
 218         struct TypeConverter< C, Checking, tc_ValueType >
 219         {
 220                 TypeConverter( lua_State* pLS_ ) :
 221                         m_pLS( pLS_ ),
 222                         m_bByRef( true )
 223                 {
 224                 }
 225
 226                 bool CheckType( int Index_ )
 227                 {
 228                         if( lua_type( m_pLS, Index_ ) != LUA_TUSERDATA )
 229                         {
 230                                 // TODO: better error reporting
 231                                 TypeCheckHelpers< Checking >::ThrowTypeMismatch();
 232                                 return false;
 233                         }
 234
 235                         if( !lua_getmetatable( m_pLS, Index_ ) )
 236                         {
 237                                 TypeCheckHelpers< Checking >::ThrowTypeMismatch();
 238                                 return false;
 239                         }
 240
 241                         // Check if it's a struct wrapped by reference
 242                         Registry< C* >::PushMetatable( m_pLS );
 243                         if( lua_rawequal( m_pLS, -1, -2 ) )
 244                         {
 245                                 lua_pop( m_pLS, 2 );
 246                                 return true;
 247                         }
 248
 249                         lua_pop( m_pLS, 1 );
 250
 251                         // Check if it's a struct wrapped by value
 252                         Registry< C& >::PushMetatable( m_pLS );
 253                         if( lua_rawequal( m_pLS, -1, -2 ) )
 254                         {
 255                                 lua_pop( m_pLS, 2 );
 256                                 m_bByRef = false;
 257                                 return true;
 258                         }
 259
 260                         TypeCheckHelpers< Checking >::ThrowTypeMismatch( lua_type( m_pLS, -2 ), lua_type( m_pLS, -1 ) );
 261                         return false;
 262                 }
 263
 264                 bool ConvertFromLua( int Index_, C& Dest_ )
 265                 {
 266                         if( !CheckType( Index_ ) )
 267                                 return false;
 268                         if( m_bByRef )
 269                         {
 270                                 StructRefWrapper< C >* pWrapper =
 271                                         static_cast< StructRefWrapper< C >* >( lua_touserdata( m_pLS, Index_ ) );
 272                                 Dest_ = *pWrapper->pStruct;
 273                         }
 274                         else
 275                         {
 276                                 StructValWrapper< C >* pWrapper =
 277                                         static_cast< StructValWrapper< C >* >( lua_touserdata( m_pLS, Index_ ) );
 278                                 Dest_ = *pWrapper->pStruct;
 279                         }
 280
 281
 282                         //      Dest_ = *static_cast< C* >( lua_touserdata( m_pLS, Index_ ) );
 283
 284                         return true;
 285                 }
 286
 287                 void ConvertToLua( const C& Obj_ ) const
 288                 {
 289                         shared_ptr< C > pStruct( new C( Obj_ ) );
 290
 291                         void* pData = lua_newuserdata( m_pLS, sizeof( StructValWrapper< C > ) );
 292                         if( !pData )
 293                                 throw std::bad_alloc();
 294
 295                         new( pData ) StructValWrapper< C >( pStruct );
 296
 297                         Registry< C& >::PushMetatable( m_pLS );
 298                         lua_setmetatable( m_pLS, -2 );
 299                 }
 300
 301                 void ConvertToLuaByRef( shared_ptr< void > pOwner_, C& Obj_ ) const
 302                 {
 303                         void* pData = lua_newuserdata( m_pLS, sizeof( StructRefWrapper< C > ) );
 304                         if( !pData )
 305                                 throw std::bad_alloc();
 306
 307                         new( pData ) StructRefWrapper< C >( pOwner_, &Obj_ );
 308
 309                         Registry< C* >::PushMetatable( m_pLS );
 310
 311                         lua_setmetatable( m_pLS, -2 );
 312                 }
 313
 314                 lua_State*      m_pLS;
 315                 bool            m_bByRef;
 316         };
 317
 318         template< class C >
 319         struct TypeConverter< C, cp_NoCheck, tc_ValueType >
 320         {
 321                 TypeConverter( lua_State* pLS_ ) :
 322                         m_pLS( pLS_ )
 323                 {
 324                 }
 325
 326                 bool CheckType( int Index_ )
 327                 {
 328                         return true;
 329                 }
 330
 331                 bool ConvertFromLua( int Index_, C& Dest_ )
 332                 {
 333                         lua_getmetatable( m_pLS, Index_ );
 334
 335                         // Check if it's a struct wrapped by reference
 336                         Registry< C* >::PushMetatable( m_pLS );
 337
 338                         bool bRes = lua_rawequal( m_pLS, -1, -2 );
 339                         lua_pop( m_pLS, 2 );
 340
 341                         if( bRes )
 342                         {
 343                                 StructRefWrapper< C >* pWrapper =
 344                                         static_cast< StructRefWrapper< C >* >( lua_touserdata( m_pLS, Index_ ) );
 345                                 Dest_ = *pWrapper->pStruct;
 346                         }
 347                         else
 348                                 Dest_ = *static_cast< C* >( lua_touserdata( m_pLS, Index_ ) );
 349
 350                         return true;
 351                 }
 352
 353                 lua_State*      m_pLS;
 354         };
 355 }}
 356
 357 #endif