PrevUpHomeNext

Chapter 3. Object Wrappers

Table of Contents

boost/python/dict.hpp
Introduction
Class dict
Example
boost_python_list.hpp
Introduction
Class list
Example
boost/python/long.hpp
Introduction
Class long_
Example
boost/python/object.hpp
Introduction
Class slice_nil
Class const_attribute_policies
Class const_attribute_policies static functions
Class attribute_policies
Class attribute_policies static functions
Class const_objattribute_policies
Class const_objattribute_policies static functions
Class objattribute_policies
Class objattribute_policies static functions
Class const_item_policies
Class const_item_policies static functions
Class item_policies
Class item_policies static functions
Class const_slice_policies
Class const_slice_policies static functions
Class slice_policies
Class slice_policies static functions
Class template object_operators
Class template object_operators observer functions
Class object
Class object constructors and destructor
Class object modifiers
Class template proxy
Class template proxy observer functions
Class template proxy modifier functions
Functions
Example
boost/python/str.hpp
Introduction
Class str
Example
boost/python/slice.hpp
Introduction
Class slice
Class slice constructors
Class slice observer functions
Example
boost/python/tuple.hpp
Introduction
Class tuple
Function make_tuple
Example

Exposes a TypeWrapper for the Python dict type.

Exposes the mapping protocol of Python's built-in dict type. The semantics of the constructors and member functions defined below can be fully understood by reading the TypeWrapper concept definition. Since dict is publicly derived from object, the public object interface applies to dict instances as well.

namespace boost { namespace python
{
   class dict : public object
   {
      dict();

      template< class T >
      dict(T const & data);

      // modifiers
      void clear();
      dict copy();

      template <class T1, class T2>
      tuple popitem();

      template <class T>
      object setdefault(T const &k);

      template <class T1, class T2>
      object setdefault(T1 const & k, T2 const & d);

      void update(object_cref E);

      template< class T >
      void update(T const & E);

      // observers
      list values() const;

      object get(object_cref k) const;

      template<class T>
      object get(T const & k) const;

      object get(object_cref k, object_cref d) const;
      object get(T1 const & k, T2 const & d) const;

      bool has_key(object_cref k) const;

      template< class T >
      bool has_key(T const & k) const;

      list items() const;
      object iteritems() const;
      object iterkeys() const;
      object itervalues() const;
      list keys() const;
  };
}}
using namespace boost::python;
dict swap_object_dict(object target, dict d)
{
    dict result = extract<dict>(target.attr("__dict__"));
    target.attr("__dict__") = d;
    return result;
}

PrevUpHomeNext