sequence.hpp

Go to the documentation of this file.

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

#ifndef MDS_UTILS_PYTHON_SEQUENCE_HPP_INCLUDED
#define MDS_UTILS_PYTHON_SEQUENCE_HPP_INCLUDED

#include <mds_utils/python/obj.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <boost/fusion/include/size.hpp>
#include <boost/lexical_cast.hpp>
#include <algorithm>
#include <iterator>
#include <utility>
#include <stdexcept>

namespace mds_utils {
    namespace python {

inline size_t len(PyObject *o) {
    Py_ssize_t  retval(PySequence_Length(o));

    if (retval == -1) {
        throw std::runtime_error("Cannot retrieve the length");
    }

    return static_cast<size_t>(retval);
}

template<class Derived>
class Sequence_Base : public Obj {  
    
    class from_fusion_seq {
        
        Derived&    self;
        
        volatile size_t     pos;
        
    public:
    
        from_fusion_seq(Derived& seq) : self(seq),pos(0) {}
    
        template <typename T>
        void operator()(T const& x) const {
            from_fusion_seq* pself(const_cast<from_fusion_seq*>(this));
            if (!self.set_item(pself->pos++,x)) {
                throw std::runtime_error("Failed to insert element n. " +
                    boost::lexical_cast<std::string>(pos-1) +
                    " into Python sequence");
            }
        }
    };
    
    friend class from_fusion_seq;
    
    
    class ProxyElem {
        
        Sequence_Base<Derived>& m_seq;
        
        size_t              m_i;
        
        PyObject* get_item() const {
            PyObject* po = PySequence_GetItem(m_seq,m_i);
            if (po == NULL) throw std::runtime_error(
                "Cannot access element " +
                    boost::lexical_cast<std::string>(m_i));
            return po;
        }
    
    public:
    
        ProxyElem(Sequence_Base<Derived>& seq,size_t i) : m_seq(seq),m_i(i) {}
        
        // Returns a new reference
        operator PyObject* () {
            return get_item();
        }
        
        operator Obj () {
            Obj o(get_item());
            o.get_ownership();
            return o;
        }
        
        template<class T>
        ProxyElem& operator =(const T& val) {

            PyObject *v = to_python(val);
            
            int success(PySequence_SetItem(m_seq,m_i,v));
            
            Py_XDECREF(v);
            
            if (success == -1) {
                throw std::runtime_error("Cannot assign to element " +
                    boost::lexical_cast<std::string>(m_i));
            }

            return *this;
        }       
    };
    

protected:

    size_t      m_len;  

    size_t idx(long i) const {
        long    Nel(static_cast<long>(m_len));
        if (i < -Nel || i >= Nel) throw std::invalid_argument(
            "Cannot access element " +
                boost::lexical_cast<std::string>(i));
        if (i >= 0) return static_cast<size_t>(i);
        return  static_cast<size_t>(i+Nel);
    }

        

public:

    Sequence_Base() : m_len(0) {}


    Sequence_Base(size_t len) : Obj(Derived::new_seq(len)),m_len(len) {
        get_ownership();
    }
        
    
    Sequence_Base(PyObject *po) : Obj(po) {
        assert(Derived::self_type_check(*this));
        m_len = PySequence_Size(po);    
    }
        
    
    Sequence_Base(Sequence_Base&& rhs) : Obj(std::move(rhs)) {
        assert(Derived::self_type_check(*this));
        m_len = PySequence_Size(m_po);          
    }
    
    
    Sequence_Base(const Sequence_Base& rhs) : Obj(rhs) {
        assert(Derived::self_type_check(*this));
        m_len = PySequence_Size(m_po);
    }
    

    Sequence_Base(ProxyAttr&& rhs) : Obj(std::move(rhs)) {
        assert(Derived::self_type_check(*this));
        m_len = PySequence_Size(m_po);
    }
    
    Sequence_Base<Derived>& operator =(Sequence_Base<Derived>&& rhs) {
        Obj::operator =(std::move(rhs));
        m_len = rhs.m_len;
        return *this;
    }
    

