Package pyplusplus :: Package code_repository :: Module ctypes_integration

# Source Code for Module pyplusplus.code_repository.ctypes_integration

      1  # Copyright 2004-2008 Roman Yakovenko.
      2  # Distributed under the Boost Software License, Version 1.0. (See
      3  # accompanying file LICENSE_1_0.txt or copy at
      4  # http://www.boost.org/LICENSE_1_0.txt)
      5
      6  """
      7  This file contains C++ code needed to export one dimensional static arrays.
      8  """
      9
     10
     11  namespace = "pyplusplus::convenience"
     12
     13  file_name = "__ctypes_integration.pypp.hpp"
     14
     15  code = \
     16  """// Copyright 2004-2008 Roman Yakovenko.
     17  // Distributed under the Boost Software License, Version 1.0. (See
     18  // accompanying file LICENSE_1_0.txt or copy at
     19  // http://www.boost.org/LICENSE_1_0.txt)
     20
     21  #ifndef __ctypes_integration_pyplusplus_hpp__
     22  #define __ctypes_integration_pyplusplus_hpp__
     23
     24  #include "boost/python.hpp"
     25  #include "boost/utility/addressof.hpp"
     26  #include "boost/mpl/vector.hpp"
     27  #include "boost/function.hpp"
     28  #include "boost/cstdint.hpp"
     29  #include "boost/type.hpp"
     30  #include "boost/bind.hpp"
     31
     32
     33  namespace pyplusplus{ namespace convenience{
     34
     35  template< typename TType, typename TMemVarType >
     36  boost::uint32_t
     37  addressof( const TType* inst_ptr, const TMemVarType TType::* offset){
     38      if( !inst_ptr ){
     39          throw std::runtime_error( "unable to dereference null pointer" );
     40      }
     41      const TType& inst = *inst_ptr;
     42      return boost::uint32_t( boost::addressof( inst.*offset ) );
     43  }
     44
     45  template< typename TType >
     46  boost::uint32_t
     47  addressof_inst( const TType* inst_ptr){
     48      if( !inst_ptr ){
     49          throw std::runtime_error( "unable to dereference null pointer" );
     50      }
     51
     52      return boost::uint32_t( inst_ptr );
     53  }
     54
     55  template< typename TType, typename TMemVarType >
     56  boost::python::object
     57  make_addressof_getter( const TMemVarType TType::* offset ){
     58      namespace bpl = boost::python;
     59      namespace pyppc = pyplusplus::convenience;
     60      return bpl::make_function( boost::bind( &pyppc::addressof< TType, TMemVarType >, _1, offset )
     61                                 , bpl::default_call_policies()
     62                                 , boost::mpl::vector< boost::uint32_t, const TType* >() );
     63  }
     64
     65  template< typename TType >
     66  boost::python::object
     67  make_addressof_inst_getter(){
     68      namespace bpl = boost::python;
     69      namespace pyppc = pyplusplus::convenience;
     70      return bpl::make_function( boost::bind( &pyppc::addressof_inst< TType >, _1 )
     71                                 , bpl::default_call_policies()
     72                                 , boost::mpl::vector< boost::uint32_t, const TType* >() );
     73  }
     74
     75  class register_addressof_static_var : public boost::python::def_visitor<register_addressof_static_var>
     76  {
     77      friend class boost::python::def_visitor_access;
     78
     79  public:
     80
     81      template< typename TVarType >
     82      register_addressof_static_var( const char* name, const TVarType& var )
     83      : m_name( name )
     84        , m_address( addressof_inst( boost::addressof( var ) ) )
     85      {}
     86
     87      template <class classT>
     88      void visit(classT& c) const{
     89          boost::python::scope cls_scope( c );
     90          cls_scope.attr(m_name) = m_address;
     91      }
     92
     93  private:
     94      boost::uint32_t m_address;
     95      const char* m_name;
     96  };
     97
     98
     99  class register_sizeof : public boost::python::def_visitor<register_sizeof>
    100  {
    101      friend class boost::python::def_visitor_access;
    102
    103  public:
    104
    105      template< typename TType >
    106      register_sizeof( boost::type< TType > )
    107      : m_sizeof( sizeof( TType ) )
    108      {}
    109
    110      template <class classT>
    111      void visit(classT& c) const{
    112          boost::python::scope cls_scope( c );
    113          cls_scope.attr("sizeof") = m_sizeof;
    114      }
    115
    116  private:
    117      size_t m_sizeof;
    118  };
    119
    120
    121  } /*pyplusplus*/ } /*convenience*/
    122
    123  namespace pyplus_conv = pyplusplus::convenience;
    124
    125  #endif//__ctypes_integration_pyplusplus_hpp__
    126
    127  """
    128