# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.6
#
# 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
        fp = None
        try:
            fp, pathname, description = imp.find_module('_plist', [dirname(__file__)])
        except ImportError:
            import _plist
            return _plist
        if fp is not None:
            try:
                _mod = imp.load_module('_plist', fp, pathname, description)
            finally:
                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):
        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 - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _plist.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _plist.SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator 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__(std::pair<(std::string,p.PList::Node)> self) -> PairStringNodePtr
        __init__(std::pair<(std::string,p.PList::Node)> self, std::string __a, Node __b) -> PairStringNodePtr
        __init__(std::pair<(std::string,p.PList::Node)> 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(MapStringNodePtr self) -> SwigPyIterator"""
        return _plist.MapStringNodePtr_iterator(self)

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

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

    def __len__(self):
        """__len__(MapStringNodePtr self) -> std::map< std::string,PList::Node * >::size_type"""
        return _plist.MapStringNodePtr___len__(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 __getitem__(self, *args):
        """__getitem__(MapStringNodePtr self, std::map< std::string,PList::Node * >::key_type const & key) -> Node"""
        return _plist.MapStringNodePtr___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(MapStringNodePtr self, std::map< std::string,PList::Node * >::key_type const & key)"""
        return _plist.MapStringNodePtr___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(MapStringNodePtr self, std::map< std::string,PList::Node * >::key_type const & key) -> bool"""
        return _plist.MapStringNodePtr_has_key(self, *args)

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

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

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

    def __contains__(self, *args):
        """__contains__(MapStringNodePtr self, std::map< std::string,PList::Node * >::key_type const & key) -> bool"""
        return _plist.MapStringNodePtr___contains__(self, *args)

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

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

    def __setitem__(self, *args):
        """
        __setitem__(MapStringNodePtr self, std::map< std::string,PList::Node * >::key_type const & key)
        __setitem__(MapStringNodePtr self, std::map< std::string,PList::Node * >::key_type const & key, Node x)
        """
        return _plist.MapStringNodePtr___setitem__(self, *args)

    def asdict(self):
        """asdict(MapStringNodePtr self) -> PyObject *"""
        return _plist.MapStringNodePtr_asdict(self)

    def __init__(self, *args): 
        """
        __init__(std::map<(std::string,p.PList::Node)> self, std::less< std::string > const & arg2) -> MapStringNodePtr
        __init__(std::map<(std::string,p.PList::Node)> self) -> MapStringNodePtr
        __init__(std::map<(std::string,p.PList::Node)> self, MapStringNodePtr arg2) -> MapStringNodePtr
        """
        this = _plist.new_MapStringNodePtr(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(MapStringNodePtr self) -> bool"""
        return _plist.MapStringNodePtr_empty(self)

    def size(self):
        """size(MapStringNodePtr self) -> std::map< std::string,PList::Node * >::size_type"""
        return _plist.MapStringNodePtr_size(self)

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

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

    def get_allocator(self):
        """get_allocator(MapStringNodePtr self) -> std::map< std::string,PList::Node * >::allocator_type"""
        return _plist.MapStringNodePtr_get_allocator(self)

    def begin(self):
        """begin(MapStringNodePtr self) -> std::map< std::string,PList::Node * >::iterator"""
        return _plist.MapStringNodePtr_begin(self)

    def end(self):
        """end(MapStringNodePtr self) -> std::map< std::string,PList::Node * >::iterator"""
        return _plist.MapStringNodePtr_end(self)

    def rbegin(self):
        """rbegin(MapStringNodePtr self) -> std::map< std::string,PList::Node * >::reverse_iterator"""
        return _plist.MapStringNodePtr_rbegin(self)

    def rend(self):
        """rend(MapStringNodePtr self) -> std::map< std::string,PList::Node * >::reverse_iterator"""
        return _plist.MapStringNodePtr_rend(self)

    def count(self, *args):
        """count(MapStringNodePtr self, std::map< std::string,PList::Node * >::key_type const & x) -> std::map< std::string,PList::Node * >::size_type"""
        return _plist.MapStringNodePtr_count(self, *args)

    def erase(self, *args):
        """
        erase(MapStringNodePtr self, std::map< std::string,PList::Node * >::key_type const & x) -> std::map< std::string,PList::Node * >::size_type
        erase(MapStringNodePtr self, std::map< std::string,PList::Node * >::iterator position)
        erase(MapStringNodePtr self, std::map< std::string,PList::Node * >::iterator first, std::map< std::string,PList::Node * >::iterator last)
        """
        return _plist.MapStringNodePtr_erase(self, *args)

    def find(self, *args):
        """find(MapStringNodePtr self, std::map< std::string,PList::Node * >::key_type const & x) -> std::map< std::string,PList::Node * >::iterator"""
        return _plist.MapStringNodePtr_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(MapStringNodePtr self, std::map< std::string,PList::Node * >::key_type const & x) -> std::map< std::string,PList::Node * >::iterator"""
        return _plist.MapStringNodePtr_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(MapStringNodePtr self, std::map< std::string,PList::Node * >::key_type const & x) -> std::map< std::string,PList::Node * >::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 - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _plist.delete_Node
    __del__ = lambda self : None;
    def __deepcopy__(self):
        """__deepcopy__(Node self) -> Node"""
        return _plist.Node___deepcopy__(self)

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

    def get_type(self):
        """get_type(Node 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__(Boolean self, Boolean b) -> Boolean"""
        return _plist.Boolean___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(PList::Boolean self, Node parent=None) -> Boolean
        __init__(PList::Boolean self) -> Boolean
        __init__(PList::Boolean self, plist_t node, Node parent=None) -> Boolean
        __init__(PList::Boolean self, Boolean b) -> Boolean
        __init__(PList::Boolean 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__(Boolean self) -> Node"""
        return _plist.Boolean___deepcopy__(self)

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

    def get_value(self):
        """get_value(Boolean 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__(Integer self, Integer i) -> Integer"""
        return _plist.Integer___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(PList::Integer self, Node parent=None) -> Integer
        __init__(PList::Integer self) -> Integer
        __init__(PList::Integer self, plist_t node, Node parent=None) -> Integer
        __init__(PList::Integer self, Integer i) -> Integer
        __init__(PList::Integer 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__(Integer self) -> Node"""
        return _plist.Integer___deepcopy__(self)

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

    def get_value(self):
        """get_value(Integer 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__(Real self, Real d) -> Real"""
        return _plist.Real___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(PList::Real self, Node parent=None) -> Real
        __init__(PList::Real self) -> Real
        __init__(PList::Real self, plist_t node, Node parent=None) -> Real
        __init__(PList::Real self, Real d) -> Real
        __init__(PList::Real 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__(Real self) -> Node"""
        return _plist.Real___deepcopy__(self)

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

    def get_value(self):
        """get_value(Real 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__(String self, String s) -> String"""
        return _plist.String___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(PList::String self, Node parent=None) -> String
        __init__(PList::String self) -> String
        __init__(PList::String self, plist_t node, Node parent=None) -> String
        __init__(PList::String self, String s) -> String
        __init__(PList::String self, std::string const & 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__(String self) -> Node"""
        return _plist.String___deepcopy__(self)

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

    def get_value(self):
        """get_value(String self) -> std::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__(Data self, Data d) -> Data"""
        return _plist.Data___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(PList::Data self, Node parent=None) -> Data
        __init__(PList::Data self) -> Data
        __init__(PList::Data self, plist_t node, Node parent=None) -> Data
        __init__(PList::Data self, Data d) -> Data
        __init__(PList::Data self, std::vector< char > const & 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__(Data self) -> Node"""
        return _plist.Data___deepcopy__(self)

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

    def get_value(self):
        """get_value(Data 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__(Date self, Date d) -> Date"""
        return _plist.Date___assign__(self, *args)

    def __init__(self, *args): 
        """
        __init__(PList::Date self, Node parent=None) -> Date
        __init__(PList::Date self) -> Date
        __init__(PList::Date self, plist_t node, Node parent=None) -> Date
        __init__(PList::Date self, Date d) -> Date
        __init__(PList::Date 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__(Date self) -> Node"""
        return _plist.Date___deepcopy__(self)

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

    def get_value(self):
        """get_value(Date 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 - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _plist.delete_Structure
    __del__ = lambda self : None;
    def __len__(self):
        """__len__(Structure self) -> uint32_t"""
        return _plist.Structure___len__(self)

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

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

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

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

    from_xml = staticmethod(from_xml)
    def from_bin(*args):
        """from_bin(std::vector< char > const & 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(std::string const & xml) -> Structure"""
  return _plist.Structure_from_xml(*args)

def Structure_from_bin(*args):
  """Structure_from_bin(std::vector< char > const & 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__(PList::Array self, Node parent=None) -> Array
        __init__(PList::Array self) -> Array
        __init__(PList::Array self, plist_t node, Node parent=None) -> Array
        __init__(PList::Array self, Array a) -> Array
        """
        this = _plist.new_Array(*args)
        try: self.this.append(this)
        except: self.this = this
    def __assign__(self, *args):
        """__assign__(Array self, Array a) -> Array"""
        return _plist.Array___assign__(self, *args)

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

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

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

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

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

    def GetNodeIndex(self, *args):
        """GetNodeIndex(Array 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__(PList::Dictionary self, Node parent=None) -> Dictionary
        __init__(PList::Dictionary self) -> Dictionary
        __init__(PList::Dictionary self, plist_t node, Node parent=None) -> Dictionary
        __init__(PList::Dictionary self, Dictionary d) -> Dictionary
        """
        this = _plist.new_Dictionary(*args)
        try: self.this.append(this)
        except: self.this = this
    def __assign__(self, *args):
        """__assign__(Dictionary self, Dictionary d) -> Dictionary"""
        return _plist.Dictionary___assign__(self, *args)

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

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

    def Find(self, *args):
        """Find(Dictionary self, std::string const & key) -> PList::Dictionary::iterator"""
        return _plist.Dictionary_Find(self, *args)

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

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

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

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

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

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

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

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

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

    def items(self):
        """items(Dictionary 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