    Sequence_Base<Derived>& operator =(const Sequence_Base<Derived>& rhs) {
        Obj::operator =(rhs);
        m_len = rhs.m_len;
        return *this;
    }
    
    template<class seq_T>
    void set(const seq_T& seq) {
        reset();
        get_ownership();
        m_len = boost::fusion::size(seq);
        m_po = Derived::new_seq(m_len);
        if (m_po == NULL) {
            throw std::runtime_error("Could not instantiate a new sequence");
        }
        
        Derived&    self(*static_cast<Derived*>(this));
        
        boost::fusion::for_each(seq,from_fusion_seq(self));     
    }
    

    template<class FwIt>
    void set(FwIt b,FwIt e) {
        
        reset();
        
        Derived&    self(*static_cast<Derived*>(this));
        
        size_t  m_len(std::distance(b,e));
        
        m_po = Derived::new_seq(m_len);
            
        if (m_po == NULL) {
            throw std::runtime_error("Could not instantiate a new sequence");
        }
        
        get_ownership();
        
        size_t  k;
        
        for (k = 0;k < m_len;++k,++b) {
            if (!self.set_item(k,to_python(*b))) {
                throw std::runtime_error("Failed to insert "
                    "element n. " +
                    boost::lexical_cast<std::string>(k) +
                    " into Python sequence");
            }
        }
    }
    
    
    void set(const Obj& o) {
        if (!PySequence_Check(o)) {
            throw std::invalid_argument("Cannot construct a sequence from "
                "a non-sequence object.");
        }
        
        reset();
        
        m_len = PySequence_Size(o);

        if (Derived::self_type_check(o)) {
            m_po = o;
            incref();
            return;
        }
        
        
        if ((m_po = Derived::new_seq(m_len)) == NULL) {
            throw std::runtime_error("Could not instantiate a new sequence");
        }
        
        get_ownership();
                        
        size_t      k;
        
        PyObject    *po(NULL);
        
        Derived&    self(*static_cast<Derived*>(this));
                
        for (k = 0;k < m_len;++k,po = NULL) {

            po = PySequence_GetItem(o,k);
            
            if (po == NULL) {
                throw std::runtime_error(
                    "Failed extracting sequence element n. " +
                    boost::lexical_cast<std::string>(k) +
                    " from the input sequence");
            }
            
            if (!self.set_item(k,po)) {
                throw std::runtime_error("Failed to insert "
                    "element n. " +
                    boost::lexical_cast<std::string>(k) +
                    " into Python sequence");
            }
        }
    }
    
    
    void del(long i) {
        if (PySequence_DelItem(*this,idx(i)) == -1) {
            throw std::runtime_error("Cannot delete item.");
        }
    }
    
    
    size_t len() const { return m_len; }
    
    
    ProxyElem operator [](long i) {
        return ProxyElem(*this,idx(i));
    }   
};


class Sequence : public Sequence_Base<Sequence> {

    static PyObject* new_seq(size_t len) {
        return PyList_New(len);
    }

    static bool self_type_check(const Obj& o) {
        return PySequence_Check(o);
    }

    template<class T>
    bool set_item(size_t pos,T const& x) {
        PyObject    *po(to_python(x));
        bool        retval(PySequence_SetItem(m_po,pos,po) == 0);

        Py_XDECREF(po);

        return retval;
    }

    friend class Sequence_Base<Sequence>;

public:

    Sequence() {}


    Sequence(PyObject *po) : Sequence_Base<Sequence>(po) {}


    Sequence(const Sequence& rhs) : Sequence_Base<Sequence>(rhs) {}


    Sequence(Sequence&& rhs) : Sequence_Base<Sequence>(std::move(rhs)) {}


    Sequence(ProxyAttr&& rhs) : Sequence_Base<Sequence>(std::move(rhs)) {}


    Sequence& operator =(Sequence&& rhs) {
        Sequence_Base<Sequence>::operator =(std::move(rhs));
        return *this;
    }

    Sequence& operator =(const Sequence& rhs) {
        Sequence_Base<Sequence>::operator =(rhs);
        return *this;
    }
};

    }
}

#endif