obj.hpp

Go to the documentation of this file.

// obj.hpp
// 
// Copyright (c) 2014 - Michele De Stefano (micdestefano@users.sourceforge.net)
// 
// Distributed under the MIT License (See accompanying file LICENSE)

#ifndef MDS_UTILS_PYTHON_OBJ_HPP_INCLUDED
#define MDS_UTILS_PYTHON_OBJ_HPP_INCLUDED

#include <Python.h>
#include <string>
#include <stdexcept>
#include <mds_utils/python/conversion.hpp>

namespace mds_utils {
    namespace python {


class Obj;

template<>
Obj get<Obj>(PyObject *po);

PyObject* to_python(const Obj& o);



class Obj {
    
    void release_obj() {
        while (decref_on_destroy > 0) decref();
        m_po = NULL;
    }

protected:

    size_t      decref_on_destroy;


    class ProxyAttr {

        Obj&    m_o;

        const std::string&
                attr_name;

        PyObject
                *m_attr;

        void reset_m_attr() {
            Py_XDECREF(m_attr);
            m_attr = NULL;
        }

    public:

        ProxyAttr(Obj& o,const std::string& attr) :
            m_o(o),attr_name(attr),
            m_attr(NULL) {
            
            if (m_o.has_attr(attr_name)) {
                /*
                 * The assignment only under this condition
                 * allows to create new attributes on the fly,
                 * without throwing any exception.
                 */
                m_attr = PyObject_GetAttrString(m_o,attr_name.c_str());
            }
        }

        ~ProxyAttr() {
            reset_m_attr();
        }

        operator PyObject* () {
            return m_attr;
        }

        operator Obj () {
            Obj o(m_attr);
            o.incref();
            return o;
        }

        template<class T>
        ProxyAttr& operator =(const T& val) {

            reset_m_attr();
            m_attr = to_python(val);
            Py_XINCREF(m_attr);

            /*
             * The following instruction can create new attributes
             * if they don't already exist.
             */
            if (PyObject_SetAttrString(m_o,attr_name.c_str(),m_attr) == -1) {
                throw std::runtime_error("Cannot assign to attribute " +
                    attr_name);
            }

            return *this;
        }

        Obj operator()() {
            Obj oattr(m_attr);

            return oattr();
        }
    };


    PyObject    *m_po;  

    void check_callable() {
        if (!is_callable()) {
            throw std::logic_error("The object is not callable");
        }
    }

    void check_call_result(PyObject *result) {
        if (result == NULL) {
            throw std::runtime_error("Object call failed.");
        }
    }
    
public:

    Obj() : decref_on_destroy(0),m_po(NULL) {}

    Obj(const Obj& rhs) : decref_on_destroy(0),m_po(rhs.m_po) {
        incref();
    }
    
    Obj(Obj&& rhs) : decref_on_destroy(0),m_po(rhs.transfer()) {
        get_ownership();
    }


    Obj(ProxyAttr&& rhs) : decref_on_destroy(0),m_po(rhs) {
        incref();
    }
    
    Obj(PyObject *po) : decref_on_destroy(0),m_po(po) {}


    Obj& operator =(const Obj& rhs) {
        if (&rhs == this) return *this;
        reset();
        m_po = rhs.m_po;
        incref();
        return *this;
    }
    
    
    Obj& operator =(Obj&& rhs) {
        m_po = rhs.transfer();
        get_ownership();
        return *this;
    }
    
    virtual Obj& operator =(PyObject *po) {
        if (m_po == po) return *this;
        reset();
        m_po = po;
        return *this;
    }
    
    
    template<class T>
    Obj& operator =(const T& val) {
        reset();
        m_po = to_python(val);
        get_ownership();
        return *this;
    }
    
    virtual ~Obj() { reset(); }

    PyObject* getPyObject() const {
        return m_po;
    }

    operator PyObject* () const {
        return m_po;
    }
    
    virtual PyObject* transfer() {
        Py_XINCREF(m_po);
        PyObject *pret(m_po);
        reset();
        return pret;
    }
    
    virtual void incref() {
        Py_XINCREF(m_po);
        ++decref_on_destroy;
    }
    
    virtual void decref() {
        if (decref_on_destroy > 0) {
            Py_XDECREF(m_po);
            --decref_on_destroy;
        }
    }

    void reset() { release_obj(); }

    void get_ownership() {
        ++decref_on_destroy;
    }
    
    
    bool has_attr(const std::string& name) const {
        return PyObject_HasAttrString(m_po,name.c_str()) == 1;
    }
    
    
    ProxyAttr attr(const std::string& name) {
        return ProxyAttr(*this,name);
    }


    bool is_callable() const {
        return PyCallable_Check(m_po) == 1;
    }

    
    Obj operator()() {

        check_callable();

        PyObject*
            result(PyObject_CallObject(*this,NULL));

        check_call_result(result);

        Obj o(result);

        // No need to get the ownership here. It will be the destination
        // to take it, if needed

        return o;
    }


    Obj operator()(const Obj& args) {

        check_callable();

        PyObject*
            result(PyObject_CallObject(*this,args));

        check_call_result(result);

        Obj o(result);

        // No need to get the ownership here. It will be the destination
        // to take it, if needed

        return o;
    }

    Obj operator()(const Obj& args,const Obj& kw) {

        check_callable();

        PyObject*
            result(PyObject_Call(*this,args,kw));

        check_call_result(result);

        Obj o(result);

        // No need to get the ownership here. It will be the destination
        // to take it, if needed

        return o;
    }

};



template<>
inline Obj get<Obj>(PyObject *po) {
    return Obj(po);
}

inline PyObject* to_python(const Obj& o) {
    PyObject *retval(o);
    Py_XINCREF(retval);
    return retval;
}



    }
}

#endif