PyExport.h

Go to the documentation of this file.

#ifndef __PYEXPORT_H__
#define __PYEXPORT_H__

// Std. configurations

// needed header
#undef slots

// (re-)defined in pyconfig.h
#if defined(_POSIX_C_SOURCE)
#undef _POSIX_C_SOURCE
#endif

#include <Python.h>
#define slots
//#include <iostream>



#include <base_defines.h>

#include <typeinfo>



// forward
// class FCInterpreter;
typedef struct _object PyObject;


namespace Base
{
class PyObjectBase;

class CA_BASE_EXPORT PyHandler
{
public:
    void IncRef(void);
    void DecRef(void);
    virtual PyObjectBase* GetPyObject(void) = 0;
};


template <class HandledType>
class PyHandle
{
public:
    //**************************************************************************
    // construction destruction

    PyHandle(HandledType* ToHandel = 0L) : _pHandels(ToHandel)
    {
        if (_pHandels)
            _pHandels->IncRef();
    }

    PyHandle(const PyHandle<HandledType>& ToHandel) : _pHandels(ToHandel._pHandels)
    {
        if (_pHandels)
            _pHandels->IncRef();
    }

    ~PyHandle()
    {
        if (_pHandels)
            _pHandels->DecRef();
    }

    //**************************************************************************
    // operator implementation

    // assign operator from a pointer
    PyHandle<HandledType>& operator=(/*const*/ HandledType* other)
    {
        if (_pHandels)
            _pHandels->DecRef();
        // FIXME: Should be without "->_pHandels", shouldn't it? (Werner)
        _pHandels = other;  //_pHandels = other->_pHandels;
        if (_pHandels)
            _pHandels->IncRef();
        return *this;
    }
    /*
      // FIXME: Does this method make sense? I don't think so. (Werner)
        // assign operator from a unknown pointer
        PyHandle <HandledType>  &operator=(void* other)
        {
            if(_pHandels)
                _pHandels->DecRef();
            if( PointsOn(other) )
        // FIXME: Should be without "->_pHandels", shouldn't it? (Werner)
            _pHandels = reinterpret_cast<HandledType*>(other);//_pHandels = other->_pHandels;
            else
                // invalid handle
                _pHandels = 0L;
            if(_pHandels)
                _pHandels->IncRef();
            return *this;
        }
    */
    // assign operator from a handle
    PyHandle<HandledType>& operator=(const PyHandle<HandledType>& other)
    {
        if (_pHandels)
            _pHandels->DecRef();
        _pHandels = other._pHandels;
        if (_pHandels)
            _pHandels->IncRef();
        return *this;
    }

    HandledType& operator*() { return *_pHandels; }

    HandledType* operator->() { return _pHandels; }

    const HandledType& operator*() const { return _pHandels; }

    const HandledType* operator->() const { return _pHandels; }

    bool operator<(const PyHandle<HandledType>& other) const
    {
        // return _pHandels<&other;
        // FIXME: Shouldn't we compare both pointers?. (Werner)
        return _pHandels < other._pHandels;
    }

    bool operator==(const PyHandle<HandledType>& other) const
    {
        // return _pHandels==&other;
        // FIXME: Shouldn't we compare both pointers?. (Werner)
        return _pHandels == other._pHandels;
    }

    PyObject* GetPyObject(void)
    {
        // return (PyObject*) _pHandels;
        // FIXME: Shouldn't we return the pointer's object?. (Werner)
        return _pHandels->GetPyObject();
    }
    //**************************************************************************
    // checking on the state

    bool IsValid(void) const { return _pHandels != 0; }

    bool IsNull(void) const { return _pHandels == 0; }
    /*
        bool IsLastRef(void) const
        {
            if(_pHandels && _pHadels->GetReferenceCount()==1)
                return true;
            return false;
        }

        long GetReferenceCount(void) const
        {
            if(_pHandels)
                return _pHadels->GetReferenceCount();
            return 0;
        }
    */
    // FIXME: Does this method make sense? I don't think so. (Werner)
    /*
      bool PointsOn(const void* other) const
      {
          if(!_pHandels)
              if(other)
                  return false;
              else
                  return true;
          return typeid(*other) == typeid(HandledType) ;
      }*/

private:
    HandledType* _pHandels;
};


}  // namespace Base

#endif