// Copyright David Abrahams 2002.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef DICT_20020706_HPP
#define DICT_20020706_HPP

# include <boost/python/detail/prefix.hpp>

#include <boost/python/object.hpp>
#include <boost/python/list.hpp>
#include <boost/python/tuple.hpp>
#include <boost/python/converter/pytype_object_mgr_traits.hpp>

namespace boost { namespace python {

class dict;

namespace detail
{
 struct BOOST_PYTHON_DECL dict_base : object
 {
 // D.clear() -> None. Remove all items from D.
 void clear();

 // D.copy() -> a shallow copy of D
 dict copy();

 // D.get(k[,d]) -> D[k] if D.has_key(k), else d. d defaults to None.
 object get(object_cref k) const;
 
 object get(object_cref k, object_cref d) const;

 // D.has_key(k) -> 1 if D has a key k, else 0
 bool has_key(object_cref k) const;

 // D.items() -> list of D's (key, value) pairs, as 2-tuples
 list items() const;
 
 // D.iteritems() -> an iterator over the (key, value) items of D
 object iteritems() const;

 // D.iterkeys() -> an iterator over the keys of D
 object iterkeys() const;

 // D.itervalues() -> an iterator over the values of D
 object itervalues() const;
 
 // D.keys() -> list of D's keys
 list keys() const;
 
 // D.popitem() -> (k, v), remove and return some (key, value) pair as a
 // 2-tuple; but raise KeyError if D is empty
 tuple popitem();

 // D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if not D.has_key(k)
 object setdefault(object_cref k);

 object setdefault(object_cref k, object_cref d);

 // D.update(E) -> None. Update D from E: for k in E.keys(): D[k] = E[k]
 void update(object_cref E);

 // D.values() -> list of D's values
 list values() const;

 protected:
 // dict() -> new empty dictionary.
 // dict(mapping) -> new dictionary initialized from a mapping object's
 // (key, value) pairs.
 // dict(seq) -> new dictionary initialized as if via:
 dict_base(); // new dict
 explicit dict_base(object_cref data);

 BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(dict_base, object)
 private:
 static detail::new_reference call(object const&);
 };
}

class dict : public detail::dict_base
{
 typedef detail::dict_base base;
 public:
 // dict() -> new empty dictionary.
 // dict(mapping) -> new dictionary initialized from a mapping object's
 // (key, value) pairs.
 // dict(seq) -> new dictionary initialized as if via:
 dict() {} // new dict

 template <class T>
 explicit dict(T const& data)
 : base(object(data))
 {
 }

 template<class T>
 object get(T const& k) const 
 {
 return base::get(object(k));
 }
 
 template<class T1, class T2>
 object get(T1 const& k, T2 const& d) const 
 {
 return base::get(object(k),object(d));
 }
 
 template<class T>
 bool has_key(T const& k) const
 {
 return base::has_key(object(k));
 }
 
 template<class T>
 object setdefault(T const& k)
 {
 return base::setdefault(object(k));
 }
 
 template<class T1, class T2>
 object setdefault(T1 const& k, T2 const& d)
 {
 return base::setdefault(object(k),object(d));
 }

 template<class T>
 void update(T const& E)
 {
 base::update(object(E));
 }

 public: // implementation detail -- for internal use only
 BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(dict, base)
};

//
// Converter Specializations
//
namespace converter
{
 template <>
 struct object_manager_traits<dict>
 : pytype_object_manager_traits<&PyDict_Type,dict>
 {
 };
}

}} // namespace boost::python

#endif