container_operators.hpp

Go to the documentation of this file.

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

#ifndef MDS_UTILS_PYTHON_CONTAINER_OPERATORS_HPP_INCLUDED
#define MDS_UTILS_PYTHON_CONTAINER_OPERATORS_HPP_INCLUDED

#include <mds_utils/python/common.hpp>
#include <mds_utils/python/conversion.hpp>
#include <mds_utils/python/list.hpp>
#include <mds_utils/python/exception.hpp>
#include <boost/numeric/conversion/cast.hpp>

namespace mds_utils {
    namespace python {
    

template<class Derived>
struct support_random_access {
    
    
    Obj py_get_item(const Obj &idx) {

        using namespace boost;

        Derived     &self(static_cast<Derived&>(*this));
        
        Py_ssize_t  nel(numeric_cast<Py_ssize_t>(self.get_nel()));

        if (PySlice_Check(idx)) {

            Py_ssize_t  start(0),stop(0),step(0),slen(0);

            PySlice_GetIndicesEx(
                reinterpret_cast<PySliceObject*>(static_cast<PyObject*>(idx)),
                    self.get_nel(),&start,&stop,&step,&slen);

            List    l;

            Py_ssize_t k,i,ind;

            for (k = 0,ind = i = start;k < slen;++k,i += step,ind = i) {
                if (ind < 0) ind += nel;
                if (ind < 0 || ind >= nel) {
                    throw index_error("Index out of range");
                }
                l.append(self.get_el_at(ind));
            }

            return l;
        } else {

            Py_ssize_t i = get<Py_ssize_t>(idx);
            if (i < 0) i += nel;
            if (i < 0 || i >= nel) {
                throw index_error("Index out of range");
            }

            return to_python(self.get_el_at(i));
        }

    }
    
};


template<class Derived>
struct support_random_getset_access : public support_random_access<Derived> {

    void py_set_item(const Obj& idx,const Obj& val) {

        using namespace boost;

        Derived     &self(static_cast<Derived&>(*this));
        
        Py_ssize_t  nel(numeric_cast<Py_ssize_t>(self.get_nel()));

        if (PySlice_Check(idx)) {
            
            if (!PySequence_Check(val)) {
                throw std::invalid_argument("The value to be set is not a sequence");
            }

            Py_ssize_t  start(0),stop(0),step(0),slen(0);

            PySlice_GetIndicesEx(
                reinterpret_cast<PySliceObject*>(static_cast<PyObject*>(idx)),
                    self.get_nel(),&start,&stop,&step,&slen);
            
            Py_ssize_t  len_val(PySequence_Length(val));
            
            if (len_val != slen) {
                throw std::invalid_argument("The rhs has not the same dimensions as the lhs.");
            }

            Py_ssize_t k,i,ind;

            for (k = 0,ind = i = start;k < slen;++k,i += step,ind = i) {
                if (ind < 0) ind += nel;
                if (ind < 0 || ind >= nel) {
                    throw index_error("Index out of range");
                }
                
                Obj py_val(PySequence_GetItem(val,k));
                
                py_val.get_ownership();
                
                self.set_el_at(ind,
                    get<typename Derived::value_type>(py_val));
            }
            
        } else {

            Py_ssize_t i = get<Py_ssize_t>(idx);
            if (i < 0) i += nel;
            if (i < 0 || i >= nel) {
                throw index_error("Index out of range");
            }

            self.set_el_at(i,get<typename Derived::value_type>(val));
        }

    }

};



    }   // namespace python
}   // namespace mds_utils

#endif