# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.38
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        try:
            fp, pathname, description = imp.find_module('_plist', [dirname(__file__)])
            _mod = imp.load_module('_plist', fp, pathname, description)
        finally:
            if fp is not None: fp.close()
        return _mod
    _plist = swig_import_helper()
    del swig_import_helper
else:
    import _plist
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


def _swig_setattr_nondynamic_method(set):
    def set_attr(self,name,value):
        if (name == "thisown"): return self.this.own(value)
        if hasattr(self,name) or (name == "this"):
            set(self,name,value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


class SwigPyIterator(object):
    """Proxy of C++ swig::SwigPyIterator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _plist.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(self) -> PyObject"""
        return _plist.SwigPyIterator_value(self)

    def incr(self, n = 1):
        """
        incr(self, size_t n = 1) -> SwigPyIterator
        incr(self) -> SwigPyIterator
        """
        return _plist.SwigPyIterator_incr(self, n)

    def decr(self, n = 1):
        """
        decr(self, size_t n = 1) -> SwigPyIterator
        decr(self) -> SwigPyIterator
        """
        return _plist.SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(self, SwigPyIterator x) -> ptrdiff_t"""
        return _plist.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(self, SwigPyIterator x) -> bool"""
        return _plist.SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(self) -> SwigPyIterator"""
        return _plist.SwigPyIterator_copy(self)

    def next(self):
        """next(self) -> PyObject"""
        return _plist.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(self) -> PyObject"""
        return _plist.SwigPyIterator___next__(self)

    def previous(self):
        """previous(self) -> PyObject"""
        return _plist.SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(self, ptrdiff_t n) -> SwigPyIterator"""
        return _plist.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SwigPyIterator x) -> bool"""
        return _plist.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SwigPyIterator x) -> bool"""
        return _plist.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _plist.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _plist.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _plist.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(self, ptrdiff_t n) -> SwigPyIterator
        __sub__(self, SwigPyIterator x) -> ptrdiff_t
        """
        return _plist.SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
SwigPyIterator_swigregister = _plist.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class PairStringNodePtr(object):
    """Proxy of C++ std::pair<(std::string,p.PList::Node)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> PairStringNodePtr
        __init__(self, string __a, Node __b) -> PairStringNodePtr
        __init__(self, PairStringNodePtr __p) -> PairStringNodePtr
        """
        this = _plist.new_PairStringNodePtr(*args)
        try: self.this.append(this)
        except: self.this = this
    first = _swig_property(_plist.PairStringNodePtr_first_get, _plist.PairStringNodePtr_first_set)
    second = _swig_property(_plist.PairStringNodePtr_second_get, _plist.PairStringNodePtr_second_set)
    def __len__(self): return 2
    def __repr__(self): return str((self.first, self.second))
    def __getitem__(self, index): 
      if not (index % 2): 
        return self.first
      else:
        return self.second
    def __setitem__(self, index, val):
      if not (index % 2): 
        self.first = val
      else:
        self.second = val
    __swig_destroy__ = _plist.delete_PairStringNodePtr
    __del__ = lambda self : None;
PairStringNodePtr_swigregister = _plist.PairStringNodePtr_swigregister
PairStringNodePtr_swigregister(PairStringNodePtr)

