lua/method.h

   1 #ifndef AWFUL_LUA_METHOD_H
   2 #define AWFUL_LUA_METHOD_H
   3
   4 namespace awful { namespace LuaImpl
   5 {
   6         template< class C, typename obj_category, typename PointerT > struct CallContext
   7         {
   8                 CallContext( lua_State* pLS, bool bStatic = false, int SkipParams = 0 ) :
   9                         m_pLS( pLS ),
  10                         m_paramindex( SkipParams + 1 ),
  11                         m_bReturnValue( false ),
  12                         m_bStatic( bStatic ),
  13                         m_SkipParams( SkipParams )
  14                 {
  15                 }
  16
  17                 int numParams() const
  18                 {
  19                         int numparams = lua_gettop( m_pLS );
  20
  21                         if( !m_bStatic )
  22                                 --numparams;
  23
  24                         numparams -= m_SkipParams;
  25
  26                         return numparams;
  27                 }
  28
  29                 void numExpectedParams( int Num_ ) const
  30                 {
  31                         // Check if we have the proper number of parameters
  32                         int numargs = numParams();
  33                         if( numargs != Num_ )
  34                                 throw Error::NotEnoughParams( numargs, Num_ );
  35                 }
  36
  37                 C& getObject()
  38                 {
  39                         PointerT Ptr;
  40
  41                         try
  42                         {
  43                                 TypeConverter< obj_category, PointerT > tc( m_pLS );
  44                                 tc.ConvertFromLua( m_paramindex, Ptr );
  45                         }
  46                         catch( const Error::TypeMismatch& error )
  47                         {
  48                                 throw Error::BadMethodCall();
  49                         }
  50
  51                         ++m_paramindex;
  52                         return *Ptr;
  53                 }
  54
  55                 template< typename category, typename T > bool getParam( const char* pName_, T& Dest_ )
  56                 {
  57                         TypeConverter< category, T > tc( m_pLS );
  58
  59                         if( !tc.CheckType_nothrow( m_paramindex ) )
  60                         {
  61                                 m_paramindex = m_SkipParams + 1;
  62                                 return false;
  63                         }
  64
  65                         tc.ConvertFromLua_nocheck( m_paramindex, Dest_ );
  66                         ++m_paramindex;
  67                         return true;
  68                 }
  69
  70                 template< typename category, typename T > void setReturnValue( const T& Value_ )
  71                 {
  72                         TypeConverter< category, T > tc( m_pLS );
  73                         tc.ConvertToLua( Value_ );
  74                         m_bReturnValue = true;
  75                 }
  76
  77                 lua_State*      m_pLS;
  78                 int             m_paramindex;
  79                 bool            m_bReturnValue;
  80                 bool            m_bStatic;
  81                 int                     m_SkipParams;
  82         };
  83
  84         template< class C, typename MtdTag, class CC > struct LuaStaticMethodWrapper
  85         {
  86                 static int LuaCFunc( lua_State* pLS )
  87                 {
  88                         try
  89                         {
  90                                 CC context( pLS, true );
  91                                 if( !method_traits< C, MtdTag >::template CallWrapper< CC >::Call( context ) )
  92                                         throw Error::NoOverloadFound();
  93                                 return context.m_bReturnValue ? 1 : 0;
  94                         }
  95                         catch( const Error::Base& error )
  96                         {
  97                                 error.ConvertToLua( pLS );
  98                                 return 0;
  99                         }
 100                 }
 101         };
 102
 103         // Same as static method wrapper, but tell the callcontext to skip
 104         // the first param.
 105         template< class C, class CC > struct LuaCtorWrapper
 106         {
 107                 static int LuaCFunc( lua_State* pLS )
 108                 {
 109                         try
 110                         {
 111                                 CC context( pLS, true, 1 );
 112                                 if( !method_traits< C, C >::template CallWrapper< CC >::Call( context ) )
 113                                         throw Error::NoOverloadFound();
 114                                 return context.m_bReturnValue ? 1 : 0;
 115                         }
 116                         catch( const Error::Base& error )
 117                         {
 118                                 error.ConvertToLua( pLS );
 119                                 return 0;
 120                         }
 121                 }
 122         };
 123
 124         template< class C, typename MtdTag, class CC > struct LuaMethodWrapper
 125         {
 126                 static int LuaCFunc( lua_State* pLS )
 127                 {
 128                         try
 129                         {
 130                                 CC context( pLS, false );
 131                                 if( !method_traits< C, MtdTag >::template CallWrapper< CC >::Call( context ) )
 132                                         throw Error::NoOverloadFound();
 133                                 return context.m_bReturnValue ? 1 : 0;
 134                         }
 135                         catch( Error::Base& error )
 136                         {
 137                                 error.ConvertToLua( pLS );
 138                                 return 0;
 139                         }
 140                 }
 141         };
 142 }}
 143
 144 #endif