PyTypeWrapper.h

Go to the documentation of this file.

//    Copyright 2004, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//

#ifdef HAVE_PYTHON

#if defined(_MSC_VER)
// undefine _DEBUG since we want to always link to the release version of
// python and pyconfig.h automatically links debug version if _DEBUG is
// defined.
#ifdef _DEBUG
#define _DEBUG_UNDEFED
#undef _DEBUG
#endif
#endif
#if defined(__APPLE__) && defined(__MACH__)
#include <Python/Python.h>
#else
#include <Python.h>
#endif
#if defined(_MSC_VER)
// redefine _DEBUG if it was undefed
#ifdef _DEBUG_UNDEFED
#define _DEBUG
#endif
#endif
  
namespace H3D {

  struct PyType {
    PyObject_HEAD
  };

  template< class Type, 
            PyTypeObject *TypeObject,
            string ( *NameFunc ) (),
            bool ( *CheckFunc )( PyObject * ),
            Type (*ValueFunc)( PyObject *),
            PyObject *(*NewFunc)( const Type &) >
  struct PyTypeWrapper: public PyType, Type {

    static void installType( PyObject* H3D_module ) {
      if (PyType_Ready( TypeObject ) < 0 )
        return; // THROW ERROR!?
      
      Py_INCREF( TypeObject );
      PyModule_AddObject( H3D_module, 
                          (char *)NameFunc().c_str(), 
                          (PyObject *)TypeObject );
    }
  
    static PyObject* create() {
      return PyType_GenericAlloc( TypeObject, 1 ); 
    } 
    
    static void dealloc( PyObject *self ) {
      self->ob_type->tp_free( self );
    }

    static PyObject* repr( PyObject *myself, PyObject *args ) {
      if( CheckFunc( myself ) ) {
        ostringstream s;
        s << ValueFunc( myself );
        return PyString_FromString( s.str().c_str() );
      } else {
        ostringstream s;
        s << "PyObject * is not a " << NameFunc() << "*"; 
        throw Exception::H3DAPIException( s.str(), 
                                          H3D_FULL_LOCATION );
      }
    }


    static int compare( PyObject *veca, PyObject *vecb ) {
      if( CheckFunc( veca ) && CheckFunc( vecb ) ){
        Type a = ValueFunc( veca );
        Type b = ValueFunc( vecb );
        return a != b;
      } else {
        ostringstream s;
        s << "PyObject * is not a " << NameFunc() << "*"; 
        throw Exception::H3DAPIException( s.str(),
                                          H3D_FULL_LOCATION );
      }
    }
  };