class MapStringNodePtr(object):
    """Proxy of C++ std::map<(std::string,p.PList::Node)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _plist.MapStringNodePtr_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _plist.MapStringNodePtr___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _plist.MapStringNodePtr___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _plist.MapStringNodePtr___len__(self)

    def __getitem__(self, *args):
        """__getitem__(self, key_type key) -> mapped_type"""
        return _plist.MapStringNodePtr___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, key_type key)"""
        return _plist.MapStringNodePtr___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(self, key_type key) -> bool"""
        return _plist.MapStringNodePtr_has_key(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _plist.MapStringNodePtr_keys(self)

    def values(self):
        """values(self) -> PyObject"""
        return _plist.MapStringNodePtr_values(self)

    def items(self):
        """items(self) -> PyObject"""
        return _plist.MapStringNodePtr_items(self)

    def __contains__(self, *args):
        """__contains__(self, key_type key) -> bool"""
        return _plist.MapStringNodePtr___contains__(self, *args)

    def key_iterator(self):
        """key_iterator(self) -> SwigPyIterator"""
        return _plist.MapStringNodePtr_key_iterator(self)

    def value_iterator(self):
        """value_iterator(self) -> SwigPyIterator"""
        return _plist.MapStringNodePtr_value_iterator(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __setitem__(self, *args):
        """__setitem__(self, key_type key, mapped_type x)"""
        return _plist.MapStringNodePtr___setitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, std::less<(std::string)> arg0) -> MapStringNodePtr
        __init__(self) -> MapStringNodePtr
        __init__(self, MapStringNodePtr arg0) -> MapStringNodePtr
        """
        this = _plist.new_MapStringNodePtr(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _plist.MapStringNodePtr_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _plist.MapStringNodePtr_size(self)

    def clear(self):
        """clear(self)"""
        return _plist.MapStringNodePtr_clear(self)

    def swap(self, *args):
        """swap(self, MapStringNodePtr v)"""
        return _plist.MapStringNodePtr_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _plist.MapStringNodePtr_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _plist.MapStringNodePtr_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _plist.MapStringNodePtr_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _plist.MapStringNodePtr_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _plist.MapStringNodePtr_rend(self)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _plist.MapStringNodePtr_count(self, *args)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator position)
        erase(self, iterator first, iterator last)
        """
        return _plist.MapStringNodePtr_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _plist.MapStringNodePtr_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _plist.MapStringNodePtr_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> iterator"""
        return _plist.MapStringNodePtr_upper_bound(self, *args)

    __swig_destroy__ = _plist.delete_MapStringNodePtr
    __del__ = lambda self : None;
MapStringNodePtr_swigregister = _plist.MapStringNodePtr_swigregister
MapStringNodePtr_swigregister(MapStringNodePtr)

