PyExport.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) Jürgen Riegel          (juergen.riegel@web.de) 2002     *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   This library  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 Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/


#ifndef BASE_PYEXPORT_H
#define BASE_PYEXPORT_H

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

#include <Python.h>

namespace Base
{
class PyObjectBase;

//class BaseExport PyHandler
//{
//public:
//      void IncRef(void);
//      void DecRef(void);
//  virtual ~PyHandler();
//      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;
    }

    // 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) const {
        // return (PyObject*) _pHandels;
        // FIXME: Shouldn't we return the pointer's object?. (Werner)
        return const_cast<HandledType*>(_pHandels)->getPyObject();
    }
    //**************************************************************************
    // checking on the state

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

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

private:
    HandledType *_pHandels;

};


} // namespace Base

#endif // BASE_PYEXPORT_H