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, cp_NoThrow > tc( m_pLS );
  58
  59                 /*      if( !tc.CheckType( m_paramindex ) )
  60                         {
  61                                 m_paramindex = m_SkipParams + 1;
  62                                 return false;
  63                         }*/
  64
  65                         if( !tc.ConvertFromLua( m_paramindex, Dest_ ) )
  66                         {
  67                                 m_paramindex = m_SkipParams + 1;
  68                                 return false;
  69                         }
  70
  71                         ++m_paramindex;
  72                         return true;
  73                 }
  74
  75                 template< typename category, typename T > void setReturnValue( const T& Value_ )
  76                 {
  77                         TypeConverter< category, T > tc( m_pLS );
  78                         tc.ConvertToLua( Value_ );
  79                         m_bReturnValue = true;
  80                 }
  81
  82                 lua_State*      m_pLS;
  83                 int             m_paramindex;
  84                 bool            m_bReturnValue;
  85                 bool            m_bStatic;
  86                 int                     m_SkipParams;
  87         };
  88
  89         template< class C, typename MtdTag, class CC > struct StaticMethodWrapper
  90         {
  91                 static int LuaCFunc( lua_State* pLS )
  92                 {
  93                         try
  94                         {
  95                                 CC context( pLS, true );
  96                                 if( !method_traits< C, MtdTag >::template CallWrapper< CC >::Call( context ) )
  97                                         throw Error::NoOverloadFound();
  98                                 return context.m_bReturnValue ? 1 : 0;
  99                         }
 100                         catch( const Error::Base& error )
 101                         {
 102                                 error.ConvertToLua( pLS );
 103                                 return 0;
 104                         }
 105                 }
 106         };
 107
 108         template< class C, class CC > struct CtorWrapper
 109         {
 110                 static int LuaCFunc( lua_State* pLS )
 111                 {
 112                         try
 113                         {
 114                                 CC context( pLS, true, 1 );
 115                                 if( !method_traits< C, typename class_traits< C >::ctor_tag >::
 116                                         template CallWrapper< CC >::Call( context ) )
 117                                         throw Error::NoOverloadFound();
 118                                 return 1;
 119                         }
 120                         catch( const Error::Base& error )
 121                         {
 122                                 error.ConvertToLua( pLS );
 123                                 return 0;
 124                         }
 125                 }
 126         };
 127
 128         template< class C, typename MtdTag, class CC > struct MethodWrapper
 129         {
 130                 static int LuaCFunc( lua_State* pLS )
 131                 {
 132                         try
 133                         {
 134                                 CC context( pLS, false );
 135                                 if( !method_traits< C, MtdTag >::template CallWrapper< CC >::Call( context ) )
 136                                         throw Error::NoOverloadFound();
 137                                 return context.m_bReturnValue ? 1 : 0;
 138                         }
 139                         catch( Error::Base& error )
 140                         {
 141                                 error.ConvertToLua( pLS );
 142                                 return 0;
 143                         }
 144                 }
 145         };
 146 }}
 147
 148 #endif