class Node(object):
    """Proxy of C++ PList::Node class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _plist.delete_Node
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _plist.Node___deepcopy__(self)

    def GetParent(self):
        """GetParent(self) -> Node"""
        return _plist.Node_GetParent(self)

    def get_type(self):
        """get_type(self) -> plist_type"""
        return _plist.Node_get_type(self)

    def FromPlist(*args):
        """
        FromPlist(plist_t node, Node parent = None) -> Node
        FromPlist(plist_t node) -> Node
        """
        return _plist.Node_FromPlist(*args)

    FromPlist = staticmethod(FromPlist)
Node_swigregister = _plist.Node_swigregister
Node_swigregister(Node)

def Node_FromPlist(*args):
  """
    FromPlist(plist_t node, Node parent = None) -> Node
    Node_FromPlist(plist_t node) -> Node
    """
  return _plist.Node_FromPlist(*args)

class Boolean(Node):
    """Proxy of C++ PList::Boolean class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __assign__(self, *args):
        """__assign__(self, Boolean b) -> Boolean"""
        return _plist.Boolean___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> Boolean
        __init__(self) -> Boolean
        __init__(self, plist_t node, Node parent = None) -> Boolean
        __init__(self, Boolean b) -> Boolean
        __init__(self, bool b) -> Boolean
        """
        this = _plist.new_Boolean(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _plist.delete_Boolean
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _plist.Boolean___deepcopy__(self)

    def set_value(self, *args):
        """set_value(self, bool b)"""
        return _plist.Boolean_set_value(self, *args)

    def get_value(self):
        """get_value(self) -> bool"""
        return _plist.Boolean_get_value(self)

Boolean_swigregister = _plist.Boolean_swigregister
Boolean_swigregister(Boolean)

class Integer(Node):
    """Proxy of C++ PList::Integer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __assign__(self, *args):
        """__assign__(self, Integer i) -> Integer"""
        return _plist.Integer___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> Integer
        __init__(self) -> Integer
        __init__(self, plist_t node, Node parent = None) -> Integer
        __init__(self, Integer i) -> Integer
        __init__(self, uint64_t i) -> Integer
        """
        this = _plist.new_Integer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _plist.delete_Integer
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _plist.Integer___deepcopy__(self)

    def set_value(self, *args):
        """set_value(self, uint64_t i)"""
        return _plist.Integer_set_value(self, *args)

    def get_value(self):
        """get_value(self) -> uint64_t"""
        return _plist.Integer_get_value(self)

Integer_swigregister = _plist.Integer_swigregister
Integer_swigregister(Integer)

class Real(Node):
    """Proxy of C++ PList::Real class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __assign__(self, *args):
        """__assign__(self, Real d) -> Real"""
        return _plist.Real___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> Real
        __init__(self) -> Real
        __init__(self, plist_t node, Node parent = None) -> Real
        __init__(self, Real d) -> Real
        __init__(self, double d) -> Real
        """
        this = _plist.new_Real(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _plist.delete_Real
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _plist.Real___deepcopy__(self)

    def set_value(self, *args):
        """set_value(self, double d)"""
        return _plist.Real_set_value(self, *args)

    def get_value(self):
        """get_value(self) -> double"""
        return _plist.Real_get_value(self)

Real_swigregister = _plist.Real_swigregister
Real_swigregister(Real)

class String(Node):
    """Proxy of C++ PList::String class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __assign__(self, *args):
        """__assign__(self, String s) -> String"""
        return _plist.String___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> String
        __init__(self) -> String
        __init__(self, plist_t node, Node parent = None) -> String
        __init__(self, String s) -> String
        __init__(self, string s) -> String
        """
        this = _plist.new_String(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _plist.delete_String
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _plist.String___deepcopy__(self)

    def set_value(self, *args):
        """set_value(self, string s)"""
        return _plist.String_set_value(self, *args)

    def get_value(self):
        """get_value(self) -> string"""
        return _plist.String_get_value(self)

String_swigregister = _plist.String_swigregister
String_swigregister(String)

class Data(Node):
    """Proxy of C++ PList::Data class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __assign__(self, *args):
        """__assign__(self, Data d) -> Data"""
        return _plist.Data___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> Data
        __init__(self) -> Data
        __init__(self, plist_t node, Node parent = None) -> Data
        __init__(self, Data d) -> Data
        __init__(self, std::vector<(char)> buff) -> Data
        """
        this = _plist.new_Data(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _plist.delete_Data
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _plist.Data___deepcopy__(self)

    def set_value(self, *args):
        """set_value(self, std::vector<(char)> buff)"""
        return _plist.Data_set_value(self, *args)

    def get_value(self):
        """get_value(self) -> std::vector<(char)>"""
        return _plist.Data_get_value(self)

Data_swigregister = _plist.Data_swigregister
Data_swigregister(Data)

class Date(Node):
    """Proxy of C++ PList::Date class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __assign__(self, *args):
        """__assign__(self, Date d) -> Date"""
        return _plist.Date___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> Date
        __init__(self) -> Date
        __init__(self, plist_t node, Node parent = None) -> Date
        __init__(self, Date d) -> Date
        __init__(self, timeval t) -> Date
        """
        this = _plist.new_Date(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _plist.delete_Date
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _plist.Date___deepcopy__(self)

    def set_value(self, *args):
        """set_value(self, timeval t)"""
        return _plist.Date_set_value(self, *args)

    def get_value(self):
        """get_value(self) -> timeval"""
        return _plist.Date_get_value(self)

Date_swigregister = _plist.Date_swigregister
Date_swigregister(Date)

class Structure(Node):
    """Proxy of C++ PList::Structure class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _plist.delete_Structure
    __del__ = lambda self : None;
    def __len__(self):
        """__len__(self) -> uint32_t"""
        return _plist.Structure___len__(self)

    def to_xml(self):
        """to_xml(self) -> string"""
        return _plist.Structure_to_xml(self)

    def to_bin(self):
        """to_bin(self) -> std::vector<(char)>"""
        return _plist.Structure_to_bin(self)

    def __delitem__(self, *args):
        """__delitem__(self, Node node)"""
        return _plist.Structure___delitem__(self, *args)

    def from_xml(*args):
        """from_xml(string xml) -> Structure"""
        return _plist.Structure_from_xml(*args)

    from_xml = staticmethod(from_xml)
    def from_bin(*args):
        """from_bin(std::vector<(char)> bin) -> Structure"""
        return _plist.Structure_from_bin(*args)

    from_bin = staticmethod(from_bin)
Structure_swigregister = _plist.Structure_swigregister
Structure_swigregister(Structure)

def Structure_from_xml(*args):
  """Structure_from_xml(string xml) -> Structure"""
  return _plist.Structure_from_xml(*args)

