list.hpp

Go to the documentation of this file.

// list.hpp
//
// Copyright (c) 2014 - Michele De Stefano (info.micheledestefano@gmail.com)
//
// Distributed under the MIT License (See accompanying file LICENSE)

#ifndef MDS_UTILS_PYTHON_LIST_HPP_INCLUDED
#define MDS_UTILS_PYTHON_LIST_HPP_INCLUDED

#include <mds_utils/python/sequence.hpp>

namespace mds_utils {
    namespace python {

class List : public Sequence_Base<List> {
    
    static PyObject* new_seq(size_t len) {
        return PyList_New(len);
    }
    
    static bool self_type_check(const Obj& o) {
        return PyList_Check(o);
    }
        
    template<class T>
    bool set_item(size_t pos,T const& x) {
        return PyList_SetItem(m_po,pos,to_python(x)) == 0;
    }
    
    
    void init_list() {
        if ((m_po = new_seq(0)) == NULL) {
            throw std::runtime_error("Could not create an empty list");
        }
        get_ownership();
    }
    
    friend class Sequence_Base<List>;
    
    
public:

    List() {}
    
    
    List(PyObject *po) : Sequence_Base<List>(po) {}
    
    
    List(const List& rhs) : Sequence_Base<List>(rhs) {}
    
    
    List(List&& rhs) : Sequence_Base<List>(std::move(rhs)) {}
    
    
    List(ProxyAttr&& rhs) : Sequence_Base<List>(std::move(rhs)) {}


    List& operator =(List&& rhs) {
        Sequence_Base<List>::operator =(std::move(rhs));
        return *this;
    }
    
    List& operator =(const List& rhs) {
        Sequence_Base<List>::operator =(rhs);
        return *this;
    }
    
    template<class T>
    List& append(const T& val) {
        if (m_po == NULL) init_list();
        if (PyList_Append(m_po,to_python(val)) == -1) {
            throw std::runtime_error("Append failed.");
        }
        ++m_len;
        return *this;
    }
    
    template<class T>
    List& append(T&& val) {
        if (m_po == NULL) init_list();
        if (PyList_Append(m_po,to_python(val)) == -1) {
            throw std::runtime_error("Append failed.");
        }
        ++m_len;
        return *this;
    }
    
    template<class T>
    List& insert(long i,const T& val) {
        if (PyList_Insert(*this,idx(i),to_python(val)) == -1) {
            throw std::runtime_error("Insert failed.");
        }
        return *this;
    }
    
    template<class T>
    List& insert(long i,T&& val) {
        if (PyList_Insert(*this,idx(i),to_python(val)) == -1) {
            throw std::runtime_error("Insert failed.");
        }
        return *this;
    }
    
    List& sort() {
        if (PyList_Sort(*this) == -1) {
            throw std::runtime_error("Cannot sort.");
        }
        return *this;
    }
    
    
    List& reverse() {
        if (PyList_Reverse(*this) == -1) {
            throw std::runtime_error("Cannot reverse.");
        }
        return *this;
    }
};

    }
}

#endif /* MDS_UTILS_PYTHON_LIST_HPP_INCLUDED */