  template< class Type, 
            PyTypeObject *TypeObject,
            string ( *NameFunc ) (),
            bool ( *CheckFunc )( PyObject * ),
            Type (*ValueFunc)( PyObject *),
            PyObject *(*NewFunc)( const Type &) >
  struct PyNumberTypeWrapperBase: 
    public PyTypeWrapper< Type, 
                          TypeObject, 
                          NameFunc,
                          CheckFunc, 
                          ValueFunc, 
                          NewFunc > {

    static PyObject* add( PyObject *veca, PyObject *vecb ) {
      if( CheckFunc( veca ) && CheckFunc( vecb ) ){
        Type c = ValueFunc( veca ) + ValueFunc( vecb );
        return NewFunc( c );
      }
      return Py_NotImplemented;
    }
    
    static PyObject* sub( PyObject *veca, PyObject *vecb ) {
      if( CheckFunc( veca ) && CheckFunc( vecb ) ){
        Type c = ValueFunc( veca ) - ValueFunc( vecb );
        return NewFunc( c );
      }
      return Py_NotImplemented;
    }
    static PyObject* mul( PyObject *veca, PyObject *vecb ) {
      if( CheckFunc( veca ) ) {
        Type a = ValueFunc( veca );
        if( PyFloat_Check( vecb ) ) {
          Type c = a * PyFloat_AsDouble( vecb );
          return NewFunc( c );
          // int type
        } else if( PyInt_Check( vecb ) ) {
          Type c = a * PyInt_AsLong( vecb );
          return NewFunc( c );
          // long type
        } else if( PyLong_Check( vecb ) ) {
          Type c = a * PyLong_AsLong( vecb );
          return NewFunc( c );
        }
      } else if( CheckFunc( vecb ) ) {
        Type b = ValueFunc( vecb );
        // float type
        if( PyFloat_Check( veca ) ) {
          Type c = PyFloat_AsDouble( veca ) * b;
          return NewFunc( c );
          // int type
        } else if( PyInt_Check( veca ) ) {
          Type c = PyInt_AsLong( veca ) * b;
          return NewFunc( c );
          // long type
        } else if( PyLong_Check( veca ) ) {
          Type c = PyLong_AsLong( veca ) * b;
          return NewFunc( c );
        } 
      }
      return Py_NotImplemented;
    }

    static PyObject* div( PyObject *veca, PyObject *floatb ) {
      if( CheckFunc( veca ) ) {
        Type a = ValueFunc( veca );
        // float type
        if( PyFloat_Check( floatb ) ) {
          Type c = a / PyFloat_AsDouble( floatb );
          return NewFunc( c );
          // int type
        } else if( PyInt_Check( floatb ) ) {
          Type c = a / PyInt_AsLong( floatb );
          return NewFunc( c );
          // long type
        } else if( PyLong_Check( floatb ) ) {
          Type c = a / PyLong_AsLong( floatb );
          return NewFunc( c );
        }
      }
      return Py_NotImplemented;
    }

    static PyObject* neg( PyObject *vec ) {
      if( CheckFunc( vec ) ){
        Type c = -ValueFunc( vec );
        return NewFunc( c );
      }
      return Py_NotImplemented;
    }

  };

  template< class Type, 
            PyTypeObject *TypeObject,
            string ( *NameFunc ) (),
            bool ( *CheckFunc )( PyObject * ),
            Type (*ValueFunc)( PyObject *),
            PyObject *(*NewFunc)( const Type &) >
  struct PyVecTypeWrapper: 
    public PyNumberTypeWrapperBase< Type, 
                                    TypeObject, 
                                    NameFunc,
                                    CheckFunc, 
                                    ValueFunc, 
                                    NewFunc > {
    static PyObject* mul( PyObject *veca, PyObject *vecb ) {
      if( CheckFunc( veca ) && CheckFunc( vecb )  ) {
        Type a = ValueFunc( veca );
        Type b = ValueFunc( vecb );
        return PyFloat_FromDouble( a * b );
      } else {
        return PyNumberTypeWrapperBase< Type, 
          TypeObject, 
          NameFunc,
          CheckFunc, 
          ValueFunc, 
          NewFunc >::mul( veca, vecb );
      }
    }
  };

  template< class Type, 
            PyTypeObject *TypeObject,
            string ( *NameFunc ) (),
            bool ( *CheckFunc )( PyObject * ),
            Type (*ValueFunc)( PyObject *),
            PyObject *(*NewFunc)( const Type &) >
  struct PyNumberTypeWrapper: 
    public PyNumberTypeWrapperBase< Type, 
                                    TypeObject, 
                                    NameFunc,
                                    CheckFunc, 
                                    ValueFunc, 
                                    NewFunc > {
    static PyObject* mul( PyObject *veca, PyObject *vecb ) {
      if( CheckFunc( veca ) && CheckFunc( vecb )  ) {
        Type a = ValueFunc( veca );
        Type b = ValueFunc( vecb );
        return NewFunc( a * b );
      } else {
        return PyNumberTypeWrapperBase< Type, 
          TypeObject, 
          NameFunc,
          CheckFunc, 
          ValueFunc, 
          NewFunc >::mul( veca, vecb );
      }
    }
  };

}

#endif // HAVE_PYTHON

---