def Structure_from_bin(*args):
  """Structure_from_bin(std::vector<(char)> bin) -> Structure"""
  return _plist.Structure_from_bin(*args)

class Array(Structure):
    """Proxy of C++ PList::Array class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> Array
        __init__(self) -> Array
        __init__(self, plist_t node, Node parent = None) -> Array
        __init__(self, Array a) -> Array
        """
        this = _plist.new_Array(*args)
        try: self.this.append(this)
        except: self.this = this
    def __assign__(self, *args):
        """__assign__(self, Array a) -> Array"""
        return _plist.Array___assign__(self, *args)

    __swig_destroy__ = _plist.delete_Array
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _plist.Array___deepcopy__(self)

    def __getitem__(self, *args):
        """__getitem__(self, unsigned int index) -> Node"""
        return _plist.Array___getitem__(self, *args)

    def append(self, *args):
        """append(self, Node node)"""
        return _plist.Array_append(self, *args)

    def insert(self, *args):
        """insert(self, Node node, unsigned int pos)"""
        return _plist.Array_insert(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, Node node)
        __delitem__(self, unsigned int pos)
        """
        return _plist.Array___delitem__(self, *args)

    def GetNodeIndex(self, *args):
        """GetNodeIndex(self, Node node) -> unsigned int"""
        return _plist.Array_GetNodeIndex(self, *args)

Array_swigregister = _plist.Array_swigregister
Array_swigregister(Array)

class Dictionary(Structure):
    """Proxy of C++ PList::Dictionary class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Node parent = None) -> Dictionary
        __init__(self) -> Dictionary
        __init__(self, plist_t node, Node parent = None) -> Dictionary
        __init__(self, Dictionary d) -> Dictionary
        """
        this = _plist.new_Dictionary(*args)
        try: self.this.append(this)
        except: self.this = this
    def __assign__(self, *args):
        """__assign__(self, Dictionary d) -> Dictionary"""
        return _plist.Dictionary___assign__(self, *args)

    __swig_destroy__ = _plist.delete_Dictionary
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(self) -> Node"""
        return _plist.Dictionary___deepcopy__(self)

    def __getitem__(self, *args):
        """__getitem__(self, string key) -> Node"""
        return _plist.Dictionary___getitem__(self, *args)

    def Find(self, *args):
        """Find(self, string key) -> iterator"""
        return _plist.Dictionary_Find(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, string key, Node node) -> iterator"""
        return _plist.Dictionary___setitem__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, Node node)
        __delitem__(self, string key)
        """
        return _plist.Dictionary___delitem__(self, *args)

    def GetNodeKey(self, *args):
        """GetNodeKey(self, Node key) -> string"""
        return _plist.Dictionary_GetNodeKey(self, *args)

    def key_iterator(self):
        """key_iterator(self) -> SwigPyIterator"""
        return _plist.Dictionary_key_iterator(self)

    def value_iterator(self):
        """value_iterator(self) -> SwigPyIterator"""
        return _plist.Dictionary_value_iterator(self)

    def iteritems(self):
        """iteritems(self) -> iterator"""
        return _plist.Dictionary_iteritems(self)

    def has_key(self, *args):
        """has_key(self, string key) -> bool"""
        return _plist.Dictionary_has_key(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _plist.Dictionary_keys(self)

    def values(self):
        """values(self) -> PyObject"""
        return _plist.Dictionary_values(self)

    def items(self):
        """items(self) -> PyObject"""
        return _plist.Dictionary_items(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
Dictionary_swigregister = _plist.Dictionary_swigregister
Dictionary_swigregister(Dictionary)

PLIST_BOOLEAN = _plist.PLIST_BOOLEAN
PLIST_UINT = _plist.PLIST_UINT
PLIST_REAL = _plist.PLIST_REAL
PLIST_STRING = _plist.PLIST_STRING
PLIST_ARRAY = _plist.PLIST_ARRAY
PLIST_DICT = _plist.PLIST_DICT
PLIST_DATE = _plist.PLIST_DATE
PLIST_DATA = _plist.PLIST_DATA
PLIST_KEY = _plist.PLIST_KEY
PLIST_NONE = _plist.PLIST_NONE


