sequence_iterator.hpp

Go to the documentation of this file.

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

#ifndef SEQUENCE_ITERATOR_HPP_INCLUDED
#define SEQUENCE_ITERATOR_HPP_INCLUDED

#include <Python.h>
#include <boost/iterator/iterator_facade.hpp>
#include <stdexcept>
#include <mds_utils/python/conversion.hpp>


namespace mds_utils {
    namespace python {

template<class T>
class ProxyPySeqElement;

template<class T,class Reference = ProxyPySeqElement<T> >
class PySequenceIterator;


template<class PySeqIt>
class PySeqIt_Access {
    
    PySeqIt&    seq_it;
    
public:
    
    PySeqIt_Access(PySeqIt& it) : seq_it(it) {}
    
    PyObject *pPySeq() const { return seq_it.pPySeq; }
    
    size_t cur_pos() const { return seq_it.cur_pos; }
    
    size_t nel() const { return seq_it.nel; }
};



template<class T>
class ProxyPySeqElement {

    PySeqIt_Access< PySequenceIterator<T> >     seq_it;
    
public:

    ProxyPySeqElement(const PySequenceIterator<T>& it) :
        seq_it(*const_cast<PySequenceIterator<T>*>(&it)) {}
    
    ProxyPySeqElement& operator =(const T& val);

    operator T() const;
};




template<class T,class Reference>
class PySequenceIterator :
    public boost::iterator_facade<
            PySequenceIterator<T>,
            T,
            boost::bidirectional_traversal_tag,
            Reference
    >   {
        
        
    friend class boost::iterator_core_access;
    friend class PySeqIt_Access< PySequenceIterator<T,Reference> >;

    
    PyObject    *pPySeq;
    
    size_t
                nel,
                cur_pos;
    
    bool
                valid_obj;

    void seq_check(PyObject *o) {
        if (!PySequence_Check(o)) {
            throw std::invalid_argument("Input object is not a sequence");
        }
    }
    
    Reference dereference() const {
        return Reference(*this);
    }
    
    bool equal(const PySequenceIterator& rhs) const {
        return cur_pos == rhs.cur_pos;
    }
    
    void increment() { ++cur_pos; }
    
    void decrement() { --cur_pos; }
    
public:
    
    PySequenceIterator() : pPySeq(NULL),nel(0),cur_pos(0),
        valid_obj(false) {}
    
    
    PySequenceIterator(PyObject *o,bool end = false) : pPySeq(o),
        valid_obj(true) {
            
        Py_INCREF(pPySeq);
        seq_check(o);
        nel = static_cast<size_t>(PySequence_Length(o));
        cur_pos = (end) ? nel : 0;
    }
    
    
    PySequenceIterator(const PySequenceIterator& rhs) :
        pPySeq(rhs.pPySeq),nel(rhs.nel),cur_pos(rhs.cur_pos),
        valid_obj(rhs.valid_obj) {

        Py_INCREF(pPySeq);
    }
    
    
    ~PySequenceIterator() {
        if (valid_obj) Py_DECREF(pPySeq);
    }
    
    
    PySequenceIterator& operator =(const PySequenceIterator& rhs) {
        if (this == &rhs) return *this;
        
        if (pPySeq != NULL) Py_DECREF(pPySeq);
        
        pPySeq = rhs.pPySeq;
        Py_INCREF(pPySeq);
        
        nel = rhs.nel;
        cur_pos = rhs.cur_pos;
        valid_obj = rhs.valid_obj;
        
        return *this;
    }
};

template<class T>
inline ProxyPySeqElement<T>& ProxyPySeqElement<T>::operator =(const T& val) {
    using namespace mds_utils::python;
    
    PyObject *v(to_python(val));
    
    PySequence_SetItem(seq_it.pPySeq(),seq_it.cur_pos(),v);
    return *this;
}

template<class T>
inline ProxyPySeqElement<T>::operator T() const {
    PyObject    *py_el(PySequence_GetItem(seq_it.pPySeq(),seq_it.cur_pos()));
    T           retval(get<T>(py_el));
    
    Py_DECREF(py_el);
    return retval;
}

template<>
inline ProxyPySeqElement<PyObject*>::operator PyObject*() const {
    PyObject    *py_el(PySequence_GetItem(seq_it.pPySeq(),seq_it.cur_pos()));
    
    return py_el;
}

    } // namespace python
} // namespace mds_utils


#endif