lua/genericpointer.h

   1 #ifndef AWFUL_LUA_GENERICPOINTER_H
   2 #define AWFUL_LUA_GENERICPOINTER_H
   3
   4 namespace awful { namespace LuaImpl
   5 {
   6         template<> struct TypeConverter< NormalType, GenericPointer >
   7         {
   8                 class PointerConverter_i : public RefCounted
   9                 {
  10                         public:
  11                                 virtual ~PointerConverter_i() {}
  12                                 virtual void ConvertFromLua_nocheck( lua_State* pLS, int Index_, GenericPointer& Dest_ ) = 0;
  13                                 virtual void ConvertToLua( lua_State* pLS, const GenericPointer& Dest_ ) = 0;
  14                 };
  15
  16                 template< class C > class PointerConverter : public PointerConverter_i
  17                 {
  18                         public:
  19                                 virtual void ConvertFromLua_nocheck( lua_State* pLS, int Index_, GenericPointer& Dest_ )
  20                                 {
  21                                         TypeConverter< NormalType, Pointer< C > > tc( pLS );
  22                                         Pointer< C > pObj;
  23                                         tc.ConvertFromLua_nocheck( Index_, pObj );
  24                                         Dest_ = pObj;
  25                                 }
  26
  27                                 virtual void ConvertToLua( lua_State* pLS, const GenericPointer& pObj_ )
  28                                 {
  29                                         TypeConverter< NormalType, Pointer< C > > tc( pLS );
  30                                         Pointer< C > pObj = static_cast< C* >( pObj_ );
  31                                         tc.ConvertToLua( pObj );
  32                                 }
  33                 };
  34
  35                 typedef std::map< TypeInfoKey, Pointer< PointerConverter_i > > converter_map;
  36                 static converter_map PointerConverters;
  37
  38                 template< class C > static void RegisterClass()
  39                 {
  40                         PointerConverters.insert( std::make_pair(
  41                                         TypeInfoKey( typeid( C ) ),
  42                                         new PointerConverter< C > ) );
  43                 }
  44
  45                 TypeConverter( lua_State* pLS_ ) :
  46                         m_pLS( pLS_ )
  47                 {
  48                 }
  49
  50                 bool CheckType_nothrow( int Index_ )
  51                 {
  52                         // TODO: this is not very robust because it assume that any user data we get thrown
  53                         // at are our own wrapped pointers, whereas it could be some completely alien stuff.
  54                         if( lua_isnil( m_pLS, Index_ ) )
  55                                 return true;
  56
  57                         if( lua_type( m_pLS, Index_ ) != LUA_TUSERDATA )
  58                                 return false;
  59
  60                         PointerWrapper< RefCounted >* pWrapper =
  61                                         static_cast< PointerWrapper< RefCounted >* >( lua_touserdata( m_pLS, Index_ ) );
  62
  63                         converter_map::const_iterator it = PointerConverters.find( *pWrapper->pTypeInfo );
  64                         return it != PointerConverters.end();
  65                 }
  66
  67                 void ConvertFromLua( int Index_, GenericPointer& Dest_ )
  68                 {
  69                         if( !CheckType_nothrow( Index_ ) )
  70                                 throw Error::TypeMismatch( lua_type( m_pLS, Index_ ), LUA_TUSERDATA );
  71
  72                         ConvertFromLua_nocheck( Index_, Dest_ );
  73                 }
  74
  75                 void ConvertFromLua_nocheck( int Index_, GenericPointer& Dest_ )
  76                 {
  77                         if( lua_isnil( m_pLS, Index_ ) )
  78                         {
  79                                 Dest_.clear();
  80                                 return;
  81                         }
  82
  83                         PointerWrapper< RefCounted >* pWrapper =
  84                                         static_cast< PointerWrapper< RefCounted >* >( lua_touserdata( m_pLS, Index_ ) );
  85
  86                         // TODO: This could be cached from the possible prior call to CheckType_nothrow
  87                         // so as to avoid to look this up twice.
  88                         converter_map::const_iterator it = PointerConverters.find( *pWrapper->pTypeInfo );
  89                         it->second->ConvertFromLua_nocheck( m_pLS, Index_, Dest_ );
  90                 }
  91
  92                 void ConvertToLua( const GenericPointer& Ptr_ )
  93                 {
  94                         if( !Ptr_ )
  95                                 lua_pushnil( m_pLS );
  96                         else
  97                         {
  98                                 converter_map::const_iterator it = PointerConverters.find( *Ptr_.getDynamicType() );
  99
 100                                 // TODO: what if the GenericPointer somehow points to a type that is not registered
 101                                 // in converter_map? We should throw a specific diagnostic message.
 102                                 it->second->ConvertToLua( m_pLS, Ptr_ );
 103                         }
 104                 }
 105
 106                 lua_State*      m_pLS;
 107         };
 108 }}
 109
 110 #endif