dictionary.hpp

Go to the documentation of this file.

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

#ifndef MDS_UTILS_PYTHON_DICTIONARY_HPP_INCLUDED
#define MDS_UTILS_PYTHON_DICTIONARY_HPP_INCLUDED

#include <mds_utils/python/obj.hpp>
#include <mds_utils/python/list.hpp>

namespace mds_utils {
    namespace python {

class Dictionary : public Obj {
    
    static bool self_type_check(const Obj& o) {
        return PyDict_Check(o);
    }

public:
    
    Dictionary() {
        m_po = PyDict_New();
        get_ownership();
    }
    
    Dictionary(PyObject *po) : Obj(po) {
        assert(self_type_check(o));
    }
    
    
    Dictionary(const Dictionary& rhs) : Obj(rhs) {}
    
    
    Dictionary(Dictionary&& rhs) : Obj(std::move(rhs)) {}
    
    
    void copy(const Dictionary& rhs) {
        reset();
        m_po = PyDict_Copy(rhs);
        get_ownership();
    }
    
    
    void clear() {
        PyDict_Clear(m_po);
    }
    
    
    Dictionary& operator =(Dictionary&& rhs) {
        Obj::operator =(std::move(rhs));
        return *this;
    }
        
    Dictionary& operator =(const Dictionary& rhs) {
        Obj::operator =(rhs);
        return *this;
    }
    
    template<class Key_T>
    bool contains(const Key_T& key) const {
        int retval(PyDict_Contains(m_po,to_python(key)));
        if (retval == -1) {
            throw std::runtime_error("Error while searching for the "
                "provided key.");
        }
        return (retval == 1);
    }
    
    
    template<class Key_T,class Val_T>
    void set_item(const Key_T& key,const Val_T& val) {
        Obj
            pykey(to_python(key)),
            pyval(to_python(val));
        
        pykey.get_ownership();
        pyval.get_ownership();
        
        if (PyDict_SetItem(m_po,pykey,pyval) == -1) {
            throw std::runtime_error("Could not set item into dictionary.");
        }
    }
    
    
    template<class Key_T>
    void del_item(const Key_T& key) {
        Obj
            pykey(to_python(key));
        pykey.get_ownership();
        
        if (PyDict_DelItem(m_po,key) == -1) {
            throw std::runtime_error("Could not remove item from dictionary.");
        }
    }
    
    
    template<class Key_T>
    Obj get_item(const Key_T& key) const {
        PyObject    *pout(PyDict_GetItem(m_po,to_python(key)));
        if (pout == NULL) {
            throw std::runtime_error("Could not get item for the provided key");
        }
        Obj out(pout);
        out.incref();
        return out;
    }
    
    
    List items() const {
        List
            out(PyDict_Items(m_po));
        out.get_ownership();
        return out;
    }

    List keys() const {
        List
            out(PyDict_Keys(m_po));
        out.get_ownership();
        return out;
    }

    List values() const {
        List
            out(PyDict_Values(m_po));
        out.get_ownership();
        return out;
    }
    
    size_t len() const {
        return PyDict_Size(m_po);
    }
    
    
    void update(const Dictionary& b) {
        if (PyDict_Update(m_po,b) == -1) {
            throw std::runtime_error("Cannot update dictionary.");
        }
    }
};

    }
}

#endif /* MDS_UTILS_PYTHON_DICTIONARY_HPP_INCLUDED */