src/blawful/pyawful/pointer.h

   1 #ifndef AWFUL_PYTHON_POINTER_H
   2 #define AWFUL_PYTHON_POINTER_H
   3
   4 namespace awful { namespace PythonImpl
   5 {
   6         template< class C > struct TypeConverter< NormalType, Pointer< C > >
   7         {
   8                 class PointerConverter : public GenericPointerTable::PointerConverter_i
   9                 {
  10                         public:
  11                                 virtual void ConvertFromPython_nocheck( PyObject* pPyObj_, GenericPointer& Dest_ )
  12                                 {
  13                                         typedef TypeConverter< NormalType, Pointer< C > > tc;
  14                                         Pointer< C > pObj;
  15                                         tc::ConvertFromPython_nocheck( pPyObj_, pObj );
  16                                         Dest_ = pObj;
  17                                 }
  18
  19                                 virtual PyObject* ConvertToPython( const GenericPointer& Ptr_ )
  20                                 {
  21                                         typedef TypeConverter< NormalType, Pointer< C > > tc;
  22                                         Pointer< C > pObj = static_cast< C* >( Ptr_ );
  23                                         return tc::ConvertToPython( pObj );
  24                                 }
  25                 };
  26
  27                 static void RegisterPointerConversion()
  28                 {
  29                         Pointer< PointerConverter > pConverter = new PointerConverter;
  30
  31                         GenericPointerTable::PointerToPythonConverters.insert( std::make_pair(
  32                                         TypeInfoKey( typeid( C ) ),
  33                                         pConverter ) );
  34
  35                         GenericPointerTable::PointerFromPythonConverters.insert( std::make_pair(
  36                                         &ClassStuff< C >::TypeObject,
  37                                         pConverter ) );
  38                 }
  39
  40                 static bool CheckType_nothrow( PyObject* pPyObj_ )
  41                 {
  42                         if( pPyObj_ == Py_None )
  43                                 return true;
  44
  45                         if( PyObject_TypeCheck( pPyObj_, &ClassStuff< C >::TypeObject ) )
  46                                 return true;
  47
  48                         const PyTypeObject* pTypeObject = pPyObj_->ob_type;
  49                         typename ClassStuff< C >::Wrapper* pWrapper =
  50                                 static_cast< typename ClassStuff< C >::Wrapper* >( pPyObj_ );
  51
  52                         // This should be kept around to be reused by convertfrompython.
  53                         TypeCastMap::const_iterator it = pWrapper->pTypeCastMap->find( &ClassStuff< C >::TypeObject );
  54                         return it != pWrapper->pTypeCastMap->end();
  55
  56                 //      if( PyObject_TypeCheck( pPyObj_, &ClassStuff< C >::TypeObject ) || pPyObj_ == Py_None;
  57                 }
  58
  59                 static void ConvertFromPython_nocheck( PyObject* pPyObj_, Pointer< C >& Dest_ )
  60                 {
  61                         if( pPyObj_ == Py_None )
  62                                 Dest_ = 0;
  63                         else
  64                         {
  65                                 typename ClassStuff< C >::Wrapper* pWrapper =
  66                                         static_cast< typename ClassStuff< C >::Wrapper* >( pPyObj_ );
  67
  68                                 if( PyObject_TypeCheck( pPyObj_, &ClassStuff< C >::TypeObject ) )
  69                                         Dest_ = pWrapper->pObj;
  70                                 else
  71                                 {
  72                                         // We need to cast.
  73                                         TypeCastMap::const_iterator it = pWrapper->pTypeCastMap->find( &ClassStuff< C >::TypeObject );
  74                                         Dest_ = static_cast< C* >( it->second( &pWrapper->pObj ) );
  75                                 }
  76                         }
  77                 }
  78
  79                 static void ConvertFromPython( PyObject* pPyObj_, Pointer< C >& Dest_ )
  80                 {
  81                         if( !CheckType_nothrow( pPyObj_ ) )
  82                                 throw Error::TypeMismatch();
  83                         ConvertFromPython_nocheck( pPyObj_, Dest_ );
  84                 }
  85
  86                 static PyObject* ConvertToPython( const Pointer< C >& Ptr_ )
  87                 {
  88                         if( !flags::Scriptable< C >::value )
  89                                 Py_RETURN_NONE;
  90
  91                         if( !Ptr_ )
  92                                 Py_RETURN_NONE;
  93
  94                         PyObject* pPyObj;
  95
  96                         pPyObj = PyType_GenericAlloc( &ClassStuff< C >::TypeObject, 0 );
  97                         if( !pPyObj )
  98                                 Py_RETURN_NONE; //throw std::bad_alloc();
  99
 100                         try
 101                         {
 102                                 typedef typename ClassStuff< C >::Wrapper Wrapper;
 103                                 new( pPyObj ) Wrapper( Ptr_ );
 104                                 return pPyObj;
 105                         }
 106                         catch( const Error::Base& error )
 107                         {
 108                                 error.ConvertToPython();
 109                                 Py_DECREF( pPyObj );
 110                                 return NULL;
 111                         }
 112                 }
 113         };
 114 }}
 115
 116 #endif