python-ariapy 2.8.0+repack-1.2ubuntu1 / usr / lib / python2.7 / dist-packages / AriaPy.py

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




"""Python wrapper library for Aria"""


from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_AriaPy')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_AriaPy')
    _AriaPy = swig_import_helper()
    del swig_import_helper
elif _swig_python_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('_AriaPy', [dirname(__file__)])
        except ImportError:
            import _AriaPy
            return _AriaPy
        if fp is not None:
            try:
                _mod = imp.load_module('_AriaPy', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _AriaPy = swig_import_helper()
    del swig_import_helper
else:
    import _AriaPy
del _swig_python_version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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):
        object.__setattr__(self, 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("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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


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


try:
    import weakref
    weakref_proxy = weakref.proxy
except __builtin__.Exception:
    weakref_proxy = lambda x: x


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__ = _AriaPy.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _AriaPy.SwigPyIterator_value(self)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

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

class ArPoseWithTimeVector(object):
    """Proxy of C++ std::vector<(ArPoseWithTime)> 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(ArPoseWithTimeVector self) -> SwigPyIterator"""
        return _AriaPy.ArPoseWithTimeVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ArPoseWithTimeVector self) -> bool"""
        return _AriaPy.ArPoseWithTimeVector___nonzero__(self)


    def __bool__(self):
        """__bool__(ArPoseWithTimeVector self) -> bool"""
        return _AriaPy.ArPoseWithTimeVector___bool__(self)


    def __len__(self):
        """__len__(ArPoseWithTimeVector self) -> std::vector< ArPoseWithTime >::size_type"""
        return _AriaPy.ArPoseWithTimeVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::difference_type i, std::vector< ArPoseWithTime >::difference_type j) -> ArPoseWithTimeVector"""
        return _AriaPy.ArPoseWithTimeVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::difference_type i, std::vector< ArPoseWithTime >::difference_type j)
        __setslice__(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::difference_type i, std::vector< ArPoseWithTime >::difference_type j, ArPoseWithTimeVector v)
        """
        return _AriaPy.ArPoseWithTimeVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::difference_type i, std::vector< ArPoseWithTime >::difference_type j)"""
        return _AriaPy.ArPoseWithTimeVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::difference_type i)
        __delitem__(ArPoseWithTimeVector self, PySliceObject * slice)
        """
        return _AriaPy.ArPoseWithTimeVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ArPoseWithTimeVector self, PySliceObject * slice) -> ArPoseWithTimeVector
        __getitem__(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::difference_type i) -> ArPoseWithTime
        """
        return _AriaPy.ArPoseWithTimeVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ArPoseWithTimeVector self, PySliceObject * slice, ArPoseWithTimeVector v)
        __setitem__(ArPoseWithTimeVector self, PySliceObject * slice)
        __setitem__(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::difference_type i, ArPoseWithTime x)
        """
        return _AriaPy.ArPoseWithTimeVector___setitem__(self, *args)


    def pop(self):
        """pop(ArPoseWithTimeVector self) -> ArPoseWithTime"""
        return _AriaPy.ArPoseWithTimeVector_pop(self)


    def append(self, x):
        """append(ArPoseWithTimeVector self, ArPoseWithTime x)"""
        return _AriaPy.ArPoseWithTimeVector_append(self, x)


    def empty(self):
        """empty(ArPoseWithTimeVector self) -> bool"""
        return _AriaPy.ArPoseWithTimeVector_empty(self)


    def size(self):
        """size(ArPoseWithTimeVector self) -> std::vector< ArPoseWithTime >::size_type"""
        return _AriaPy.ArPoseWithTimeVector_size(self)


    def swap(self, v):
        """swap(ArPoseWithTimeVector self, ArPoseWithTimeVector v)"""
        return _AriaPy.ArPoseWithTimeVector_swap(self, v)


    def begin(self):
        """begin(ArPoseWithTimeVector self) -> std::vector< ArPoseWithTime >::iterator"""
        return _AriaPy.ArPoseWithTimeVector_begin(self)


    def end(self):
        """end(ArPoseWithTimeVector self) -> std::vector< ArPoseWithTime >::iterator"""
        return _AriaPy.ArPoseWithTimeVector_end(self)


    def rbegin(self):
        """rbegin(ArPoseWithTimeVector self) -> std::vector< ArPoseWithTime >::reverse_iterator"""
        return _AriaPy.ArPoseWithTimeVector_rbegin(self)


    def rend(self):
        """rend(ArPoseWithTimeVector self) -> std::vector< ArPoseWithTime >::reverse_iterator"""
        return _AriaPy.ArPoseWithTimeVector_rend(self)


    def clear(self):
        """clear(ArPoseWithTimeVector self)"""
        return _AriaPy.ArPoseWithTimeVector_clear(self)


    def get_allocator(self):
        """get_allocator(ArPoseWithTimeVector self) -> std::vector< ArPoseWithTime >::allocator_type"""
        return _AriaPy.ArPoseWithTimeVector_get_allocator(self)


    def pop_back(self):
        """pop_back(ArPoseWithTimeVector self)"""
        return _AriaPy.ArPoseWithTimeVector_pop_back(self)


    def erase(self, *args):
        """
        erase(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::iterator pos) -> std::vector< ArPoseWithTime >::iterator
        erase(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::iterator first, std::vector< ArPoseWithTime >::iterator last) -> std::vector< ArPoseWithTime >::iterator
        """
        return _AriaPy.ArPoseWithTimeVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(ArPoseWithTime)> self) -> ArPoseWithTimeVector
        __init__(std::vector<(ArPoseWithTime)> self, ArPoseWithTimeVector arg2) -> ArPoseWithTimeVector
        __init__(std::vector<(ArPoseWithTime)> self, std::vector< ArPoseWithTime >::size_type size) -> ArPoseWithTimeVector
        __init__(std::vector<(ArPoseWithTime)> self, std::vector< ArPoseWithTime >::size_type size, ArPoseWithTime value) -> ArPoseWithTimeVector
        """
        this = _AriaPy.new_ArPoseWithTimeVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ArPoseWithTimeVector self, ArPoseWithTime x)"""
        return _AriaPy.ArPoseWithTimeVector_push_back(self, x)


    def front(self):
        """front(ArPoseWithTimeVector self) -> ArPoseWithTime"""
        return _AriaPy.ArPoseWithTimeVector_front(self)


    def back(self):
        """back(ArPoseWithTimeVector self) -> ArPoseWithTime"""
        return _AriaPy.ArPoseWithTimeVector_back(self)


    def assign(self, n, x):
        """assign(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::size_type n, ArPoseWithTime x)"""
        return _AriaPy.ArPoseWithTimeVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::size_type new_size)
        resize(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::size_type new_size, ArPoseWithTime x)
        """
        return _AriaPy.ArPoseWithTimeVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::iterator pos, ArPoseWithTime x) -> std::vector< ArPoseWithTime >::iterator
        insert(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::iterator pos, std::vector< ArPoseWithTime >::size_type n, ArPoseWithTime x)
        """
        return _AriaPy.ArPoseWithTimeVector_insert(self, *args)


    def reserve(self, n):
        """reserve(ArPoseWithTimeVector self, std::vector< ArPoseWithTime >::size_type n)"""
        return _AriaPy.ArPoseWithTimeVector_reserve(self, n)


    def capacity(self):
        """capacity(ArPoseWithTimeVector self) -> std::vector< ArPoseWithTime >::size_type"""
        return _AriaPy.ArPoseWithTimeVector_capacity(self)

    __swig_destroy__ = _AriaPy.delete_ArPoseWithTimeVector
    __del__ = lambda self: None
ArPoseWithTimeVector_swigregister = _AriaPy.ArPoseWithTimeVector_swigregister
ArPoseWithTimeVector_swigregister(ArPoseWithTimeVector)

class ArSensorReadingVector(object):
    """Proxy of C++ std::vector<(ArSensorReading)> 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(ArSensorReadingVector self) -> SwigPyIterator"""
        return _AriaPy.ArSensorReadingVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ArSensorReadingVector self) -> bool"""
        return _AriaPy.ArSensorReadingVector___nonzero__(self)


    def __bool__(self):
        """__bool__(ArSensorReadingVector self) -> bool"""
        return _AriaPy.ArSensorReadingVector___bool__(self)


    def __len__(self):
        """__len__(ArSensorReadingVector self) -> std::vector< ArSensorReading >::size_type"""
        return _AriaPy.ArSensorReadingVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ArSensorReadingVector self, std::vector< ArSensorReading >::difference_type i, std::vector< ArSensorReading >::difference_type j) -> ArSensorReadingVector"""
        return _AriaPy.ArSensorReadingVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ArSensorReadingVector self, std::vector< ArSensorReading >::difference_type i, std::vector< ArSensorReading >::difference_type j)
        __setslice__(ArSensorReadingVector self, std::vector< ArSensorReading >::difference_type i, std::vector< ArSensorReading >::difference_type j, ArSensorReadingVector v)
        """
        return _AriaPy.ArSensorReadingVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ArSensorReadingVector self, std::vector< ArSensorReading >::difference_type i, std::vector< ArSensorReading >::difference_type j)"""
        return _AriaPy.ArSensorReadingVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ArSensorReadingVector self, std::vector< ArSensorReading >::difference_type i)
        __delitem__(ArSensorReadingVector self, PySliceObject * slice)
        """
        return _AriaPy.ArSensorReadingVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ArSensorReadingVector self, PySliceObject * slice) -> ArSensorReadingVector
        __getitem__(ArSensorReadingVector self, std::vector< ArSensorReading >::difference_type i) -> ArSensorReading
        """
        return _AriaPy.ArSensorReadingVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ArSensorReadingVector self, PySliceObject * slice, ArSensorReadingVector v)
        __setitem__(ArSensorReadingVector self, PySliceObject * slice)
        __setitem__(ArSensorReadingVector self, std::vector< ArSensorReading >::difference_type i, ArSensorReading x)
        """
        return _AriaPy.ArSensorReadingVector___setitem__(self, *args)


    def pop(self):
        """pop(ArSensorReadingVector self) -> ArSensorReading"""
        return _AriaPy.ArSensorReadingVector_pop(self)


    def append(self, x):
        """append(ArSensorReadingVector self, ArSensorReading x)"""
        return _AriaPy.ArSensorReadingVector_append(self, x)


    def empty(self):
        """empty(ArSensorReadingVector self) -> bool"""
        return _AriaPy.ArSensorReadingVector_empty(self)


    def size(self):
        """size(ArSensorReadingVector self) -> std::vector< ArSensorReading >::size_type"""
        return _AriaPy.ArSensorReadingVector_size(self)


    def swap(self, v):
        """swap(ArSensorReadingVector self, ArSensorReadingVector v)"""
        return _AriaPy.ArSensorReadingVector_swap(self, v)


    def begin(self):
        """begin(ArSensorReadingVector self) -> std::vector< ArSensorReading >::iterator"""
        return _AriaPy.ArSensorReadingVector_begin(self)


    def end(self):
        """end(ArSensorReadingVector self) -> std::vector< ArSensorReading >::iterator"""
        return _AriaPy.ArSensorReadingVector_end(self)


    def rbegin(self):
        """rbegin(ArSensorReadingVector self) -> std::vector< ArSensorReading >::reverse_iterator"""
        return _AriaPy.ArSensorReadingVector_rbegin(self)


    def rend(self):
        """rend(ArSensorReadingVector self) -> std::vector< ArSensorReading >::reverse_iterator"""
        return _AriaPy.ArSensorReadingVector_rend(self)


    def clear(self):
        """clear(ArSensorReadingVector self)"""
        return _AriaPy.ArSensorReadingVector_clear(self)


    def get_allocator(self):
        """get_allocator(ArSensorReadingVector self) -> std::vector< ArSensorReading >::allocator_type"""
        return _AriaPy.ArSensorReadingVector_get_allocator(self)


    def pop_back(self):
        """pop_back(ArSensorReadingVector self)"""
        return _AriaPy.ArSensorReadingVector_pop_back(self)


    def erase(self, *args):
        """
        erase(ArSensorReadingVector self, std::vector< ArSensorReading >::iterator pos) -> std::vector< ArSensorReading >::iterator
        erase(ArSensorReadingVector self, std::vector< ArSensorReading >::iterator first, std::vector< ArSensorReading >::iterator last) -> std::vector< ArSensorReading >::iterator
        """
        return _AriaPy.ArSensorReadingVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(ArSensorReading)> self) -> ArSensorReadingVector
        __init__(std::vector<(ArSensorReading)> self, ArSensorReadingVector arg2) -> ArSensorReadingVector
        __init__(std::vector<(ArSensorReading)> self, std::vector< ArSensorReading >::size_type size) -> ArSensorReadingVector
        __init__(std::vector<(ArSensorReading)> self, std::vector< ArSensorReading >::size_type size, ArSensorReading value) -> ArSensorReadingVector
        """
        this = _AriaPy.new_ArSensorReadingVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ArSensorReadingVector self, ArSensorReading x)"""
        return _AriaPy.ArSensorReadingVector_push_back(self, x)


    def front(self):
        """front(ArSensorReadingVector self) -> ArSensorReading"""
        return _AriaPy.ArSensorReadingVector_front(self)


    def back(self):
        """back(ArSensorReadingVector self) -> ArSensorReading"""
        return _AriaPy.ArSensorReadingVector_back(self)


    def assign(self, n, x):
        """assign(ArSensorReadingVector self, std::vector< ArSensorReading >::size_type n, ArSensorReading x)"""
        return _AriaPy.ArSensorReadingVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ArSensorReadingVector self, std::vector< ArSensorReading >::size_type new_size)
        resize(ArSensorReadingVector self, std::vector< ArSensorReading >::size_type new_size, ArSensorReading x)
        """
        return _AriaPy.ArSensorReadingVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(ArSensorReadingVector self, std::vector< ArSensorReading >::iterator pos, ArSensorReading x) -> std::vector< ArSensorReading >::iterator
        insert(ArSensorReadingVector self, std::vector< ArSensorReading >::iterator pos, std::vector< ArSensorReading >::size_type n, ArSensorReading x)
        """
        return _AriaPy.ArSensorReadingVector_insert(self, *args)


    def reserve(self, n):
        """reserve(ArSensorReadingVector self, std::vector< ArSensorReading >::size_type n)"""
        return _AriaPy.ArSensorReadingVector_reserve(self, n)


    def capacity(self):
        """capacity(ArSensorReadingVector self) -> std::vector< ArSensorReading >::size_type"""
        return _AriaPy.ArSensorReadingVector_capacity(self)

    __swig_destroy__ = _AriaPy.delete_ArSensorReadingVector
    __del__ = lambda self: None
ArSensorReadingVector_swigregister = _AriaPy.ArSensorReadingVector_swigregister
ArSensorReadingVector_swigregister(ArSensorReadingVector)

class DoubleVector(object):
    """Proxy of C++ std::vector<(double)> 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(DoubleVector self) -> SwigPyIterator"""
        return _AriaPy.DoubleVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(DoubleVector self) -> bool"""
        return _AriaPy.DoubleVector___nonzero__(self)


    def __bool__(self):
        """__bool__(DoubleVector self) -> bool"""
        return _AriaPy.DoubleVector___bool__(self)


    def __len__(self):
        """__len__(DoubleVector self) -> std::vector< double >::size_type"""
        return _AriaPy.DoubleVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> DoubleVector"""
        return _AriaPy.DoubleVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, DoubleVector v)
        """
        return _AriaPy.DoubleVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _AriaPy.DoubleVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(DoubleVector self, std::vector< double >::difference_type i)
        __delitem__(DoubleVector self, PySliceObject * slice)
        """
        return _AriaPy.DoubleVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(DoubleVector self, PySliceObject * slice) -> DoubleVector
        __getitem__(DoubleVector self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _AriaPy.DoubleVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(DoubleVector self, PySliceObject * slice, DoubleVector v)
        __setitem__(DoubleVector self, PySliceObject * slice)
        __setitem__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _AriaPy.DoubleVector___setitem__(self, *args)


    def pop(self):
        """pop(DoubleVector self) -> std::vector< double >::value_type"""
        return _AriaPy.DoubleVector_pop(self)


    def append(self, x):
        """append(DoubleVector self, std::vector< double >::value_type const & x)"""
        return _AriaPy.DoubleVector_append(self, x)


    def empty(self):
        """empty(DoubleVector self) -> bool"""
        return _AriaPy.DoubleVector_empty(self)


    def size(self):
        """size(DoubleVector self) -> std::vector< double >::size_type"""
        return _AriaPy.DoubleVector_size(self)


    def swap(self, v):
        """swap(DoubleVector self, DoubleVector v)"""
        return _AriaPy.DoubleVector_swap(self, v)


    def begin(self):
        """begin(DoubleVector self) -> std::vector< double >::iterator"""
        return _AriaPy.DoubleVector_begin(self)


    def end(self):
        """end(DoubleVector self) -> std::vector< double >::iterator"""
        return _AriaPy.DoubleVector_end(self)


    def rbegin(self):
        """rbegin(DoubleVector self) -> std::vector< double >::reverse_iterator"""
        return _AriaPy.DoubleVector_rbegin(self)


    def rend(self):
        """rend(DoubleVector self) -> std::vector< double >::reverse_iterator"""
        return _AriaPy.DoubleVector_rend(self)


    def clear(self):
        """clear(DoubleVector self)"""
        return _AriaPy.DoubleVector_clear(self)


    def get_allocator(self):
        """get_allocator(DoubleVector self) -> std::vector< double >::allocator_type"""
        return _AriaPy.DoubleVector_get_allocator(self)


    def pop_back(self):
        """pop_back(DoubleVector self)"""
        return _AriaPy.DoubleVector_pop_back(self)


    def erase(self, *args):
        """
        erase(DoubleVector self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(DoubleVector self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _AriaPy.DoubleVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(double)> self) -> DoubleVector
        __init__(std::vector<(double)> self, DoubleVector arg2) -> DoubleVector
        __init__(std::vector<(double)> self, std::vector< double >::size_type size) -> DoubleVector
        __init__(std::vector<(double)> self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> DoubleVector
        """
        this = _AriaPy.new_DoubleVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(DoubleVector self, std::vector< double >::value_type const & x)"""
        return _AriaPy.DoubleVector_push_back(self, x)


    def front(self):
        """front(DoubleVector self) -> std::vector< double >::value_type const &"""
        return _AriaPy.DoubleVector_front(self)


    def back(self):
        """back(DoubleVector self) -> std::vector< double >::value_type const &"""
        return _AriaPy.DoubleVector_back(self)


    def assign(self, n, x):
        """assign(DoubleVector self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _AriaPy.DoubleVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(DoubleVector self, std::vector< double >::size_type new_size)
        resize(DoubleVector self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _AriaPy.DoubleVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(DoubleVector self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(DoubleVector self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _AriaPy.DoubleVector_insert(self, *args)


    def reserve(self, n):
        """reserve(DoubleVector self, std::vector< double >::size_type n)"""
        return _AriaPy.DoubleVector_reserve(self, n)


    def capacity(self):
        """capacity(DoubleVector self) -> std::vector< double >::size_type"""
        return _AriaPy.DoubleVector_capacity(self)

    __swig_destroy__ = _AriaPy.delete_DoubleVector
    __del__ = lambda self: None
DoubleVector_swigregister = _AriaPy.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class ArMapObjectPtrList(object):
    """Proxy of C++ std::list<(p.ArMapObject)> 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(ArMapObjectPtrList self) -> SwigPyIterator"""
        return _AriaPy.ArMapObjectPtrList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ArMapObjectPtrList self) -> bool"""
        return _AriaPy.ArMapObjectPtrList___nonzero__(self)


    def __bool__(self):
        """__bool__(ArMapObjectPtrList self) -> bool"""
        return _AriaPy.ArMapObjectPtrList___bool__(self)


    def __len__(self):
        """__len__(ArMapObjectPtrList self) -> std::list< ArMapObject * >::size_type"""
        return _AriaPy.ArMapObjectPtrList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ArMapObjectPtrList self, std::list< ArMapObject * >::difference_type i, std::list< ArMapObject * >::difference_type j) -> ArMapObjectPtrList"""
        return _AriaPy.ArMapObjectPtrList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ArMapObjectPtrList self, std::list< ArMapObject * >::difference_type i, std::list< ArMapObject * >::difference_type j)
        __setslice__(ArMapObjectPtrList self, std::list< ArMapObject * >::difference_type i, std::list< ArMapObject * >::difference_type j, ArMapObjectPtrList v)
        """
        return _AriaPy.ArMapObjectPtrList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ArMapObjectPtrList self, std::list< ArMapObject * >::difference_type i, std::list< ArMapObject * >::difference_type j)"""
        return _AriaPy.ArMapObjectPtrList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ArMapObjectPtrList self, std::list< ArMapObject * >::difference_type i)
        __delitem__(ArMapObjectPtrList self, PySliceObject * slice)
        """
        return _AriaPy.ArMapObjectPtrList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ArMapObjectPtrList self, PySliceObject * slice) -> ArMapObjectPtrList
        __getitem__(ArMapObjectPtrList self, std::list< ArMapObject * >::difference_type i) -> ArMapObject
        """
        return _AriaPy.ArMapObjectPtrList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ArMapObjectPtrList self, PySliceObject * slice, ArMapObjectPtrList v)
        __setitem__(ArMapObjectPtrList self, PySliceObject * slice)
        __setitem__(ArMapObjectPtrList self, std::list< ArMapObject * >::difference_type i, ArMapObject x)
        """
        return _AriaPy.ArMapObjectPtrList___setitem__(self, *args)


    def pop(self):
        """pop(ArMapObjectPtrList self) -> ArMapObject"""
        return _AriaPy.ArMapObjectPtrList_pop(self)


    def append(self, x):
        """append(ArMapObjectPtrList self, ArMapObject x)"""
        return _AriaPy.ArMapObjectPtrList_append(self, x)


    def empty(self):
        """empty(ArMapObjectPtrList self) -> bool"""
        return _AriaPy.ArMapObjectPtrList_empty(self)


    def size(self):
        """size(ArMapObjectPtrList self) -> std::list< ArMapObject * >::size_type"""
        return _AriaPy.ArMapObjectPtrList_size(self)


    def swap(self, v):
        """swap(ArMapObjectPtrList self, ArMapObjectPtrList v)"""
        return _AriaPy.ArMapObjectPtrList_swap(self, v)


    def begin(self):
        """begin(ArMapObjectPtrList self) -> std::list< ArMapObject * >::iterator"""
        return _AriaPy.ArMapObjectPtrList_begin(self)


    def end(self):
        """end(ArMapObjectPtrList self) -> std::list< ArMapObject * >::iterator"""
        return _AriaPy.ArMapObjectPtrList_end(self)


    def rbegin(self):
        """rbegin(ArMapObjectPtrList self) -> std::list< ArMapObject * >::reverse_iterator"""
        return _AriaPy.ArMapObjectPtrList_rbegin(self)


    def rend(self):
        """rend(ArMapObjectPtrList self) -> std::list< ArMapObject * >::reverse_iterator"""
        return _AriaPy.ArMapObjectPtrList_rend(self)


    def clear(self):
        """clear(ArMapObjectPtrList self)"""
        return _AriaPy.ArMapObjectPtrList_clear(self)


    def get_allocator(self):
        """get_allocator(ArMapObjectPtrList self) -> std::list< ArMapObject * >::allocator_type"""
        return _AriaPy.ArMapObjectPtrList_get_allocator(self)


    def pop_back(self):
        """pop_back(ArMapObjectPtrList self)"""
        return _AriaPy.ArMapObjectPtrList_pop_back(self)


    def erase(self, *args):
        """
        erase(ArMapObjectPtrList self, std::list< ArMapObject * >::iterator pos) -> std::list< ArMapObject * >::iterator
        erase(ArMapObjectPtrList self, std::list< ArMapObject * >::iterator first, std::list< ArMapObject * >::iterator last) -> std::list< ArMapObject * >::iterator
        """
        return _AriaPy.ArMapObjectPtrList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(p.ArMapObject)> self) -> ArMapObjectPtrList
        __init__(std::list<(p.ArMapObject)> self, ArMapObjectPtrList arg2) -> ArMapObjectPtrList
        __init__(std::list<(p.ArMapObject)> self, std::list< ArMapObject * >::size_type size) -> ArMapObjectPtrList
        __init__(std::list<(p.ArMapObject)> self, std::list< ArMapObject * >::size_type size, ArMapObject value) -> ArMapObjectPtrList
        """
        this = _AriaPy.new_ArMapObjectPtrList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ArMapObjectPtrList self, ArMapObject x)"""
        return _AriaPy.ArMapObjectPtrList_push_back(self, x)


    def front(self):
        """front(ArMapObjectPtrList self) -> ArMapObject"""
        return _AriaPy.ArMapObjectPtrList_front(self)


    def back(self):
        """back(ArMapObjectPtrList self) -> ArMapObject"""
        return _AriaPy.ArMapObjectPtrList_back(self)


    def assign(self, n, x):
        """assign(ArMapObjectPtrList self, std::list< ArMapObject * >::size_type n, ArMapObject x)"""
        return _AriaPy.ArMapObjectPtrList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ArMapObjectPtrList self, std::list< ArMapObject * >::size_type new_size)
        resize(ArMapObjectPtrList self, std::list< ArMapObject * >::size_type new_size, ArMapObject x)
        """
        return _AriaPy.ArMapObjectPtrList_resize(self, *args)


    def insert(self, *args):
        """
        insert(ArMapObjectPtrList self, std::list< ArMapObject * >::iterator pos, ArMapObject x) -> std::list< ArMapObject * >::iterator
        insert(ArMapObjectPtrList self, std::list< ArMapObject * >::iterator pos, std::list< ArMapObject * >::size_type n, ArMapObject x)
        """
        return _AriaPy.ArMapObjectPtrList_insert(self, *args)


    def pop_front(self):
        """pop_front(ArMapObjectPtrList self)"""
        return _AriaPy.ArMapObjectPtrList_pop_front(self)


    def push_front(self, x):
        """push_front(ArMapObjectPtrList self, ArMapObject x)"""
        return _AriaPy.ArMapObjectPtrList_push_front(self, x)


    def remove(self, x):
        """remove(ArMapObjectPtrList self, ArMapObject x)"""
        return _AriaPy.ArMapObjectPtrList_remove(self, x)


    def unique(self):
        """unique(ArMapObjectPtrList self)"""
        return _AriaPy.ArMapObjectPtrList_unique(self)


    def reverse(self):
        """reverse(ArMapObjectPtrList self)"""
        return _AriaPy.ArMapObjectPtrList_reverse(self)


    def sort(self):
        """sort(ArMapObjectPtrList self)"""
        return _AriaPy.ArMapObjectPtrList_sort(self)


    def merge(self, x):
        """merge(ArMapObjectPtrList self, ArMapObjectPtrList x)"""
        return _AriaPy.ArMapObjectPtrList_merge(self, x)

    __swig_destroy__ = _AriaPy.delete_ArMapObjectPtrList
    __del__ = lambda self: None
ArMapObjectPtrList_swigregister = _AriaPy.ArMapObjectPtrList_swigregister
ArMapObjectPtrList_swigregister(ArMapObjectPtrList)

class ArFunctorPtrList(object):
    """Proxy of C++ std::list<(p.ArFunctor)> 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(ArFunctorPtrList self) -> SwigPyIterator"""
        return _AriaPy.ArFunctorPtrList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ArFunctorPtrList self) -> bool"""
        return _AriaPy.ArFunctorPtrList___nonzero__(self)


    def __bool__(self):
        """__bool__(ArFunctorPtrList self) -> bool"""
        return _AriaPy.ArFunctorPtrList___bool__(self)


    def __len__(self):
        """__len__(ArFunctorPtrList self) -> std::list< ArFunctor * >::size_type"""
        return _AriaPy.ArFunctorPtrList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ArFunctorPtrList self, std::list< ArFunctor * >::difference_type i, std::list< ArFunctor * >::difference_type j) -> ArFunctorPtrList"""
        return _AriaPy.ArFunctorPtrList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ArFunctorPtrList self, std::list< ArFunctor * >::difference_type i, std::list< ArFunctor * >::difference_type j)
        __setslice__(ArFunctorPtrList self, std::list< ArFunctor * >::difference_type i, std::list< ArFunctor * >::difference_type j, ArFunctorPtrList v)
        """
        return _AriaPy.ArFunctorPtrList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ArFunctorPtrList self, std::list< ArFunctor * >::difference_type i, std::list< ArFunctor * >::difference_type j)"""
        return _AriaPy.ArFunctorPtrList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ArFunctorPtrList self, std::list< ArFunctor * >::difference_type i)
        __delitem__(ArFunctorPtrList self, PySliceObject * slice)
        """
        return _AriaPy.ArFunctorPtrList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ArFunctorPtrList self, PySliceObject * slice) -> ArFunctorPtrList
        __getitem__(ArFunctorPtrList self, std::list< ArFunctor * >::difference_type i) -> ArFunctor
        """
        return _AriaPy.ArFunctorPtrList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ArFunctorPtrList self, PySliceObject * slice, ArFunctorPtrList v)
        __setitem__(ArFunctorPtrList self, PySliceObject * slice)
        __setitem__(ArFunctorPtrList self, std::list< ArFunctor * >::difference_type i, ArFunctor x)
        """
        return _AriaPy.ArFunctorPtrList___setitem__(self, *args)


    def pop(self):
        """pop(ArFunctorPtrList self) -> ArFunctor"""
        return _AriaPy.ArFunctorPtrList_pop(self)


    def append(self, x):
        """append(ArFunctorPtrList self, ArFunctor x)"""
        return _AriaPy.ArFunctorPtrList_append(self, x)


    def empty(self):
        """empty(ArFunctorPtrList self) -> bool"""
        return _AriaPy.ArFunctorPtrList_empty(self)


    def size(self):
        """size(ArFunctorPtrList self) -> std::list< ArFunctor * >::size_type"""
        return _AriaPy.ArFunctorPtrList_size(self)


    def swap(self, v):
        """swap(ArFunctorPtrList self, ArFunctorPtrList v)"""
        return _AriaPy.ArFunctorPtrList_swap(self, v)


    def begin(self):
        """begin(ArFunctorPtrList self) -> std::list< ArFunctor * >::iterator"""
        return _AriaPy.ArFunctorPtrList_begin(self)


    def end(self):
        """end(ArFunctorPtrList self) -> std::list< ArFunctor * >::iterator"""
        return _AriaPy.ArFunctorPtrList_end(self)


    def rbegin(self):
        """rbegin(ArFunctorPtrList self) -> std::list< ArFunctor * >::reverse_iterator"""
        return _AriaPy.ArFunctorPtrList_rbegin(self)


    def rend(self):
        """rend(ArFunctorPtrList self) -> std::list< ArFunctor * >::reverse_iterator"""
        return _AriaPy.ArFunctorPtrList_rend(self)


    def clear(self):
        """clear(ArFunctorPtrList self)"""
        return _AriaPy.ArFunctorPtrList_clear(self)


    def get_allocator(self):
        """get_allocator(ArFunctorPtrList self) -> std::list< ArFunctor * >::allocator_type"""
        return _AriaPy.ArFunctorPtrList_get_allocator(self)


    def pop_back(self):
        """pop_back(ArFunctorPtrList self)"""
        return _AriaPy.ArFunctorPtrList_pop_back(self)


    def erase(self, *args):
        """
        erase(ArFunctorPtrList self, std::list< ArFunctor * >::iterator pos) -> std::list< ArFunctor * >::iterator
        erase(ArFunctorPtrList self, std::list< ArFunctor * >::iterator first, std::list< ArFunctor * >::iterator last) -> std::list< ArFunctor * >::iterator
        """
        return _AriaPy.ArFunctorPtrList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(p.ArFunctor)> self) -> ArFunctorPtrList
        __init__(std::list<(p.ArFunctor)> self, ArFunctorPtrList arg2) -> ArFunctorPtrList
        __init__(std::list<(p.ArFunctor)> self, std::list< ArFunctor * >::size_type size) -> ArFunctorPtrList
        __init__(std::list<(p.ArFunctor)> self, std::list< ArFunctor * >::size_type size, ArFunctor value) -> ArFunctorPtrList
        """
        this = _AriaPy.new_ArFunctorPtrList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ArFunctorPtrList self, ArFunctor x)"""
        return _AriaPy.ArFunctorPtrList_push_back(self, x)


    def front(self):
        """front(ArFunctorPtrList self) -> ArFunctor"""
        return _AriaPy.ArFunctorPtrList_front(self)


    def back(self):
        """back(ArFunctorPtrList self) -> ArFunctor"""
        return _AriaPy.ArFunctorPtrList_back(self)


    def assign(self, n, x):
        """assign(ArFunctorPtrList self, std::list< ArFunctor * >::size_type n, ArFunctor x)"""
        return _AriaPy.ArFunctorPtrList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ArFunctorPtrList self, std::list< ArFunctor * >::size_type new_size)
        resize(ArFunctorPtrList self, std::list< ArFunctor * >::size_type new_size, ArFunctor x)
        """
        return _AriaPy.ArFunctorPtrList_resize(self, *args)


    def insert(self, *args):
        """
        insert(ArFunctorPtrList self, std::list< ArFunctor * >::iterator pos, ArFunctor x) -> std::list< ArFunctor * >::iterator
        insert(ArFunctorPtrList self, std::list< ArFunctor * >::iterator pos, std::list< ArFunctor * >::size_type n, ArFunctor x)
        """
        return _AriaPy.ArFunctorPtrList_insert(self, *args)


    def pop_front(self):
        """pop_front(ArFunctorPtrList self)"""
        return _AriaPy.ArFunctorPtrList_pop_front(self)


    def push_front(self, x):
        """push_front(ArFunctorPtrList self, ArFunctor x)"""
        return _AriaPy.ArFunctorPtrList_push_front(self, x)


    def remove(self, x):
        """remove(ArFunctorPtrList self, ArFunctor x)"""
        return _AriaPy.ArFunctorPtrList_remove(self, x)


    def unique(self):
        """unique(ArFunctorPtrList self)"""
        return _AriaPy.ArFunctorPtrList_unique(self)


    def reverse(self):
        """reverse(ArFunctorPtrList self)"""
        return _AriaPy.ArFunctorPtrList_reverse(self)


    def sort(self):
        """sort(ArFunctorPtrList self)"""
        return _AriaPy.ArFunctorPtrList_sort(self)


    def merge(self, x):
        """merge(ArFunctorPtrList self, ArFunctorPtrList x)"""
        return _AriaPy.ArFunctorPtrList_merge(self, x)

    __swig_destroy__ = _AriaPy.delete_ArFunctorPtrList
    __del__ = lambda self: None
ArFunctorPtrList_swigregister = _AriaPy.ArFunctorPtrList_swigregister
ArFunctorPtrList_swigregister(ArFunctorPtrList)

class ArPoseList(object):
    """Proxy of C++ std::list<(ArPose)> 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(ArPoseList self) -> SwigPyIterator"""
        return _AriaPy.ArPoseList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ArPoseList self) -> bool"""
        return _AriaPy.ArPoseList___nonzero__(self)


    def __bool__(self):
        """__bool__(ArPoseList self) -> bool"""
        return _AriaPy.ArPoseList___bool__(self)


    def __len__(self):
        """__len__(ArPoseList self) -> std::list< ArPose >::size_type"""
        return _AriaPy.ArPoseList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ArPoseList self, std::list< ArPose >::difference_type i, std::list< ArPose >::difference_type j) -> ArPoseList"""
        return _AriaPy.ArPoseList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ArPoseList self, std::list< ArPose >::difference_type i, std::list< ArPose >::difference_type j)
        __setslice__(ArPoseList self, std::list< ArPose >::difference_type i, std::list< ArPose >::difference_type j, ArPoseList v)
        """
        return _AriaPy.ArPoseList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ArPoseList self, std::list< ArPose >::difference_type i, std::list< ArPose >::difference_type j)"""
        return _AriaPy.ArPoseList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ArPoseList self, std::list< ArPose >::difference_type i)
        __delitem__(ArPoseList self, PySliceObject * slice)
        """
        return _AriaPy.ArPoseList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ArPoseList self, PySliceObject * slice) -> ArPoseList
        __getitem__(ArPoseList self, std::list< ArPose >::difference_type i) -> ArPose
        """
        return _AriaPy.ArPoseList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ArPoseList self, PySliceObject * slice, ArPoseList v)
        __setitem__(ArPoseList self, PySliceObject * slice)
        __setitem__(ArPoseList self, std::list< ArPose >::difference_type i, ArPose x)
        """
        return _AriaPy.ArPoseList___setitem__(self, *args)


    def pop(self):
        """pop(ArPoseList self) -> ArPose"""
        return _AriaPy.ArPoseList_pop(self)


    def append(self, x):
        """append(ArPoseList self, ArPose x)"""
        return _AriaPy.ArPoseList_append(self, x)


    def empty(self):
        """empty(ArPoseList self) -> bool"""
        return _AriaPy.ArPoseList_empty(self)


    def size(self):
        """size(ArPoseList self) -> std::list< ArPose >::size_type"""
        return _AriaPy.ArPoseList_size(self)


    def swap(self, v):
        """swap(ArPoseList self, ArPoseList v)"""
        return _AriaPy.ArPoseList_swap(self, v)


    def begin(self):
        """begin(ArPoseList self) -> std::list< ArPose >::iterator"""
        return _AriaPy.ArPoseList_begin(self)


    def end(self):
        """end(ArPoseList self) -> std::list< ArPose >::iterator"""
        return _AriaPy.ArPoseList_end(self)


    def rbegin(self):
        """rbegin(ArPoseList self) -> std::list< ArPose >::reverse_iterator"""
        return _AriaPy.ArPoseList_rbegin(self)


    def rend(self):
        """rend(ArPoseList self) -> std::list< ArPose >::reverse_iterator"""
        return _AriaPy.ArPoseList_rend(self)


    def clear(self):
        """clear(ArPoseList self)"""
        return _AriaPy.ArPoseList_clear(self)


    def get_allocator(self):
        """get_allocator(ArPoseList self) -> std::list< ArPose >::allocator_type"""
        return _AriaPy.ArPoseList_get_allocator(self)


    def pop_back(self):
        """pop_back(ArPoseList self)"""
        return _AriaPy.ArPoseList_pop_back(self)


    def erase(self, *args):
        """
        erase(ArPoseList self, std::list< ArPose >::iterator pos) -> std::list< ArPose >::iterator
        erase(ArPoseList self, std::list< ArPose >::iterator first, std::list< ArPose >::iterator last) -> std::list< ArPose >::iterator
        """
        return _AriaPy.ArPoseList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(ArPose)> self) -> ArPoseList
        __init__(std::list<(ArPose)> self, ArPoseList arg2) -> ArPoseList
        __init__(std::list<(ArPose)> self, std::list< ArPose >::size_type size) -> ArPoseList
        __init__(std::list<(ArPose)> self, std::list< ArPose >::size_type size, ArPose value) -> ArPoseList
        """
        this = _AriaPy.new_ArPoseList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ArPoseList self, ArPose x)"""
        return _AriaPy.ArPoseList_push_back(self, x)


    def front(self):
        """front(ArPoseList self) -> ArPose"""
        return _AriaPy.ArPoseList_front(self)


    def back(self):
        """back(ArPoseList self) -> ArPose"""
        return _AriaPy.ArPoseList_back(self)


    def assign(self, n, x):
        """assign(ArPoseList self, std::list< ArPose >::size_type n, ArPose x)"""
        return _AriaPy.ArPoseList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ArPoseList self, std::list< ArPose >::size_type new_size)
        resize(ArPoseList self, std::list< ArPose >::size_type new_size, ArPose x)
        """
        return _AriaPy.ArPoseList_resize(self, *args)


    def insert(self, *args):
        """
        insert(ArPoseList self, std::list< ArPose >::iterator pos, ArPose x) -> std::list< ArPose >::iterator
        insert(ArPoseList self, std::list< ArPose >::iterator pos, std::list< ArPose >::size_type n, ArPose x)
        """
        return _AriaPy.ArPoseList_insert(self, *args)


    def pop_front(self):
        """pop_front(ArPoseList self)"""
        return _AriaPy.ArPoseList_pop_front(self)


    def push_front(self, x):
        """push_front(ArPoseList self, ArPose x)"""
        return _AriaPy.ArPoseList_push_front(self, x)


    def reverse(self):
        """reverse(ArPoseList self)"""
        return _AriaPy.ArPoseList_reverse(self)

    __swig_destroy__ = _AriaPy.delete_ArPoseList
    __del__ = lambda self: None
ArPoseList_swigregister = _AriaPy.ArPoseList_swigregister
ArPoseList_swigregister(ArPoseList)

class ArPosePtrList(object):
    """Proxy of C++ std::list<(p.ArPose)> 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(ArPosePtrList self) -> SwigPyIterator"""
        return _AriaPy.ArPosePtrList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ArPosePtrList self) -> bool"""
        return _AriaPy.ArPosePtrList___nonzero__(self)


    def __bool__(self):
        """__bool__(ArPosePtrList self) -> bool"""
        return _AriaPy.ArPosePtrList___bool__(self)


    def __len__(self):
        """__len__(ArPosePtrList self) -> std::list< ArPose * >::size_type"""
        return _AriaPy.ArPosePtrList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ArPosePtrList self, std::list< ArPose * >::difference_type i, std::list< ArPose * >::difference_type j) -> ArPosePtrList"""
        return _AriaPy.ArPosePtrList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ArPosePtrList self, std::list< ArPose * >::difference_type i, std::list< ArPose * >::difference_type j)
        __setslice__(ArPosePtrList self, std::list< ArPose * >::difference_type i, std::list< ArPose * >::difference_type j, ArPosePtrList v)
        """
        return _AriaPy.ArPosePtrList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ArPosePtrList self, std::list< ArPose * >::difference_type i, std::list< ArPose * >::difference_type j)"""
        return _AriaPy.ArPosePtrList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ArPosePtrList self, std::list< ArPose * >::difference_type i)
        __delitem__(ArPosePtrList self, PySliceObject * slice)
        """
        return _AriaPy.ArPosePtrList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ArPosePtrList self, PySliceObject * slice) -> ArPosePtrList
        __getitem__(ArPosePtrList self, std::list< ArPose * >::difference_type i) -> ArPose
        """
        return _AriaPy.ArPosePtrList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ArPosePtrList self, PySliceObject * slice, ArPosePtrList v)
        __setitem__(ArPosePtrList self, PySliceObject * slice)
        __setitem__(ArPosePtrList self, std::list< ArPose * >::difference_type i, ArPose x)
        """
        return _AriaPy.ArPosePtrList___setitem__(self, *args)


    def pop(self):
        """pop(ArPosePtrList self) -> ArPose"""
        return _AriaPy.ArPosePtrList_pop(self)


    def append(self, x):
        """append(ArPosePtrList self, ArPose x)"""
        return _AriaPy.ArPosePtrList_append(self, x)


    def empty(self):
        """empty(ArPosePtrList self) -> bool"""
        return _AriaPy.ArPosePtrList_empty(self)


    def size(self):
        """size(ArPosePtrList self) -> std::list< ArPose * >::size_type"""
        return _AriaPy.ArPosePtrList_size(self)


    def swap(self, v):
        """swap(ArPosePtrList self, ArPosePtrList v)"""
        return _AriaPy.ArPosePtrList_swap(self, v)


    def begin(self):
        """begin(ArPosePtrList self) -> std::list< ArPose * >::iterator"""
        return _AriaPy.ArPosePtrList_begin(self)


    def end(self):
        """end(ArPosePtrList self) -> std::list< ArPose * >::iterator"""
        return _AriaPy.ArPosePtrList_end(self)


    def rbegin(self):
        """rbegin(ArPosePtrList self) -> std::list< ArPose * >::reverse_iterator"""
        return _AriaPy.ArPosePtrList_rbegin(self)


    def rend(self):
        """rend(ArPosePtrList self) -> std::list< ArPose * >::reverse_iterator"""
        return _AriaPy.ArPosePtrList_rend(self)


    def clear(self):
        """clear(ArPosePtrList self)"""
        return _AriaPy.ArPosePtrList_clear(self)


    def get_allocator(self):
        """get_allocator(ArPosePtrList self) -> std::list< ArPose * >::allocator_type"""
        return _AriaPy.ArPosePtrList_get_allocator(self)


    def pop_back(self):
        """pop_back(ArPosePtrList self)"""
        return _AriaPy.ArPosePtrList_pop_back(self)


    def erase(self, *args):
        """
        erase(ArPosePtrList self, std::list< ArPose * >::iterator pos) -> std::list< ArPose * >::iterator
        erase(ArPosePtrList self, std::list< ArPose * >::iterator first, std::list< ArPose * >::iterator last) -> std::list< ArPose * >::iterator
        """
        return _AriaPy.ArPosePtrList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(p.ArPose)> self) -> ArPosePtrList
        __init__(std::list<(p.ArPose)> self, ArPosePtrList arg2) -> ArPosePtrList
        __init__(std::list<(p.ArPose)> self, std::list< ArPose * >::size_type size) -> ArPosePtrList
        __init__(std::list<(p.ArPose)> self, std::list< ArPose * >::size_type size, ArPose value) -> ArPosePtrList
        """
        this = _AriaPy.new_ArPosePtrList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ArPosePtrList self, ArPose x)"""
        return _AriaPy.ArPosePtrList_push_back(self, x)


    def front(self):
        """front(ArPosePtrList self) -> ArPose"""
        return _AriaPy.ArPosePtrList_front(self)


    def back(self):
        """back(ArPosePtrList self) -> ArPose"""
        return _AriaPy.ArPosePtrList_back(self)


    def assign(self, n, x):
        """assign(ArPosePtrList self, std::list< ArPose * >::size_type n, ArPose x)"""
        return _AriaPy.ArPosePtrList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ArPosePtrList self, std::list< ArPose * >::size_type new_size)
        resize(ArPosePtrList self, std::list< ArPose * >::size_type new_size, ArPose x)
        """
        return _AriaPy.ArPosePtrList_resize(self, *args)


    def insert(self, *args):
        """
        insert(ArPosePtrList self, std::list< ArPose * >::iterator pos, ArPose x) -> std::list< ArPose * >::iterator
        insert(ArPosePtrList self, std::list< ArPose * >::iterator pos, std::list< ArPose * >::size_type n, ArPose x)
        """
        return _AriaPy.ArPosePtrList_insert(self, *args)


    def pop_front(self):
        """pop_front(ArPosePtrList self)"""
        return _AriaPy.ArPosePtrList_pop_front(self)


    def push_front(self, x):
        """push_front(ArPosePtrList self, ArPose x)"""
        return _AriaPy.ArPosePtrList_push_front(self, x)


    def remove(self, x):
        """remove(ArPosePtrList self, ArPose x)"""
        return _AriaPy.ArPosePtrList_remove(self, x)


    def unique(self):
        """unique(ArPosePtrList self)"""
        return _AriaPy.ArPosePtrList_unique(self)


    def reverse(self):
        """reverse(ArPosePtrList self)"""
        return _AriaPy.ArPosePtrList_reverse(self)


    def sort(self):
        """sort(ArPosePtrList self)"""
        return _AriaPy.ArPosePtrList_sort(self)


    def merge(self, x):
        """merge(ArPosePtrList self, ArPosePtrList x)"""
        return _AriaPy.ArPosePtrList_merge(self, x)

    __swig_destroy__ = _AriaPy.delete_ArPosePtrList
    __del__ = lambda self: None
ArPosePtrList_swigregister = _AriaPy.ArPosePtrList_swigregister
ArPosePtrList_swigregister(ArPosePtrList)

class ArPoseWithTimeList(object):
    """Proxy of C++ std::list<(ArPoseWithTime)> 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(ArPoseWithTimeList self) -> SwigPyIterator"""
        return _AriaPy.ArPoseWithTimeList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ArPoseWithTimeList self) -> bool"""
        return _AriaPy.ArPoseWithTimeList___nonzero__(self)


    def __bool__(self):
        """__bool__(ArPoseWithTimeList self) -> bool"""
        return _AriaPy.ArPoseWithTimeList___bool__(self)


    def __len__(self):
        """__len__(ArPoseWithTimeList self) -> std::list< ArPoseWithTime >::size_type"""
        return _AriaPy.ArPoseWithTimeList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ArPoseWithTimeList self, std::list< ArPoseWithTime >::difference_type i, std::list< ArPoseWithTime >::difference_type j) -> ArPoseWithTimeList"""
        return _AriaPy.ArPoseWithTimeList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ArPoseWithTimeList self, std::list< ArPoseWithTime >::difference_type i, std::list< ArPoseWithTime >::difference_type j)
        __setslice__(ArPoseWithTimeList self, std::list< ArPoseWithTime >::difference_type i, std::list< ArPoseWithTime >::difference_type j, ArPoseWithTimeList v)
        """
        return _AriaPy.ArPoseWithTimeList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ArPoseWithTimeList self, std::list< ArPoseWithTime >::difference_type i, std::list< ArPoseWithTime >::difference_type j)"""
        return _AriaPy.ArPoseWithTimeList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ArPoseWithTimeList self, std::list< ArPoseWithTime >::difference_type i)
        __delitem__(ArPoseWithTimeList self, PySliceObject * slice)
        """
        return _AriaPy.ArPoseWithTimeList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ArPoseWithTimeList self, PySliceObject * slice) -> ArPoseWithTimeList
        __getitem__(ArPoseWithTimeList self, std::list< ArPoseWithTime >::difference_type i) -> ArPoseWithTime
        """
        return _AriaPy.ArPoseWithTimeList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ArPoseWithTimeList self, PySliceObject * slice, ArPoseWithTimeList v)
        __setitem__(ArPoseWithTimeList self, PySliceObject * slice)
        __setitem__(ArPoseWithTimeList self, std::list< ArPoseWithTime >::difference_type i, ArPoseWithTime x)
        """
        return _AriaPy.ArPoseWithTimeList___setitem__(self, *args)


    def pop(self):
        """pop(ArPoseWithTimeList self) -> ArPoseWithTime"""
        return _AriaPy.ArPoseWithTimeList_pop(self)


    def append(self, x):
        """append(ArPoseWithTimeList self, ArPoseWithTime x)"""
        return _AriaPy.ArPoseWithTimeList_append(self, x)


    def empty(self):
        """empty(ArPoseWithTimeList self) -> bool"""
        return _AriaPy.ArPoseWithTimeList_empty(self)


    def size(self):
        """size(ArPoseWithTimeList self) -> std::list< ArPoseWithTime >::size_type"""
        return _AriaPy.ArPoseWithTimeList_size(self)


    def swap(self, v):
        """swap(ArPoseWithTimeList self, ArPoseWithTimeList v)"""
        return _AriaPy.ArPoseWithTimeList_swap(self, v)


    def begin(self):
        """begin(ArPoseWithTimeList self) -> std::list< ArPoseWithTime >::iterator"""
        return _AriaPy.ArPoseWithTimeList_begin(self)


    def end(self):
        """end(ArPoseWithTimeList self) -> std::list< ArPoseWithTime >::iterator"""
        return _AriaPy.ArPoseWithTimeList_end(self)


    def rbegin(self):
        """rbegin(ArPoseWithTimeList self) -> std::list< ArPoseWithTime >::reverse_iterator"""
        return _AriaPy.ArPoseWithTimeList_rbegin(self)


    def rend(self):
        """rend(ArPoseWithTimeList self) -> std::list< ArPoseWithTime >::reverse_iterator"""
        return _AriaPy.ArPoseWithTimeList_rend(self)


    def clear(self):
        """clear(ArPoseWithTimeList self)"""
        return _AriaPy.ArPoseWithTimeList_clear(self)


    def get_allocator(self):
        """get_allocator(ArPoseWithTimeList self) -> std::list< ArPoseWithTime >::allocator_type"""
        return _AriaPy.ArPoseWithTimeList_get_allocator(self)


    def pop_back(self):
        """pop_back(ArPoseWithTimeList self)"""
        return _AriaPy.ArPoseWithTimeList_pop_back(self)


    def erase(self, *args):
        """
        erase(ArPoseWithTimeList self, std::list< ArPoseWithTime >::iterator pos) -> std::list< ArPoseWithTime >::iterator
        erase(ArPoseWithTimeList self, std::list< ArPoseWithTime >::iterator first, std::list< ArPoseWithTime >::iterator last) -> std::list< ArPoseWithTime >::iterator
        """
        return _AriaPy.ArPoseWithTimeList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(ArPoseWithTime)> self) -> ArPoseWithTimeList
        __init__(std::list<(ArPoseWithTime)> self, ArPoseWithTimeList arg2) -> ArPoseWithTimeList
        __init__(std::list<(ArPoseWithTime)> self, std::list< ArPoseWithTime >::size_type size) -> ArPoseWithTimeList
        __init__(std::list<(ArPoseWithTime)> self, std::list< ArPoseWithTime >::size_type size, ArPoseWithTime value) -> ArPoseWithTimeList
        """
        this = _AriaPy.new_ArPoseWithTimeList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ArPoseWithTimeList self, ArPoseWithTime x)"""
        return _AriaPy.ArPoseWithTimeList_push_back(self, x)


    def front(self):
        """front(ArPoseWithTimeList self) -> ArPoseWithTime"""
        return _AriaPy.ArPoseWithTimeList_front(self)


    def back(self):
        """back(ArPoseWithTimeList self) -> ArPoseWithTime"""
        return _AriaPy.ArPoseWithTimeList_back(self)


    def assign(self, n, x):
        """assign(ArPoseWithTimeList self, std::list< ArPoseWithTime >::size_type n, ArPoseWithTime x)"""
        return _AriaPy.ArPoseWithTimeList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ArPoseWithTimeList self, std::list< ArPoseWithTime >::size_type new_size)
        resize(ArPoseWithTimeList self, std::list< ArPoseWithTime >::size_type new_size, ArPoseWithTime x)
        """
        return _AriaPy.ArPoseWithTimeList_resize(self, *args)


    def insert(self, *args):
        """
        insert(ArPoseWithTimeList self, std::list< ArPoseWithTime >::iterator pos, ArPoseWithTime x) -> std::list< ArPoseWithTime >::iterator
        insert(ArPoseWithTimeList self, std::list< ArPoseWithTime >::iterator pos, std::list< ArPoseWithTime >::size_type n, ArPoseWithTime x)
        """
        return _AriaPy.ArPoseWithTimeList_insert(self, *args)


    def pop_front(self):
        """pop_front(ArPoseWithTimeList self)"""
        return _AriaPy.ArPoseWithTimeList_pop_front(self)


    def push_front(self, x):
        """push_front(ArPoseWithTimeList self, ArPoseWithTime x)"""
        return _AriaPy.ArPoseWithTimeList_push_front(self, x)


    def reverse(self):
        """reverse(ArPoseWithTimeList self)"""
        return _AriaPy.ArPoseWithTimeList_reverse(self)

    __swig_destroy__ = _AriaPy.delete_ArPoseWithTimeList
    __del__ = lambda self: None
ArPoseWithTimeList_swigregister = _AriaPy.ArPoseWithTimeList_swigregister
ArPoseWithTimeList_swigregister(ArPoseWithTimeList)

class ArPoseWithTimePtrList(object):
    """Proxy of C++ std::list<(p.ArPoseWithTime)> 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(ArPoseWithTimePtrList self) -> SwigPyIterator"""
        return _AriaPy.ArPoseWithTimePtrList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ArPoseWithTimePtrList self) -> bool"""
        return _AriaPy.ArPoseWithTimePtrList___nonzero__(self)


    def __bool__(self):
        """__bool__(ArPoseWithTimePtrList self) -> bool"""
        return _AriaPy.ArPoseWithTimePtrList___bool__(self)


    def __len__(self):
        """__len__(ArPoseWithTimePtrList self) -> std::list< ArPoseWithTime * >::size_type"""
        return _AriaPy.ArPoseWithTimePtrList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ArPoseWithTimePtrList self, std::list< ArPoseWithTime * >::difference_type i, std::list< ArPoseWithTime * >::difference_type j) -> ArPoseWithTimePtrList"""
        return _AriaPy.ArPoseWithTimePtrList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ArPoseWithTimePtrList self, std::list< ArPoseWithTime * >::difference_type i, std::list< ArPoseWithTime * >::difference_type j)
        __setslice__(ArPoseWithTimePtrList self, std::list< ArPoseWithTime * >::difference_type i, std::list< ArPoseWithTime * >::difference_type j, ArPoseWithTimePtrList v)
        """
        return _AriaPy.ArPoseWithTimePtrList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ArPoseWithTimePtrList self, std::list< ArPoseWithTime * >::difference_type i, std::list< ArPoseWithTime * >::difference_type j)"""
        return _AriaPy.ArPoseWithTimePtrList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ArPoseWithTimePtrList self, std::list< ArPoseWithTime * >::difference_type i)
        __delitem__(ArPoseWithTimePtrList self, PySliceObject * slice)
        """
        return _AriaPy.ArPoseWithTimePtrList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ArPoseWithTimePtrList self, PySliceObject * slice) -> ArPoseWithTimePtrList
        __getitem__(ArPoseWithTimePtrList self, std::list< ArPoseWithTime * >::difference_type i) -> ArPoseWithTime
        """
        return _AriaPy.ArPoseWithTimePtrList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ArPoseWithTimePtrList self, PySliceObject * slice, ArPoseWithTimePtrList v)
        __setitem__(ArPoseWithTimePtrList self, PySliceObject * slice)
        __setitem__(ArPoseWithTimePtrList self, std::list< ArPoseWithTime * >::difference_type i, ArPoseWithTime x)
        """
        return _AriaPy.ArPoseWithTimePtrList___setitem__(self, *args)


    def pop(self):
        """pop(ArPoseWithTimePtrList self) -> ArPoseWithTime"""
        return _AriaPy.ArPoseWithTimePtrList_pop(self)


    def append(self, x):
        """append(ArPoseWithTimePtrList self, ArPoseWithTime x)"""
        return _AriaPy.ArPoseWithTimePtrList_append(self, x)


    def empty(self):
        """empty(ArPoseWithTimePtrList self) -> bool"""
        return _AriaPy.ArPoseWithTimePtrList_empty(self)


    def size(self):
        """size(ArPoseWithTimePtrList self) -> std::list< ArPoseWithTime * >::size_type"""
        return _AriaPy.ArPoseWithTimePtrList_size(self)


    def swap(self, v):
        """swap(ArPoseWithTimePtrList self, ArPoseWithTimePtrList v)"""
        return _AriaPy.ArPoseWithTimePtrList_swap(self, v)


    def begin(self):
        """begin(ArPoseWithTimePtrList self) -> std::list< ArPoseWithTime * >::iterator"""
        return _AriaPy.ArPoseWithTimePtrList_begin(self)


    def end(self):
        """end(ArPoseWithTimePtrList self) -> std::list< ArPoseWithTime * >::iterator"""
        return _AriaPy.ArPoseWithTimePtrList_end(self)


    def rbegin(self):
        """rbegin(ArPoseWithTimePtrList self) -> std::list< ArPoseWithTime * >::reverse_iterator"""
        return _AriaPy.ArPoseWithTimePtrList_rbegin(self)


    def rend(self):
        """rend(ArPoseWithTimePtrList self) -> std::list< ArPoseWithTime * >::reverse_iterator"""
        return _AriaPy.ArPoseWithTimePtrList_rend(self)


    def clear(self):
        """clear(ArPoseWithTimePtrList self)"""
        return _AriaPy.ArPoseWithTimePtrList_clear(self)


    def get_allocator(self):
        """get_allocator(ArPoseWithTimePtrList self) -> std::list< ArPoseWithTime * >::allocator_type"""
        return _AriaPy.ArPoseWithTimePtrList_get_allocator(self)


    def pop_back(self):
        """pop_back(ArPoseWithTimePtrList self)"""
        return _AriaPy.ArPoseWithTimePtrList_pop_back(self)


    def erase(self, *args):
        """
        erase(ArPoseWithTimePtrList self, std::list< ArPoseWithTime * >::iterator pos) -> std::list< ArPoseWithTime * >::iterator
        erase(ArPoseWithTimePtrList self, std::list< ArPoseWithTime * >::iterator first, std::list< ArPoseWithTime * >::iterator last) -> std::list< ArPoseWithTime * >::iterator
        """
        return _AriaPy.ArPoseWithTimePtrList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(p.ArPoseWithTime)> self) -> ArPoseWithTimePtrList
        __init__(std::list<(p.ArPoseWithTime)> self, ArPoseWithTimePtrList arg2) -> ArPoseWithTimePtrList
        __init__(std::list<(p.ArPoseWithTime)> self, std::list< ArPoseWithTime * >::size_type size) -> ArPoseWithTimePtrList
        __init__(std::list<(p.ArPoseWithTime)> self, std::list< ArPoseWithTime * >::size_type size, ArPoseWithTime value) -> ArPoseWithTimePtrList
        """
        this = _AriaPy.new_ArPoseWithTimePtrList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ArPoseWithTimePtrList self, ArPoseWithTime x)"""
        return _AriaPy.ArPoseWithTimePtrList_push_back(self, x)


    def front(self):
        """front(ArPoseWithTimePtrList self) -> ArPoseWithTime"""
        return _AriaPy.ArPoseWithTimePtrList_front(self)


    def back(self):
        """back(ArPoseWithTimePtrList self) -> ArPoseWithTime"""
        return _AriaPy.ArPoseWithTimePtrList_back(self)


    def assign(self, n, x):
        """assign(ArPoseWithTimePtrList self, std::list< ArPoseWithTime * >::size_type n, ArPoseWithTime x)"""
        return _AriaPy.ArPoseWithTimePtrList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ArPoseWithTimePtrList self, std::list< ArPoseWithTime * >::size_type new_size)
        resize(ArPoseWithTimePtrList self, std::list< ArPoseWithTime * >::size_type new_size, ArPoseWithTime x)
        """
        return _AriaPy.ArPoseWithTimePtrList_resize(self, *args)


    def insert(self, *args):
        """
        insert(ArPoseWithTimePtrList self, std::list< ArPoseWithTime * >::iterator pos, ArPoseWithTime x) -> std::list< ArPoseWithTime * >::iterator
        insert(ArPoseWithTimePtrList self, std::list< ArPoseWithTime * >::iterator pos, std::list< ArPoseWithTime * >::size_type n, ArPoseWithTime x)
        """
        return _AriaPy.ArPoseWithTimePtrList_insert(self, *args)


    def pop_front(self):
        """pop_front(ArPoseWithTimePtrList self)"""
        return _AriaPy.ArPoseWithTimePtrList_pop_front(self)


    def push_front(self, x):
        """push_front(ArPoseWithTimePtrList self, ArPoseWithTime x)"""
        return _AriaPy.ArPoseWithTimePtrList_push_front(self, x)


    def remove(self, x):
        """remove(ArPoseWithTimePtrList self, ArPoseWithTime x)"""
        return _AriaPy.ArPoseWithTimePtrList_remove(self, x)


    def unique(self):
        """unique(ArPoseWithTimePtrList self)"""
        return _AriaPy.ArPoseWithTimePtrList_unique(self)


    def reverse(self):
        """reverse(ArPoseWithTimePtrList self)"""
        return _AriaPy.ArPoseWithTimePtrList_reverse(self)


    def sort(self):
        """sort(ArPoseWithTimePtrList self)"""
        return _AriaPy.ArPoseWithTimePtrList_sort(self)


    def merge(self, x):
        """merge(ArPoseWithTimePtrList self, ArPoseWithTimePtrList x)"""
        return _AriaPy.ArPoseWithTimePtrList_merge(self, x)

    __swig_destroy__ = _AriaPy.delete_ArPoseWithTimePtrList
    __del__ = lambda self: None
ArPoseWithTimePtrList_swigregister = _AriaPy.ArPoseWithTimePtrList_swigregister
ArPoseWithTimePtrList_swigregister(ArPoseWithTimePtrList)

class ArRangeDevicePtrList(object):
    """Proxy of C++ std::list<(p.ArRangeDevice)> 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(ArRangeDevicePtrList self) -> SwigPyIterator"""
        return _AriaPy.ArRangeDevicePtrList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ArRangeDevicePtrList self) -> bool"""
        return _AriaPy.ArRangeDevicePtrList___nonzero__(self)


    def __bool__(self):
        """__bool__(ArRangeDevicePtrList self) -> bool"""
        return _AriaPy.ArRangeDevicePtrList___bool__(self)


    def __len__(self):
        """__len__(ArRangeDevicePtrList self) -> std::list< ArRangeDevice * >::size_type"""
        return _AriaPy.ArRangeDevicePtrList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ArRangeDevicePtrList self, std::list< ArRangeDevice * >::difference_type i, std::list< ArRangeDevice * >::difference_type j) -> ArRangeDevicePtrList"""
        return _AriaPy.ArRangeDevicePtrList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ArRangeDevicePtrList self, std::list< ArRangeDevice * >::difference_type i, std::list< ArRangeDevice * >::difference_type j)
        __setslice__(ArRangeDevicePtrList self, std::list< ArRangeDevice * >::difference_type i, std::list< ArRangeDevice * >::difference_type j, ArRangeDevicePtrList v)
        """
        return _AriaPy.ArRangeDevicePtrList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ArRangeDevicePtrList self, std::list< ArRangeDevice * >::difference_type i, std::list< ArRangeDevice * >::difference_type j)"""
        return _AriaPy.ArRangeDevicePtrList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ArRangeDevicePtrList self, std::list< ArRangeDevice * >::difference_type i)
        __delitem__(ArRangeDevicePtrList self, PySliceObject * slice)
        """
        return _AriaPy.ArRangeDevicePtrList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ArRangeDevicePtrList self, PySliceObject * slice) -> ArRangeDevicePtrList
        __getitem__(ArRangeDevicePtrList self, std::list< ArRangeDevice * >::difference_type i) -> ArRangeDevice
        """
        return _AriaPy.ArRangeDevicePtrList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ArRangeDevicePtrList self, PySliceObject * slice, ArRangeDevicePtrList v)
        __setitem__(ArRangeDevicePtrList self, PySliceObject * slice)
        __setitem__(ArRangeDevicePtrList self, std::list< ArRangeDevice * >::difference_type i, ArRangeDevice x)
        """
        return _AriaPy.ArRangeDevicePtrList___setitem__(self, *args)


    def pop(self):
        """pop(ArRangeDevicePtrList self) -> ArRangeDevice"""
        return _AriaPy.ArRangeDevicePtrList_pop(self)


    def append(self, x):
        """append(ArRangeDevicePtrList self, ArRangeDevice x)"""
        return _AriaPy.ArRangeDevicePtrList_append(self, x)


    def empty(self):
        """empty(ArRangeDevicePtrList self) -> bool"""
        return _AriaPy.ArRangeDevicePtrList_empty(self)


    def size(self):
        """size(ArRangeDevicePtrList self) -> std::list< ArRangeDevice * >::size_type"""
        return _AriaPy.ArRangeDevicePtrList_size(self)


    def swap(self, v):
        """swap(ArRangeDevicePtrList self, ArRangeDevicePtrList v)"""
        return _AriaPy.ArRangeDevicePtrList_swap(self, v)


    def begin(self):
        """begin(ArRangeDevicePtrList self) -> std::list< ArRangeDevice * >::iterator"""
        return _AriaPy.ArRangeDevicePtrList_begin(self)


    def end(self):
        """end(ArRangeDevicePtrList self) -> std::list< ArRangeDevice * >::iterator"""
        return _AriaPy.ArRangeDevicePtrList_end(self)


    def rbegin(self):
        """rbegin(ArRangeDevicePtrList self) -> std::list< ArRangeDevice * >::reverse_iterator"""
        return _AriaPy.ArRangeDevicePtrList_rbegin(self)


    def rend(self):
        """rend(ArRangeDevicePtrList self) -> std::list< ArRangeDevice * >::reverse_iterator"""
        return _AriaPy.ArRangeDevicePtrList_rend(self)


    def clear(self):
        """clear(ArRangeDevicePtrList self)"""
        return _AriaPy.ArRangeDevicePtrList_clear(self)


    def get_allocator(self):
        """get_allocator(ArRangeDevicePtrList self) -> std::list< ArRangeDevice * >::allocator_type"""
        return _AriaPy.ArRangeDevicePtrList_get_allocator(self)


    def pop_back(self):
        """pop_back(ArRangeDevicePtrList self)"""
        return _AriaPy.ArRangeDevicePtrList_pop_back(self)


    def erase(self, *args):
        """
        erase(ArRangeDevicePtrList self, std::list< ArRangeDevice * >::iterator pos) -> std::list< ArRangeDevice * >::iterator
        erase(ArRangeDevicePtrList self, std::list< ArRangeDevice * >::iterator first, std::list< ArRangeDevice * >::iterator last) -> std::list< ArRangeDevice * >::iterator
        """
        return _AriaPy.ArRangeDevicePtrList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(p.ArRangeDevice)> self) -> ArRangeDevicePtrList
        __init__(std::list<(p.ArRangeDevice)> self, ArRangeDevicePtrList arg2) -> ArRangeDevicePtrList
        __init__(std::list<(p.ArRangeDevice)> self, std::list< ArRangeDevice * >::size_type size) -> ArRangeDevicePtrList
        __init__(std::list<(p.ArRangeDevice)> self, std::list< ArRangeDevice * >::size_type size, ArRangeDevice value) -> ArRangeDevicePtrList
        """
        this = _AriaPy.new_ArRangeDevicePtrList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ArRangeDevicePtrList self, ArRangeDevice x)"""
        return _AriaPy.ArRangeDevicePtrList_push_back(self, x)


    def front(self):
        """front(ArRangeDevicePtrList self) -> ArRangeDevice"""
        return _AriaPy.ArRangeDevicePtrList_front(self)


    def back(self):
        """back(ArRangeDevicePtrList self) -> ArRangeDevice"""
        return _AriaPy.ArRangeDevicePtrList_back(self)


    def assign(self, n, x):
        """assign(ArRangeDevicePtrList self, std::list< ArRangeDevice * >::size_type n, ArRangeDevice x)"""
        return _AriaPy.ArRangeDevicePtrList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ArRangeDevicePtrList self, std::list< ArRangeDevice * >::size_type new_size)
        resize(ArRangeDevicePtrList self, std::list< ArRangeDevice * >::size_type new_size, ArRangeDevice x)
        """
        return _AriaPy.ArRangeDevicePtrList_resize(self, *args)


    def insert(self, *args):
        """
        insert(ArRangeDevicePtrList self, std::list< ArRangeDevice * >::iterator pos, ArRangeDevice x) -> std::list< ArRangeDevice * >::iterator
        insert(ArRangeDevicePtrList self, std::list< ArRangeDevice * >::iterator pos, std::list< ArRangeDevice * >::size_type n, ArRangeDevice x)
        """
        return _AriaPy.ArRangeDevicePtrList_insert(self, *args)


    def pop_front(self):
        """pop_front(ArRangeDevicePtrList self)"""
        return _AriaPy.ArRangeDevicePtrList_pop_front(self)


    def push_front(self, x):
        """push_front(ArRangeDevicePtrList self, ArRangeDevice x)"""
        return _AriaPy.ArRangeDevicePtrList_push_front(self, x)


    def remove(self, x):
        """remove(ArRangeDevicePtrList self, ArRangeDevice x)"""
        return _AriaPy.ArRangeDevicePtrList_remove(self, x)


    def unique(self):
        """unique(ArRangeDevicePtrList self)"""
        return _AriaPy.ArRangeDevicePtrList_unique(self)


    def reverse(self):
        """reverse(ArRangeDevicePtrList self)"""
        return _AriaPy.ArRangeDevicePtrList_reverse(self)


    def sort(self):
        """sort(ArRangeDevicePtrList self)"""
        return _AriaPy.ArRangeDevicePtrList_sort(self)


    def merge(self, x):
        """merge(ArRangeDevicePtrList self, ArRangeDevicePtrList x)"""
        return _AriaPy.ArRangeDevicePtrList_merge(self, x)

    __swig_destroy__ = _AriaPy.delete_ArRangeDevicePtrList
    __del__ = lambda self: None
ArRangeDevicePtrList_swigregister = _AriaPy.ArRangeDevicePtrList_swigregister
ArRangeDevicePtrList_swigregister(ArRangeDevicePtrList)

class ArArgumentBuilderPtrList(object):
    """Proxy of C++ std::list<(p.ArArgumentBuilder)> 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(ArArgumentBuilderPtrList self) -> SwigPyIterator"""
        return _AriaPy.ArArgumentBuilderPtrList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ArArgumentBuilderPtrList self) -> bool"""
        return _AriaPy.ArArgumentBuilderPtrList___nonzero__(self)


    def __bool__(self):
        """__bool__(ArArgumentBuilderPtrList self) -> bool"""
        return _AriaPy.ArArgumentBuilderPtrList___bool__(self)


    def __len__(self):
        """__len__(ArArgumentBuilderPtrList self) -> std::list< ArArgumentBuilder * >::size_type"""
        return _AriaPy.ArArgumentBuilderPtrList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ArArgumentBuilderPtrList self, std::list< ArArgumentBuilder * >::difference_type i, std::list< ArArgumentBuilder * >::difference_type j) -> ArArgumentBuilderPtrList"""
        return _AriaPy.ArArgumentBuilderPtrList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ArArgumentBuilderPtrList self, std::list< ArArgumentBuilder * >::difference_type i, std::list< ArArgumentBuilder * >::difference_type j)
        __setslice__(ArArgumentBuilderPtrList self, std::list< ArArgumentBuilder * >::difference_type i, std::list< ArArgumentBuilder * >::difference_type j, ArArgumentBuilderPtrList v)
        """
        return _AriaPy.ArArgumentBuilderPtrList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ArArgumentBuilderPtrList self, std::list< ArArgumentBuilder * >::difference_type i, std::list< ArArgumentBuilder * >::difference_type j)"""
        return _AriaPy.ArArgumentBuilderPtrList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ArArgumentBuilderPtrList self, std::list< ArArgumentBuilder * >::difference_type i)
        __delitem__(ArArgumentBuilderPtrList self, PySliceObject * slice)
        """
        return _AriaPy.ArArgumentBuilderPtrList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ArArgumentBuilderPtrList self, PySliceObject * slice) -> ArArgumentBuilderPtrList
        __getitem__(ArArgumentBuilderPtrList self, std::list< ArArgumentBuilder * >::difference_type i) -> ArArgumentBuilder
        """
        return _AriaPy.ArArgumentBuilderPtrList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ArArgumentBuilderPtrList self, PySliceObject * slice, ArArgumentBuilderPtrList v)
        __setitem__(ArArgumentBuilderPtrList self, PySliceObject * slice)
        __setitem__(ArArgumentBuilderPtrList self, std::list< ArArgumentBuilder * >::difference_type i, ArArgumentBuilder x)
        """
        return _AriaPy.ArArgumentBuilderPtrList___setitem__(self, *args)


    def pop(self):
        """pop(ArArgumentBuilderPtrList self) -> ArArgumentBuilder"""
        return _AriaPy.ArArgumentBuilderPtrList_pop(self)


    def append(self, x):
        """append(ArArgumentBuilderPtrList self, ArArgumentBuilder x)"""
        return _AriaPy.ArArgumentBuilderPtrList_append(self, x)


    def empty(self):
        """empty(ArArgumentBuilderPtrList self) -> bool"""
        return _AriaPy.ArArgumentBuilderPtrList_empty(self)


    def size(self):
        """size(ArArgumentBuilderPtrList self) -> std::list< ArArgumentBuilder * >::size_type"""
        return _AriaPy.ArArgumentBuilderPtrList_size(self)


    def swap(self, v):
        """swap(ArArgumentBuilderPtrList self, ArArgumentBuilderPtrList v)"""
        return _AriaPy.ArArgumentBuilderPtrList_swap(self, v)


    def begin(self):
        """begin(ArArgumentBuilderPtrList self) -> std::list< ArArgumentBuilder * >::iterator"""
        return _AriaPy.ArArgumentBuilderPtrList_begin(self)


    def end(self):
        """end(ArArgumentBuilderPtrList self) -> std::list< ArArgumentBuilder * >::iterator"""
        return _AriaPy.ArArgumentBuilderPtrList_end(self)


    def rbegin(self):
        """rbegin(ArArgumentBuilderPtrList self) -> std::list< ArArgumentBuilder * >::reverse_iterator"""
        return _AriaPy.ArArgumentBuilderPtrList_rbegin(self)


    def rend(self):
        """rend(ArArgumentBuilderPtrList self) -> std::list< ArArgumentBuilder * >::reverse_iterator"""
        return _AriaPy.ArArgumentBuilderPtrList_rend(self)


    def clear(self):
        """clear(ArArgumentBuilderPtrList self)"""
        return _AriaPy.ArArgumentBuilderPtrList_clear(self)


    def get_allocator(self):
        """get_allocator(ArArgumentBuilderPtrList self) -> std::list< ArArgumentBuilder * >::allocator_type"""
        return _AriaPy.ArArgumentBuilderPtrList_get_allocator(self)


    def pop_back(self):
        """pop_back(ArArgumentBuilderPtrList self)"""
        return _AriaPy.ArArgumentBuilderPtrList_pop_back(self)


    def erase(self, *args):
        """
        erase(ArArgumentBuilderPtrList self, std::list< ArArgumentBuilder * >::iterator pos) -> std::list< ArArgumentBuilder * >::iterator
        erase(ArArgumentBuilderPtrList self, std::list< ArArgumentBuilder * >::iterator first, std::list< ArArgumentBuilder * >::iterator last) -> std::list< ArArgumentBuilder * >::iterator
        """
        return _AriaPy.ArArgumentBuilderPtrList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(p.ArArgumentBuilder)> self) -> ArArgumentBuilderPtrList
        __init__(std::list<(p.ArArgumentBuilder)> self, ArArgumentBuilderPtrList arg2) -> ArArgumentBuilderPtrList
        __init__(std::list<(p.ArArgumentBuilder)> self, std::list< ArArgumentBuilder * >::size_type size) -> ArArgumentBuilderPtrList
        __init__(std::list<(p.ArArgumentBuilder)> self, std::list< ArArgumentBuilder * >::size_type size, ArArgumentBuilder value) -> ArArgumentBuilderPtrList
        """
        this = _AriaPy.new_ArArgumentBuilderPtrList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ArArgumentBuilderPtrList self, ArArgumentBuilder x)"""
        return _AriaPy.ArArgumentBuilderPtrList_push_back(self, x)


    def front(self):
        """front(ArArgumentBuilderPtrList self) -> ArArgumentBuilder"""
        return _AriaPy.ArArgumentBuilderPtrList_front(self)


    def back(self):
        """back(ArArgumentBuilderPtrList self) -> ArArgumentBuilder"""
        return _AriaPy.ArArgumentBuilderPtrList_back(self)


    def assign(self, n, x):
        """assign(ArArgumentBuilderPtrList self, std::list< ArArgumentBuilder * >::size_type n, ArArgumentBuilder x)"""
        return _AriaPy.ArArgumentBuilderPtrList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ArArgumentBuilderPtrList self, std::list< ArArgumentBuilder * >::size_type new_size)
        resize(ArArgumentBuilderPtrList self, std::list< ArArgumentBuilder * >::size_type new_size, ArArgumentBuilder x)
        """
        return _AriaPy.ArArgumentBuilderPtrList_resize(self, *args)


    def insert(self, *args):
        """
        insert(ArArgumentBuilderPtrList self, std::list< ArArgumentBuilder * >::iterator pos, ArArgumentBuilder x) -> std::list< ArArgumentBuilder * >::iterator
        insert(ArArgumentBuilderPtrList self, std::list< ArArgumentBuilder * >::iterator pos, std::list< ArArgumentBuilder * >::size_type n, ArArgumentBuilder x)
        """
        return _AriaPy.ArArgumentBuilderPtrList_insert(self, *args)


    def pop_front(self):
        """pop_front(ArArgumentBuilderPtrList self)"""
        return _AriaPy.ArArgumentBuilderPtrList_pop_front(self)


    def push_front(self, x):
        """push_front(ArArgumentBuilderPtrList self, ArArgumentBuilder x)"""
        return _AriaPy.ArArgumentBuilderPtrList_push_front(self, x)


    def remove(self, x):
        """remove(ArArgumentBuilderPtrList self, ArArgumentBuilder x)"""
        return _AriaPy.ArArgumentBuilderPtrList_remove(self, x)


    def unique(self):
        """unique(ArArgumentBuilderPtrList self)"""
        return _AriaPy.ArArgumentBuilderPtrList_unique(self)


    def reverse(self):
        """reverse(ArArgumentBuilderPtrList self)"""
        return _AriaPy.ArArgumentBuilderPtrList_reverse(self)


    def sort(self):
        """sort(ArArgumentBuilderPtrList self)"""
        return _AriaPy.ArArgumentBuilderPtrList_sort(self)


    def merge(self, x):
        """merge(ArArgumentBuilderPtrList self, ArArgumentBuilderPtrList x)"""
        return _AriaPy.ArArgumentBuilderPtrList_merge(self, x)

    __swig_destroy__ = _AriaPy.delete_ArArgumentBuilderPtrList
    __del__ = lambda self: None
ArArgumentBuilderPtrList_swigregister = _AriaPy.ArArgumentBuilderPtrList_swigregister
ArArgumentBuilderPtrList_swigregister(ArArgumentBuilderPtrList)

class ArLineSegmentList(object):
    """Proxy of C++ std::list<(ArLineSegment)> 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(ArLineSegmentList self) -> SwigPyIterator"""
        return _AriaPy.ArLineSegmentList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ArLineSegmentList self) -> bool"""
        return _AriaPy.ArLineSegmentList___nonzero__(self)


    def __bool__(self):
        """__bool__(ArLineSegmentList self) -> bool"""
        return _AriaPy.ArLineSegmentList___bool__(self)


    def __len__(self):
        """__len__(ArLineSegmentList self) -> std::list< ArLineSegment >::size_type"""
        return _AriaPy.ArLineSegmentList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ArLineSegmentList self, std::list< ArLineSegment >::difference_type i, std::list< ArLineSegment >::difference_type j) -> ArLineSegmentList"""
        return _AriaPy.ArLineSegmentList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ArLineSegmentList self, std::list< ArLineSegment >::difference_type i, std::list< ArLineSegment >::difference_type j)
        __setslice__(ArLineSegmentList self, std::list< ArLineSegment >::difference_type i, std::list< ArLineSegment >::difference_type j, ArLineSegmentList v)
        """
        return _AriaPy.ArLineSegmentList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ArLineSegmentList self, std::list< ArLineSegment >::difference_type i, std::list< ArLineSegment >::difference_type j)"""
        return _AriaPy.ArLineSegmentList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ArLineSegmentList self, std::list< ArLineSegment >::difference_type i)
        __delitem__(ArLineSegmentList self, PySliceObject * slice)
        """
        return _AriaPy.ArLineSegmentList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ArLineSegmentList self, PySliceObject * slice) -> ArLineSegmentList
        __getitem__(ArLineSegmentList self, std::list< ArLineSegment >::difference_type i) -> ArLineSegment
        """
        return _AriaPy.ArLineSegmentList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ArLineSegmentList self, PySliceObject * slice, ArLineSegmentList v)
        __setitem__(ArLineSegmentList self, PySliceObject * slice)
        __setitem__(ArLineSegmentList self, std::list< ArLineSegment >::difference_type i, ArLineSegment x)
        """
        return _AriaPy.ArLineSegmentList___setitem__(self, *args)


    def pop(self):
        """pop(ArLineSegmentList self) -> ArLineSegment"""
        return _AriaPy.ArLineSegmentList_pop(self)


    def append(self, x):
        """append(ArLineSegmentList self, ArLineSegment x)"""
        return _AriaPy.ArLineSegmentList_append(self, x)


    def empty(self):
        """empty(ArLineSegmentList self) -> bool"""
        return _AriaPy.ArLineSegmentList_empty(self)


    def size(self):
        """size(ArLineSegmentList self) -> std::list< ArLineSegment >::size_type"""
        return _AriaPy.ArLineSegmentList_size(self)


    def swap(self, v):
        """swap(ArLineSegmentList self, ArLineSegmentList v)"""
        return _AriaPy.ArLineSegmentList_swap(self, v)


    def begin(self):
        """begin(ArLineSegmentList self) -> std::list< ArLineSegment >::iterator"""
        return _AriaPy.ArLineSegmentList_begin(self)


    def end(self):
        """end(ArLineSegmentList self) -> std::list< ArLineSegment >::iterator"""
        return _AriaPy.ArLineSegmentList_end(self)


    def rbegin(self):
        """rbegin(ArLineSegmentList self) -> std::list< ArLineSegment >::reverse_iterator"""
        return _AriaPy.ArLineSegmentList_rbegin(self)


    def rend(self):
        """rend(ArLineSegmentList self) -> std::list< ArLineSegment >::reverse_iterator"""
        return _AriaPy.ArLineSegmentList_rend(self)


    def clear(self):
        """clear(ArLineSegmentList self)"""
        return _AriaPy.ArLineSegmentList_clear(self)


    def get_allocator(self):
        """get_allocator(ArLineSegmentList self) -> std::list< ArLineSegment >::allocator_type"""
        return _AriaPy.ArLineSegmentList_get_allocator(self)


    def pop_back(self):
        """pop_back(ArLineSegmentList self)"""
        return _AriaPy.ArLineSegmentList_pop_back(self)


    def erase(self, *args):
        """
        erase(ArLineSegmentList self, std::list< ArLineSegment >::iterator pos) -> std::list< ArLineSegment >::iterator
        erase(ArLineSegmentList self, std::list< ArLineSegment >::iterator first, std::list< ArLineSegment >::iterator last) -> std::list< ArLineSegment >::iterator
        """
        return _AriaPy.ArLineSegmentList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(ArLineSegment)> self) -> ArLineSegmentList
        __init__(std::list<(ArLineSegment)> self, ArLineSegmentList arg2) -> ArLineSegmentList
        __init__(std::list<(ArLineSegment)> self, std::list< ArLineSegment >::size_type size) -> ArLineSegmentList
        __init__(std::list<(ArLineSegment)> self, std::list< ArLineSegment >::size_type size, ArLineSegment value) -> ArLineSegmentList
        """
        this = _AriaPy.new_ArLineSegmentList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ArLineSegmentList self, ArLineSegment x)"""
        return _AriaPy.ArLineSegmentList_push_back(self, x)


    def front(self):
        """front(ArLineSegmentList self) -> ArLineSegment"""
        return _AriaPy.ArLineSegmentList_front(self)


    def back(self):
        """back(ArLineSegmentList self) -> ArLineSegment"""
        return _AriaPy.ArLineSegmentList_back(self)


    def assign(self, n, x):
        """assign(ArLineSegmentList self, std::list< ArLineSegment >::size_type n, ArLineSegment x)"""
        return _AriaPy.ArLineSegmentList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ArLineSegmentList self, std::list< ArLineSegment >::size_type new_size)
        resize(ArLineSegmentList self, std::list< ArLineSegment >::size_type new_size, ArLineSegment x)
        """
        return _AriaPy.ArLineSegmentList_resize(self, *args)


    def insert(self, *args):
        """
        insert(ArLineSegmentList self, std::list< ArLineSegment >::iterator pos, ArLineSegment x) -> std::list< ArLineSegment >::iterator
        insert(ArLineSegmentList self, std::list< ArLineSegment >::iterator pos, std::list< ArLineSegment >::size_type n, ArLineSegment x)
        """
        return _AriaPy.ArLineSegmentList_insert(self, *args)


    def pop_front(self):
        """pop_front(ArLineSegmentList self)"""
        return _AriaPy.ArLineSegmentList_pop_front(self)


    def push_front(self, x):
        """push_front(ArLineSegmentList self, ArLineSegment x)"""
        return _AriaPy.ArLineSegmentList_push_front(self, x)


    def reverse(self):
        """reverse(ArLineSegmentList self)"""
        return _AriaPy.ArLineSegmentList_reverse(self)

    __swig_destroy__ = _AriaPy.delete_ArLineSegmentList
    __del__ = lambda self: None
ArLineSegmentList_swigregister = _AriaPy.ArLineSegmentList_swigregister
ArLineSegmentList_swigregister(ArLineSegmentList)

class ArLineSegmentPtrList(object):
    """Proxy of C++ std::list<(p.ArLineSegment)> 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(ArLineSegmentPtrList self) -> SwigPyIterator"""
        return _AriaPy.ArLineSegmentPtrList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ArLineSegmentPtrList self) -> bool"""
        return _AriaPy.ArLineSegmentPtrList___nonzero__(self)


    def __bool__(self):
        """__bool__(ArLineSegmentPtrList self) -> bool"""
        return _AriaPy.ArLineSegmentPtrList___bool__(self)


    def __len__(self):
        """__len__(ArLineSegmentPtrList self) -> std::list< ArLineSegment * >::size_type"""
        return _AriaPy.ArLineSegmentPtrList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ArLineSegmentPtrList self, std::list< ArLineSegment * >::difference_type i, std::list< ArLineSegment * >::difference_type j) -> ArLineSegmentPtrList"""
        return _AriaPy.ArLineSegmentPtrList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ArLineSegmentPtrList self, std::list< ArLineSegment * >::difference_type i, std::list< ArLineSegment * >::difference_type j)
        __setslice__(ArLineSegmentPtrList self, std::list< ArLineSegment * >::difference_type i, std::list< ArLineSegment * >::difference_type j, ArLineSegmentPtrList v)
        """
        return _AriaPy.ArLineSegmentPtrList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ArLineSegmentPtrList self, std::list< ArLineSegment * >::difference_type i, std::list< ArLineSegment * >::difference_type j)"""
        return _AriaPy.ArLineSegmentPtrList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ArLineSegmentPtrList self, std::list< ArLineSegment * >::difference_type i)
        __delitem__(ArLineSegmentPtrList self, PySliceObject * slice)
        """
        return _AriaPy.ArLineSegmentPtrList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ArLineSegmentPtrList self, PySliceObject * slice) -> ArLineSegmentPtrList
        __getitem__(ArLineSegmentPtrList self, std::list< ArLineSegment * >::difference_type i) -> ArLineSegment
        """
        return _AriaPy.ArLineSegmentPtrList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ArLineSegmentPtrList self, PySliceObject * slice, ArLineSegmentPtrList v)
        __setitem__(ArLineSegmentPtrList self, PySliceObject * slice)
        __setitem__(ArLineSegmentPtrList self, std::list< ArLineSegment * >::difference_type i, ArLineSegment x)
        """
        return _AriaPy.ArLineSegmentPtrList___setitem__(self, *args)


    def pop(self):
        """pop(ArLineSegmentPtrList self) -> ArLineSegment"""
        return _AriaPy.ArLineSegmentPtrList_pop(self)


    def append(self, x):
        """append(ArLineSegmentPtrList self, ArLineSegment x)"""
        return _AriaPy.ArLineSegmentPtrList_append(self, x)


    def empty(self):
        """empty(ArLineSegmentPtrList self) -> bool"""
        return _AriaPy.ArLineSegmentPtrList_empty(self)


    def size(self):
        """size(ArLineSegmentPtrList self) -> std::list< ArLineSegment * >::size_type"""
        return _AriaPy.ArLineSegmentPtrList_size(self)


    def swap(self, v):
        """swap(ArLineSegmentPtrList self, ArLineSegmentPtrList v)"""
        return _AriaPy.ArLineSegmentPtrList_swap(self, v)


    def begin(self):
        """begin(ArLineSegmentPtrList self) -> std::list< ArLineSegment * >::iterator"""
        return _AriaPy.ArLineSegmentPtrList_begin(self)


    def end(self):
        """end(ArLineSegmentPtrList self) -> std::list< ArLineSegment * >::iterator"""
        return _AriaPy.ArLineSegmentPtrList_end(self)


    def rbegin(self):
        """rbegin(ArLineSegmentPtrList self) -> std::list< ArLineSegment * >::reverse_iterator"""
        return _AriaPy.ArLineSegmentPtrList_rbegin(self)


    def rend(self):
        """rend(ArLineSegmentPtrList self) -> std::list< ArLineSegment * >::reverse_iterator"""
        return _AriaPy.ArLineSegmentPtrList_rend(self)


    def clear(self):
        """clear(ArLineSegmentPtrList self)"""
        return _AriaPy.ArLineSegmentPtrList_clear(self)


    def get_allocator(self):
        """get_allocator(ArLineSegmentPtrList self) -> std::list< ArLineSegment * >::allocator_type"""
        return _AriaPy.ArLineSegmentPtrList_get_allocator(self)


    def pop_back(self):
        """pop_back(ArLineSegmentPtrList self)"""
        return _AriaPy.ArLineSegmentPtrList_pop_back(self)


    def erase(self, *args):
        """
        erase(ArLineSegmentPtrList self, std::list< ArLineSegment * >::iterator pos) -> std::list< ArLineSegment * >::iterator
        erase(ArLineSegmentPtrList self, std::list< ArLineSegment * >::iterator first, std::list< ArLineSegment * >::iterator last) -> std::list< ArLineSegment * >::iterator
        """
        return _AriaPy.ArLineSegmentPtrList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(p.ArLineSegment)> self) -> ArLineSegmentPtrList
        __init__(std::list<(p.ArLineSegment)> self, ArLineSegmentPtrList arg2) -> ArLineSegmentPtrList
        __init__(std::list<(p.ArLineSegment)> self, std::list< ArLineSegment * >::size_type size) -> ArLineSegmentPtrList
        __init__(std::list<(p.ArLineSegment)> self, std::list< ArLineSegment * >::size_type size, ArLineSegment value) -> ArLineSegmentPtrList
        """
        this = _AriaPy.new_ArLineSegmentPtrList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ArLineSegmentPtrList self, ArLineSegment x)"""
        return _AriaPy.ArLineSegmentPtrList_push_back(self, x)


    def front(self):
        """front(ArLineSegmentPtrList self) -> ArLineSegment"""
        return _AriaPy.ArLineSegmentPtrList_front(self)


    def back(self):
        """back(ArLineSegmentPtrList self) -> ArLineSegment"""
        return _AriaPy.ArLineSegmentPtrList_back(self)


    def assign(self, n, x):
        """assign(ArLineSegmentPtrList self, std::list< ArLineSegment * >::size_type n, ArLineSegment x)"""
        return _AriaPy.ArLineSegmentPtrList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ArLineSegmentPtrList self, std::list< ArLineSegment * >::size_type new_size)
        resize(ArLineSegmentPtrList self, std::list< ArLineSegment * >::size_type new_size, ArLineSegment x)
        """
        return _AriaPy.ArLineSegmentPtrList_resize(self, *args)


    def insert(self, *args):
        """
        insert(ArLineSegmentPtrList self, std::list< ArLineSegment * >::iterator pos, ArLineSegment x) -> std::list< ArLineSegment * >::iterator
        insert(ArLineSegmentPtrList self, std::list< ArLineSegment * >::iterator pos, std::list< ArLineSegment * >::size_type n, ArLineSegment x)
        """
        return _AriaPy.ArLineSegmentPtrList_insert(self, *args)


    def pop_front(self):
        """pop_front(ArLineSegmentPtrList self)"""
        return _AriaPy.ArLineSegmentPtrList_pop_front(self)


    def push_front(self, x):
        """push_front(ArLineSegmentPtrList self, ArLineSegment x)"""
        return _AriaPy.ArLineSegmentPtrList_push_front(self, x)


    def remove(self, x):
        """remove(ArLineSegmentPtrList self, ArLineSegment x)"""
        return _AriaPy.ArLineSegmentPtrList_remove(self, x)


    def unique(self):
        """unique(ArLineSegmentPtrList self)"""
        return _AriaPy.ArLineSegmentPtrList_unique(self)


    def reverse(self):
        """reverse(ArLineSegmentPtrList self)"""
        return _AriaPy.ArLineSegmentPtrList_reverse(self)


    def sort(self):
        """sort(ArLineSegmentPtrList self)"""
        return _AriaPy.ArLineSegmentPtrList_sort(self)


    def merge(self, x):
        """merge(ArLineSegmentPtrList self, ArLineSegmentPtrList x)"""
        return _AriaPy.ArLineSegmentPtrList_merge(self, x)

    __swig_destroy__ = _AriaPy.delete_ArLineSegmentPtrList
    __del__ = lambda self: None
ArLineSegmentPtrList_swigregister = _AriaPy.ArLineSegmentPtrList_swigregister
ArLineSegmentPtrList_swigregister(ArLineSegmentPtrList)

class IntSet(object):
    """Proxy of C++ std::set<(int)> 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(IntSet self) -> SwigPyIterator"""
        return _AriaPy.IntSet_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(IntSet self) -> bool"""
        return _AriaPy.IntSet___nonzero__(self)


    def __bool__(self):
        """__bool__(IntSet self) -> bool"""
        return _AriaPy.IntSet___bool__(self)


    def __len__(self):
        """__len__(IntSet self) -> std::set< int >::size_type"""
        return _AriaPy.IntSet___len__(self)


    def append(self, x):
        """append(IntSet self, std::set< int >::value_type x)"""
        return _AriaPy.IntSet_append(self, x)


    def __contains__(self, x):
        """__contains__(IntSet self, std::set< int >::value_type x) -> bool"""
        return _AriaPy.IntSet___contains__(self, x)


    def __getitem__(self, i):
        """__getitem__(IntSet self, std::set< int >::difference_type i) -> std::set< int >::value_type"""
        return _AriaPy.IntSet___getitem__(self, i)


    def add(self, x):
        """add(IntSet self, std::set< int >::value_type x)"""
        return _AriaPy.IntSet_add(self, x)


    def discard(self, x):
        """discard(IntSet self, std::set< int >::value_type x)"""
        return _AriaPy.IntSet_discard(self, x)


    def __init__(self, *args):
        """
        __init__(std::set<(int)> self, std::less< int > const & arg2) -> IntSet
        __init__(std::set<(int)> self) -> IntSet
        __init__(std::set<(int)> self, IntSet arg2) -> IntSet
        """
        this = _AriaPy.new_IntSet(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        """empty(IntSet self) -> bool"""
        return _AriaPy.IntSet_empty(self)


    def size(self):
        """size(IntSet self) -> std::set< int >::size_type"""
        return _AriaPy.IntSet_size(self)


    def clear(self):
        """clear(IntSet self)"""
        return _AriaPy.IntSet_clear(self)


    def swap(self, v):
        """swap(IntSet self, IntSet v)"""
        return _AriaPy.IntSet_swap(self, v)


    def count(self, x):
        """count(IntSet self, std::set< int >::key_type const & x) -> std::set< int >::size_type"""
        return _AriaPy.IntSet_count(self, x)


    def begin(self):
        """begin(IntSet self) -> std::set< int >::iterator"""
        return _AriaPy.IntSet_begin(self)


    def end(self):
        """end(IntSet self) -> std::set< int >::iterator"""
        return _AriaPy.IntSet_end(self)


    def rbegin(self):
        """rbegin(IntSet self) -> std::set< int >::reverse_iterator"""
        return _AriaPy.IntSet_rbegin(self)


    def rend(self):
        """rend(IntSet self) -> std::set< int >::reverse_iterator"""
        return _AriaPy.IntSet_rend(self)


    def erase(self, *args):
        """
        erase(IntSet self, std::set< int >::key_type const & x) -> std::set< int >::size_type
        erase(IntSet self, std::set< int >::iterator pos)
        erase(IntSet self, std::set< int >::iterator first, std::set< int >::iterator last)
        """
        return _AriaPy.IntSet_erase(self, *args)


    def find(self, x):
        """find(IntSet self, std::set< int >::key_type const & x) -> std::set< int >::iterator"""
        return _AriaPy.IntSet_find(self, x)


    def lower_bound(self, x):
        """lower_bound(IntSet self, std::set< int >::key_type const & x) -> std::set< int >::iterator"""
        return _AriaPy.IntSet_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(IntSet self, std::set< int >::key_type const & x) -> std::set< int >::iterator"""
        return _AriaPy.IntSet_upper_bound(self, x)


    def equal_range(self, x):
        """equal_range(IntSet self, std::set< int >::key_type const & x) -> std::pair< std::set< int >::iterator,std::set< int >::iterator >"""
        return _AriaPy.IntSet_equal_range(self, x)


    def insert(self, __x):
        """insert(IntSet self, std::set< int >::value_type const & __x) -> std::pair< std::set< int >::iterator,bool >"""
        return _AriaPy.IntSet_insert(self, __x)

    __swig_destroy__ = _AriaPy.delete_IntSet
    __del__ = lambda self: None
IntSet_swigregister = _AriaPy.IntSet_swigregister
IntSet_swigregister(IntSet)

class IntArPoseMap(object):
    """Proxy of C++ std::map<(int,ArPose)> 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(IntArPoseMap self) -> SwigPyIterator"""
        return _AriaPy.IntArPoseMap_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(IntArPoseMap self) -> bool"""
        return _AriaPy.IntArPoseMap___nonzero__(self)


    def __bool__(self):
        """__bool__(IntArPoseMap self) -> bool"""
        return _AriaPy.IntArPoseMap___bool__(self)


    def __len__(self):
        """__len__(IntArPoseMap self) -> std::map< int,ArPose >::size_type"""
        return _AriaPy.IntArPoseMap___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, key):
        """__getitem__(IntArPoseMap self, std::map< int,ArPose >::key_type const & key) -> ArPose"""
        return _AriaPy.IntArPoseMap___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(IntArPoseMap self, std::map< int,ArPose >::key_type const & key)"""
        return _AriaPy.IntArPoseMap___delitem__(self, key)


    def has_key(self, key):
        """has_key(IntArPoseMap self, std::map< int,ArPose >::key_type const & key) -> bool"""
        return _AriaPy.IntArPoseMap_has_key(self, key)


    def keys(self):
        """keys(IntArPoseMap self) -> PyObject *"""
        return _AriaPy.IntArPoseMap_keys(self)


    def values(self):
        """values(IntArPoseMap self) -> PyObject *"""
        return _AriaPy.IntArPoseMap_values(self)


    def items(self):
        """items(IntArPoseMap self) -> PyObject *"""
        return _AriaPy.IntArPoseMap_items(self)


    def __contains__(self, key):
        """__contains__(IntArPoseMap self, std::map< int,ArPose >::key_type const & key) -> bool"""
        return _AriaPy.IntArPoseMap___contains__(self, key)


    def key_iterator(self):
        """key_iterator(IntArPoseMap self) -> SwigPyIterator"""
        return _AriaPy.IntArPoseMap_key_iterator(self)


    def value_iterator(self):
        """value_iterator(IntArPoseMap self) -> SwigPyIterator"""
        return _AriaPy.IntArPoseMap_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(IntArPoseMap self, std::map< int,ArPose >::key_type const & key)
        __setitem__(IntArPoseMap self, std::map< int,ArPose >::key_type const & key, ArPose x)
        """
        return _AriaPy.IntArPoseMap___setitem__(self, *args)


    def asdict(self):
        """asdict(IntArPoseMap self) -> PyObject *"""
        return _AriaPy.IntArPoseMap_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(int,ArPose)> self, std::less< int > const & arg2) -> IntArPoseMap
        __init__(std::map<(int,ArPose)> self) -> IntArPoseMap
        __init__(std::map<(int,ArPose)> self, IntArPoseMap arg2) -> IntArPoseMap
        """
        this = _AriaPy.new_IntArPoseMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        """empty(IntArPoseMap self) -> bool"""
        return _AriaPy.IntArPoseMap_empty(self)


    def size(self):
        """size(IntArPoseMap self) -> std::map< int,ArPose >::size_type"""
        return _AriaPy.IntArPoseMap_size(self)


    def swap(self, v):
        """swap(IntArPoseMap self, IntArPoseMap v)"""
        return _AriaPy.IntArPoseMap_swap(self, v)


    def begin(self):
        """begin(IntArPoseMap self) -> std::map< int,ArPose >::iterator"""
        return _AriaPy.IntArPoseMap_begin(self)


    def end(self):
        """end(IntArPoseMap self) -> std::map< int,ArPose >::iterator"""
        return _AriaPy.IntArPoseMap_end(self)


    def rbegin(self):
        """rbegin(IntArPoseMap self) -> std::map< int,ArPose >::reverse_iterator"""
        return _AriaPy.IntArPoseMap_rbegin(self)


    def rend(self):
        """rend(IntArPoseMap self) -> std::map< int,ArPose >::reverse_iterator"""
        return _AriaPy.IntArPoseMap_rend(self)


    def clear(self):
        """clear(IntArPoseMap self)"""
        return _AriaPy.IntArPoseMap_clear(self)


    def get_allocator(self):
        """get_allocator(IntArPoseMap self) -> std::map< int,ArPose >::allocator_type"""
        return _AriaPy.IntArPoseMap_get_allocator(self)


    def count(self, x):
        """count(IntArPoseMap self, std::map< int,ArPose >::key_type const & x) -> std::map< int,ArPose >::size_type"""
        return _AriaPy.IntArPoseMap_count(self, x)


    def erase(self, *args):
        """
        erase(IntArPoseMap self, std::map< int,ArPose >::key_type const & x) -> std::map< int,ArPose >::size_type
        erase(IntArPoseMap self, std::map< int,ArPose >::iterator position)
        erase(IntArPoseMap self, std::map< int,ArPose >::iterator first, std::map< int,ArPose >::iterator last)
        """
        return _AriaPy.IntArPoseMap_erase(self, *args)


    def find(self, x):
        """find(IntArPoseMap self, std::map< int,ArPose >::key_type const & x) -> std::map< int,ArPose >::iterator"""
        return _AriaPy.IntArPoseMap_find(self, x)


    def lower_bound(self, x):
        """lower_bound(IntArPoseMap self, std::map< int,ArPose >::key_type const & x) -> std::map< int,ArPose >::iterator"""
        return _AriaPy.IntArPoseMap_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(IntArPoseMap self, std::map< int,ArPose >::key_type const & x) -> std::map< int,ArPose >::iterator"""
        return _AriaPy.IntArPoseMap_upper_bound(self, x)

    __swig_destroy__ = _AriaPy.delete_IntArPoseMap
    __del__ = lambda self: None
IntArPoseMap_swigregister = _AriaPy.IntArPoseMap_swigregister
IntArPoseMap_swigregister(IntArPoseMap)

class ArListPos(object):
    """Proxy of C++ ArListPos class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    FIRST = _AriaPy.ArListPos_FIRST
    LAST = _AriaPy.ArListPos_LAST

    def __init__(self):
        """__init__(ArListPos self) -> ArListPos"""
        this = _AriaPy.new_ArListPos()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArListPos
    __del__ = lambda self: None
ArListPos_swigregister = _AriaPy.ArListPos_swigregister
ArListPos_swigregister(ArListPos)

class ArTypes(object):
    """Proxy of C++ ArTypes 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):
        """__init__(ArTypes self) -> ArTypes"""
        this = _AriaPy.new_ArTypes()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArTypes
    __del__ = lambda self: None
ArTypes_swigregister = _AriaPy.ArTypes_swigregister
ArTypes_swigregister(ArTypes)

_GNU_SOURCE = _AriaPy._GNU_SOURCE
M_PI = _AriaPy.M_PI
class ArUtil(object):
    """Proxy of C++ ArUtil class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    BIT0 = _AriaPy.ArUtil_BIT0
    BIT1 = _AriaPy.ArUtil_BIT1
    BIT2 = _AriaPy.ArUtil_BIT2
    BIT3 = _AriaPy.ArUtil_BIT3
    BIT4 = _AriaPy.ArUtil_BIT4
    BIT5 = _AriaPy.ArUtil_BIT5
    BIT6 = _AriaPy.ArUtil_BIT6
    BIT7 = _AriaPy.ArUtil_BIT7
    BIT8 = _AriaPy.ArUtil_BIT8
    BIT9 = _AriaPy.ArUtil_BIT9
    BIT10 = _AriaPy.ArUtil_BIT10
    BIT11 = _AriaPy.ArUtil_BIT11
    BIT12 = _AriaPy.ArUtil_BIT12
    BIT13 = _AriaPy.ArUtil_BIT13
    BIT14 = _AriaPy.ArUtil_BIT14
    BIT15 = _AriaPy.ArUtil_BIT15

    def sleep(ms):
        """sleep(unsigned int ms)"""
        return _AriaPy.ArUtil_sleep(ms)

    sleep = staticmethod(sleep)

    def getTime():
        """getTime() -> unsigned int"""
        return _AriaPy.ArUtil_getTime()

    getTime = staticmethod(getTime)

    def findMin(*args):
        """
        findMin(int first, int second) -> int
        findMin(double first, double second) -> double
        """
        return _AriaPy.ArUtil_findMin(*args)

    findMin = staticmethod(findMin)

    def findMax(*args):
        """
        findMax(int first, int second) -> int
        findMax(double first, double second) -> double
        """
        return _AriaPy.ArUtil_findMax(*args)

    findMax = staticmethod(findMax)

    def sizeFile(*args):
        """
        sizeFile(char const * fileName) -> long
        sizeFile(std::string fileName) -> long
        """
        return _AriaPy.ArUtil_sizeFile(*args)

    sizeFile = staticmethod(sizeFile)

    def findFile(fileName):
        """findFile(char const * fileName) -> bool"""
        return _AriaPy.ArUtil_findFile(fileName)

    findFile = staticmethod(findFile)

    def appendSlash(*args):
        """
        appendSlash(char * path, size_t pathLength)
        appendSlash(std::string & path)
        """
        return _AriaPy.ArUtil_appendSlash(*args)

    appendSlash = staticmethod(appendSlash)

    def fixSlashes(*args):
        """
        fixSlashes(char * path, size_t pathLength)
        fixSlashes(std::string & path)
        """
        return _AriaPy.ArUtil_fixSlashes(*args)

    fixSlashes = staticmethod(fixSlashes)

    def fixSlashesForward(path, pathLength):
        """fixSlashesForward(char * path, size_t pathLength)"""
        return _AriaPy.ArUtil_fixSlashesForward(path, pathLength)

    fixSlashesForward = staticmethod(fixSlashesForward)

    def fixSlashesBackward(path, pathLength):
        """fixSlashesBackward(char * path, size_t pathLength)"""
        return _AriaPy.ArUtil_fixSlashesBackward(path, pathLength)

    fixSlashesBackward = staticmethod(fixSlashesBackward)

    def getSlash():
        """getSlash() -> char"""
        return _AriaPy.ArUtil_getSlash()

    getSlash = staticmethod(getSlash)

    def addDirectories(dest, destLength, baseDir, insideDir):
        """addDirectories(char * dest, size_t destLength, char const * baseDir, char const * insideDir)"""
        return _AriaPy.ArUtil_addDirectories(dest, destLength, baseDir, insideDir)

    addDirectories = staticmethod(addDirectories)

    def strcmp(*args):
        """
        strcmp(std::string str, std::string str2) -> int
        strcmp(std::string str, char const * str2) -> int
        strcmp(char const * str, std::string str2) -> int
        strcmp(char const * str, char const * str2) -> int
        """
        return _AriaPy.ArUtil_strcmp(*args)

    strcmp = staticmethod(strcmp)

    def strcasecmp(*args):
        """
        strcasecmp(std::string str, std::string str2) -> int
        strcasecmp(std::string str, char const * str2) -> int
        strcasecmp(char const * str, std::string str2) -> int
        strcasecmp(char const * str, char const * str2) -> int
        """
        return _AriaPy.ArUtil_strcasecmp(*args)

    strcasecmp = staticmethod(strcasecmp)

    def strSuffixCmp(str, suffix):
        """strSuffixCmp(char const * str, char const * suffix) -> bool"""
        return _AriaPy.ArUtil_strSuffixCmp(str, suffix)

    strSuffixCmp = staticmethod(strSuffixCmp)

    def strSuffixCaseCmp(str, suffix):
        """strSuffixCaseCmp(char const * str, char const * suffix) -> bool"""
        return _AriaPy.ArUtil_strSuffixCaseCmp(str, suffix)

    strSuffixCaseCmp = staticmethod(strSuffixCaseCmp)

    def strcasequotecmp(str1, str2):
        """strcasequotecmp(std::string const & str1, std::string const & str2) -> int"""
        return _AriaPy.ArUtil_strcasequotecmp(str1, str2)

    strcasequotecmp = staticmethod(strcasequotecmp)

    def escapeSpaces(dest, src, maxLen):
        """escapeSpaces(char * dest, char const * src, size_t maxLen)"""
        return _AriaPy.ArUtil_escapeSpaces(dest, src, maxLen)

    escapeSpaces = staticmethod(escapeSpaces)

    def stripQuotes(*args):
        """
        stripQuotes(char * dest, char const * src, size_t destLen) -> bool
        stripQuotes(std::string * strToStrip) -> bool
        """
        return _AriaPy.ArUtil_stripQuotes(*args)

    stripQuotes = staticmethod(stripQuotes)

    def lower(dest, src, maxLen):
        """lower(char * dest, char const * src, size_t maxLen)"""
        return _AriaPy.ArUtil_lower(dest, src, maxLen)

    lower = staticmethod(lower)

    def isOnlyAlphaNumeric(str):
        """isOnlyAlphaNumeric(char const * str) -> bool"""
        return _AriaPy.ArUtil_isOnlyAlphaNumeric(str)

    isOnlyAlphaNumeric = staticmethod(isOnlyAlphaNumeric)

    def isOnlyNumeric(str):
        """isOnlyNumeric(char const * str) -> bool"""
        return _AriaPy.ArUtil_isOnlyNumeric(str)

    isOnlyNumeric = staticmethod(isOnlyNumeric)

    def isStrEmpty(str):
        """isStrEmpty(char const * str) -> bool"""
        return _AriaPy.ArUtil_isStrEmpty(str)

    isStrEmpty = staticmethod(isStrEmpty)

    def isStrInList(str, list, isIgnoreCase=False):
        """
        isStrInList(char const * str, std::list< std::string,std::allocator< std::string > > const & list, bool isIgnoreCase=False) -> bool
        isStrInList(char const * str, std::list< std::string,std::allocator< std::string > > const & list) -> bool
        """
        return _AriaPy.ArUtil_isStrInList(str, list, isIgnoreCase)

    isStrInList = staticmethod(isStrInList)

    def atof(nptr):
        """atof(char const * nptr) -> double"""
        return _AriaPy.ArUtil_atof(nptr)

    atof = staticmethod(atof)

    def convertBool(val):
        """convertBool(int val) -> char const *"""
        return _AriaPy.ArUtil_convertBool(val)

    convertBool = staticmethod(convertBool)

    def writeToFile(str, file):
        """writeToFile(char const * str, FILE * file)"""
        return _AriaPy.ArUtil_writeToFile(str, file)

    writeToFile = staticmethod(writeToFile)

    def getStringFromFile(fileName, str, strLen):
        """getStringFromFile(char const * fileName, char * str, size_t strLen) -> bool"""
        return _AriaPy.ArUtil_getStringFromFile(fileName, str, strLen)

    getStringFromFile = staticmethod(getStringFromFile)
    REGKEY_CLASSES_ROOT = _AriaPy.ArUtil_REGKEY_CLASSES_ROOT
    REGKEY_CURRENT_CONFIG = _AriaPy.ArUtil_REGKEY_CURRENT_CONFIG
    REGKEY_CURRENT_USER = _AriaPy.ArUtil_REGKEY_CURRENT_USER
    REGKEY_LOCAL_MACHINE = _AriaPy.ArUtil_REGKEY_LOCAL_MACHINE
    REGKEY_USERS = _AriaPy.ArUtil_REGKEY_USERS

    def getStringFromRegistry(root, key, value, str, len):
        """getStringFromRegistry(ArUtil::REGKEY root, char const * key, char const * value, char * str, int len) -> bool"""
        return _AriaPy.ArUtil_getStringFromRegistry(root, key, value, str, len)

    getStringFromRegistry = staticmethod(getStringFromRegistry)

    def findFirstStringInRegistry(key, value, str, len):
        """findFirstStringInRegistry(char const * key, char const * value, char * str, int len) -> bool"""
        return _AriaPy.ArUtil_findFirstStringInRegistry(key, value, str, len)

    findFirstStringInRegistry = staticmethod(findFirstStringInRegistry)
    COM1 = _swig_property(_AriaPy.ArUtil_COM1_get, _AriaPy.ArUtil_COM1_set)
    COM2 = _swig_property(_AriaPy.ArUtil_COM2_get, _AriaPy.ArUtil_COM2_set)
    COM3 = _swig_property(_AriaPy.ArUtil_COM3_get, _AriaPy.ArUtil_COM3_set)
    COM4 = _swig_property(_AriaPy.ArUtil_COM4_get, _AriaPy.ArUtil_COM4_set)
    COM5 = _swig_property(_AriaPy.ArUtil_COM5_get, _AriaPy.ArUtil_COM5_set)
    COM6 = _swig_property(_AriaPy.ArUtil_COM6_get, _AriaPy.ArUtil_COM6_set)
    COM7 = _swig_property(_AriaPy.ArUtil_COM7_get, _AriaPy.ArUtil_COM7_set)
    COM8 = _swig_property(_AriaPy.ArUtil_COM8_get, _AriaPy.ArUtil_COM8_set)
    COM9 = _swig_property(_AriaPy.ArUtil_COM9_get, _AriaPy.ArUtil_COM9_set)
    COM10 = _swig_property(_AriaPy.ArUtil_COM10_get, _AriaPy.ArUtil_COM10_set)
    COM11 = _swig_property(_AriaPy.ArUtil_COM11_get, _AriaPy.ArUtil_COM11_set)
    COM12 = _swig_property(_AriaPy.ArUtil_COM12_get, _AriaPy.ArUtil_COM12_set)
    COM13 = _swig_property(_AriaPy.ArUtil_COM13_get, _AriaPy.ArUtil_COM13_set)
    COM14 = _swig_property(_AriaPy.ArUtil_COM14_get, _AriaPy.ArUtil_COM14_set)
    COM15 = _swig_property(_AriaPy.ArUtil_COM15_get, _AriaPy.ArUtil_COM15_set)
    COM16 = _swig_property(_AriaPy.ArUtil_COM16_get, _AriaPy.ArUtil_COM16_set)
    TRUESTRING = _swig_property(_AriaPy.ArUtil_TRUESTRING_get, _AriaPy.ArUtil_TRUESTRING_set)
    FALSESTRING = _swig_property(_AriaPy.ArUtil_FALSESTRING_get, _AriaPy.ArUtil_FALSESTRING_set)

    def putCurrentYearInString(s, len):
        """putCurrentYearInString(char * s, size_t len)"""
        return _AriaPy.ArUtil_putCurrentYearInString(s, len)

    putCurrentYearInString = staticmethod(putCurrentYearInString)

    def putCurrentMonthInString(s, len):
        """putCurrentMonthInString(char * s, size_t len)"""
        return _AriaPy.ArUtil_putCurrentMonthInString(s, len)

    putCurrentMonthInString = staticmethod(putCurrentMonthInString)

    def putCurrentDayInString(s, len):
        """putCurrentDayInString(char * s, size_t len)"""
        return _AriaPy.ArUtil_putCurrentDayInString(s, len)

    putCurrentDayInString = staticmethod(putCurrentDayInString)

    def putCurrentHourInString(s, len):
        """putCurrentHourInString(char * s, size_t len)"""
        return _AriaPy.ArUtil_putCurrentHourInString(s, len)

    putCurrentHourInString = staticmethod(putCurrentHourInString)

    def putCurrentMinuteInString(s, len):
        """putCurrentMinuteInString(char * s, size_t len)"""
        return _AriaPy.ArUtil_putCurrentMinuteInString(s, len)

    putCurrentMinuteInString = staticmethod(putCurrentMinuteInString)

    def putCurrentSecondInString(s, len):
        """putCurrentSecondInString(char * s, size_t len)"""
        return _AriaPy.ArUtil_putCurrentSecondInString(s, len)

    putCurrentSecondInString = staticmethod(putCurrentSecondInString)

    def parseTime(str, ok=None, toToday=True):
        """
        parseTime(char const * str, bool * ok=None, bool toToday=True) -> time_t
        parseTime(char const * str, bool * ok=None) -> time_t
        parseTime(char const * str) -> time_t
        """
        return _AriaPy.ArUtil_parseTime(str, ok, toToday)

    parseTime = staticmethod(parseTime)

    def localtime(*args):
        """
        localtime(time_t const * timep, tm * result) -> bool
        localtime(tm * result) -> bool
        """
        return _AriaPy.ArUtil_localtime(*args)

    localtime = staticmethod(localtime)

    def matchCase(baseDir, fileName, result, resultLen):
        """matchCase(char const * baseDir, char const * fileName, char * result, size_t resultLen) -> bool"""
        return _AriaPy.ArUtil_matchCase(baseDir, fileName, result, resultLen)

    matchCase = staticmethod(matchCase)

    def getDirectory(fileName, result, resultLen):
        """getDirectory(char const * fileName, char * result, size_t resultLen) -> bool"""
        return _AriaPy.ArUtil_getDirectory(fileName, result, resultLen)

    getDirectory = staticmethod(getDirectory)

    def getFileName(fileName, result, resultLen):
        """getFileName(char const * fileName, char * result, size_t resultLen) -> bool"""
        return _AriaPy.ArUtil_getFileName(fileName, result, resultLen)

    getFileName = staticmethod(getFileName)

    def changeFileTimestamp(fileName, timestamp):
        """changeFileTimestamp(char const * fileName, time_t timestamp) -> bool"""
        return _AriaPy.ArUtil_changeFileTimestamp(fileName, timestamp)

    changeFileTimestamp = staticmethod(changeFileTimestamp)

    def fopen(path, mode, closeOnExec=True):
        """
        fopen(char const * path, char const * mode, bool closeOnExec=True) -> FILE
        fopen(char const * path, char const * mode) -> FILE *
        """
        return _AriaPy.ArUtil_fopen(path, mode, closeOnExec)

    fopen = staticmethod(fopen)

    def open(*args):
        """
        open(char const * pathname, int flags, bool closeOnExec=True) -> int
        open(char const * pathname, int flags) -> int
        open(char const * pathname, int flags, mode_t mode, bool closeOnExec=True) -> int
        open(char const * pathname, int flags, mode_t mode) -> int
        """
        return _AriaPy.ArUtil_open(*args)

    open = staticmethod(open)

    def creat(pathname, mode, closeOnExec=True):
        """
        creat(char const * pathname, mode_t mode, bool closeOnExec=True) -> int
        creat(char const * pathname, mode_t mode) -> int
        """
        return _AriaPy.ArUtil_creat(pathname, mode, closeOnExec)

    creat = staticmethod(creat)

    def popen(command, type, closeOnExec=True):
        """
        popen(char const * command, char const * type, bool closeOnExec=True) -> FILE
        popen(char const * command, char const * type) -> FILE *
        """
        return _AriaPy.ArUtil_popen(command, type, closeOnExec)

    popen = staticmethod(popen)

    def setFileCloseOnExec(*args):
        """
        setFileCloseOnExec(int fd, bool closeOnExec=True)
        setFileCloseOnExec(int fd)
        setFileCloseOnExec(FILE * file, bool closeOnExec=True)
        setFileCloseOnExec(FILE * file)
        """
        return _AriaPy.ArUtil_setFileCloseOnExec(*args)

    setFileCloseOnExec = staticmethod(setFileCloseOnExec)

    def floatIsNormal(f):
        """floatIsNormal(double f) -> bool"""
        return _AriaPy.ArUtil_floatIsNormal(f)

    floatIsNormal = staticmethod(floatIsNormal)

    def secToMSec(sec):
        """secToMSec(double const sec) -> double"""
        return _AriaPy.ArUtil_secToMSec(sec)

    secToMSec = staticmethod(secToMSec)

    def mSecToSec(msec):
        """mSecToSec(double const msec) -> double"""
        return _AriaPy.ArUtil_mSecToSec(msec)

    mSecToSec = staticmethod(mSecToSec)

    def metersToFeet(m):
        """metersToFeet(double const m) -> double"""
        return _AriaPy.ArUtil_metersToFeet(m)

    metersToFeet = staticmethod(metersToFeet)

    def feetToMeters(f):
        """feetToMeters(double const f) -> double"""
        return _AriaPy.ArUtil_feetToMeters(f)

    feetToMeters = staticmethod(feetToMeters)

    def __init__(self):
        """__init__(ArUtil self) -> ArUtil"""
        this = _AriaPy.new_ArUtil()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArUtil
    __del__ = lambda self: None
ArUtil_swigregister = _AriaPy.ArUtil_swigregister
ArUtil_swigregister(ArUtil)

def ArUtil_sleep(ms):
    """ArUtil_sleep(unsigned int ms)"""
    return _AriaPy.ArUtil_sleep(ms)

def ArUtil_getTime():
    """ArUtil_getTime() -> unsigned int"""
    return _AriaPy.ArUtil_getTime()

def ArUtil_findMin(*args):
    """
    findMin(int first, int second) -> int
    ArUtil_findMin(double first, double second) -> double
    """
    return _AriaPy.ArUtil_findMin(*args)

def ArUtil_findMax(*args):
    """
    findMax(int first, int second) -> int
    ArUtil_findMax(double first, double second) -> double
    """
    return _AriaPy.ArUtil_findMax(*args)

def ArUtil_sizeFile(*args):
    """
    sizeFile(char const * fileName) -> long
    ArUtil_sizeFile(std::string fileName) -> long
    """
    return _AriaPy.ArUtil_sizeFile(*args)

def ArUtil_findFile(fileName):
    """ArUtil_findFile(char const * fileName) -> bool"""
    return _AriaPy.ArUtil_findFile(fileName)

def ArUtil_appendSlash(*args):
    """
    appendSlash(char * path, size_t pathLength)
    ArUtil_appendSlash(std::string & path)
    """
    return _AriaPy.ArUtil_appendSlash(*args)

def ArUtil_fixSlashes(*args):
    """
    fixSlashes(char * path, size_t pathLength)
    ArUtil_fixSlashes(std::string & path)
    """
    return _AriaPy.ArUtil_fixSlashes(*args)

def ArUtil_fixSlashesForward(path, pathLength):
    """ArUtil_fixSlashesForward(char * path, size_t pathLength)"""
    return _AriaPy.ArUtil_fixSlashesForward(path, pathLength)

def ArUtil_fixSlashesBackward(path, pathLength):
    """ArUtil_fixSlashesBackward(char * path, size_t pathLength)"""
    return _AriaPy.ArUtil_fixSlashesBackward(path, pathLength)

def ArUtil_getSlash():
    """ArUtil_getSlash() -> char"""
    return _AriaPy.ArUtil_getSlash()

def ArUtil_addDirectories(dest, destLength, baseDir, insideDir):
    """ArUtil_addDirectories(char * dest, size_t destLength, char const * baseDir, char const * insideDir)"""
    return _AriaPy.ArUtil_addDirectories(dest, destLength, baseDir, insideDir)

def ArUtil_strcmp(*args):
    """
    strcmp(std::string str, std::string str2) -> int
    strcmp(std::string str, char const * str2) -> int
    strcmp(char const * str, std::string str2) -> int
    ArUtil_strcmp(char const * str, char const * str2) -> int
    """
    return _AriaPy.ArUtil_strcmp(*args)

def ArUtil_strcasecmp(*args):
    """
    strcasecmp(std::string str, std::string str2) -> int
    strcasecmp(std::string str, char const * str2) -> int
    strcasecmp(char const * str, std::string str2) -> int
    ArUtil_strcasecmp(char const * str, char const * str2) -> int
    """
    return _AriaPy.ArUtil_strcasecmp(*args)

def ArUtil_strSuffixCmp(str, suffix):
    """ArUtil_strSuffixCmp(char const * str, char const * suffix) -> bool"""
    return _AriaPy.ArUtil_strSuffixCmp(str, suffix)

def ArUtil_strSuffixCaseCmp(str, suffix):
    """ArUtil_strSuffixCaseCmp(char const * str, char const * suffix) -> bool"""
    return _AriaPy.ArUtil_strSuffixCaseCmp(str, suffix)

def ArUtil_strcasequotecmp(str1, str2):
    """ArUtil_strcasequotecmp(std::string const & str1, std::string const & str2) -> int"""
    return _AriaPy.ArUtil_strcasequotecmp(str1, str2)

def ArUtil_escapeSpaces(dest, src, maxLen):
    """ArUtil_escapeSpaces(char * dest, char const * src, size_t maxLen)"""
    return _AriaPy.ArUtil_escapeSpaces(dest, src, maxLen)

def ArUtil_stripQuotes(*args):
    """
    stripQuotes(char * dest, char const * src, size_t destLen) -> bool
    ArUtil_stripQuotes(std::string * strToStrip) -> bool
    """
    return _AriaPy.ArUtil_stripQuotes(*args)

def ArUtil_lower(dest, src, maxLen):
    """ArUtil_lower(char * dest, char const * src, size_t maxLen)"""
    return _AriaPy.ArUtil_lower(dest, src, maxLen)

def ArUtil_isOnlyAlphaNumeric(str):
    """ArUtil_isOnlyAlphaNumeric(char const * str) -> bool"""
    return _AriaPy.ArUtil_isOnlyAlphaNumeric(str)

def ArUtil_isOnlyNumeric(str):
    """ArUtil_isOnlyNumeric(char const * str) -> bool"""
    return _AriaPy.ArUtil_isOnlyNumeric(str)

def ArUtil_isStrEmpty(str):
    """ArUtil_isStrEmpty(char const * str) -> bool"""
    return _AriaPy.ArUtil_isStrEmpty(str)

def ArUtil_isStrInList(str, list, isIgnoreCase=False):
    """
    isStrInList(char const * str, std::list< std::string,std::allocator< std::string > > const & list, bool isIgnoreCase=False) -> bool
    ArUtil_isStrInList(char const * str, std::list< std::string,std::allocator< std::string > > const & list) -> bool
    """
    return _AriaPy.ArUtil_isStrInList(str, list, isIgnoreCase)

def ArUtil_atof(nptr):
    """ArUtil_atof(char const * nptr) -> double"""
    return _AriaPy.ArUtil_atof(nptr)

def ArUtil_convertBool(val):
    """ArUtil_convertBool(int val) -> char const *"""
    return _AriaPy.ArUtil_convertBool(val)

def ArUtil_writeToFile(str, file):
    """ArUtil_writeToFile(char const * str, FILE * file)"""
    return _AriaPy.ArUtil_writeToFile(str, file)

def ArUtil_getStringFromFile(fileName, str, strLen):
    """ArUtil_getStringFromFile(char const * fileName, char * str, size_t strLen) -> bool"""
    return _AriaPy.ArUtil_getStringFromFile(fileName, str, strLen)

def ArUtil_getStringFromRegistry(root, key, value, str, len):
    """ArUtil_getStringFromRegistry(ArUtil::REGKEY root, char const * key, char const * value, char * str, int len) -> bool"""
    return _AriaPy.ArUtil_getStringFromRegistry(root, key, value, str, len)

def ArUtil_findFirstStringInRegistry(key, value, str, len):
    """ArUtil_findFirstStringInRegistry(char const * key, char const * value, char * str, int len) -> bool"""
    return _AriaPy.ArUtil_findFirstStringInRegistry(key, value, str, len)
cvar = _AriaPy.cvar

def ArUtil_putCurrentYearInString(s, len):
    """ArUtil_putCurrentYearInString(char * s, size_t len)"""
    return _AriaPy.ArUtil_putCurrentYearInString(s, len)

def ArUtil_putCurrentMonthInString(s, len):
    """ArUtil_putCurrentMonthInString(char * s, size_t len)"""
    return _AriaPy.ArUtil_putCurrentMonthInString(s, len)

def ArUtil_putCurrentDayInString(s, len):
    """ArUtil_putCurrentDayInString(char * s, size_t len)"""
    return _AriaPy.ArUtil_putCurrentDayInString(s, len)

def ArUtil_putCurrentHourInString(s, len):
    """ArUtil_putCurrentHourInString(char * s, size_t len)"""
    return _AriaPy.ArUtil_putCurrentHourInString(s, len)

def ArUtil_putCurrentMinuteInString(s, len):
    """ArUtil_putCurrentMinuteInString(char * s, size_t len)"""
    return _AriaPy.ArUtil_putCurrentMinuteInString(s, len)

def ArUtil_putCurrentSecondInString(s, len):
    """ArUtil_putCurrentSecondInString(char * s, size_t len)"""
    return _AriaPy.ArUtil_putCurrentSecondInString(s, len)

def ArUtil_parseTime(str, ok=None, toToday=True):
    """
    parseTime(char const * str, bool * ok=None, bool toToday=True) -> time_t
    parseTime(char const * str, bool * ok=None) -> time_t
    ArUtil_parseTime(char const * str) -> time_t
    """
    return _AriaPy.ArUtil_parseTime(str, ok, toToday)

def ArUtil_localtime(*args):
    """
    localtime(time_t const * timep, tm * result) -> bool
    ArUtil_localtime(tm * result) -> bool
    """
    return _AriaPy.ArUtil_localtime(*args)

def ArUtil_matchCase(baseDir, fileName, result, resultLen):
    """ArUtil_matchCase(char const * baseDir, char const * fileName, char * result, size_t resultLen) -> bool"""
    return _AriaPy.ArUtil_matchCase(baseDir, fileName, result, resultLen)

def ArUtil_getDirectory(fileName, result, resultLen):
    """ArUtil_getDirectory(char const * fileName, char * result, size_t resultLen) -> bool"""
    return _AriaPy.ArUtil_getDirectory(fileName, result, resultLen)

def ArUtil_getFileName(fileName, result, resultLen):
    """ArUtil_getFileName(char const * fileName, char * result, size_t resultLen) -> bool"""
    return _AriaPy.ArUtil_getFileName(fileName, result, resultLen)

def ArUtil_changeFileTimestamp(fileName, timestamp):
    """ArUtil_changeFileTimestamp(char const * fileName, time_t timestamp) -> bool"""
    return _AriaPy.ArUtil_changeFileTimestamp(fileName, timestamp)

def ArUtil_fopen(path, mode, closeOnExec=True):
    """
    fopen(char const * path, char const * mode, bool closeOnExec=True) -> FILE
    ArUtil_fopen(char const * path, char const * mode) -> FILE *
    """
    return _AriaPy.ArUtil_fopen(path, mode, closeOnExec)

def ArUtil_open(*args):
    """
    open(char const * pathname, int flags, bool closeOnExec=True) -> int
    open(char const * pathname, int flags) -> int
    open(char const * pathname, int flags, mode_t mode, bool closeOnExec=True) -> int
    ArUtil_open(char const * pathname, int flags, mode_t mode) -> int
    """
    return _AriaPy.ArUtil_open(*args)

def ArUtil_creat(pathname, mode, closeOnExec=True):
    """
    creat(char const * pathname, mode_t mode, bool closeOnExec=True) -> int
    ArUtil_creat(char const * pathname, mode_t mode) -> int
    """
    return _AriaPy.ArUtil_creat(pathname, mode, closeOnExec)

def ArUtil_popen(command, type, closeOnExec=True):
    """
    popen(char const * command, char const * type, bool closeOnExec=True) -> FILE
    ArUtil_popen(char const * command, char const * type) -> FILE *
    """
    return _AriaPy.ArUtil_popen(command, type, closeOnExec)

def ArUtil_setFileCloseOnExec(*args):
    """
    setFileCloseOnExec(int fd, bool closeOnExec=True)
    setFileCloseOnExec(int fd)
    setFileCloseOnExec(FILE * file, bool closeOnExec=True)
    ArUtil_setFileCloseOnExec(FILE * file)
    """
    return _AriaPy.ArUtil_setFileCloseOnExec(*args)

def ArUtil_floatIsNormal(f):
    """ArUtil_floatIsNormal(double f) -> bool"""
    return _AriaPy.ArUtil_floatIsNormal(f)

def ArUtil_secToMSec(sec):
    """ArUtil_secToMSec(double const sec) -> double"""
    return _AriaPy.ArUtil_secToMSec(sec)

def ArUtil_mSecToSec(msec):
    """ArUtil_mSecToSec(double const msec) -> double"""
    return _AriaPy.ArUtil_mSecToSec(msec)

def ArUtil_metersToFeet(m):
    """ArUtil_metersToFeet(double const m) -> double"""
    return _AriaPy.ArUtil_metersToFeet(m)

def ArUtil_feetToMeters(f):
    """ArUtil_feetToMeters(double const f) -> double"""
    return _AriaPy.ArUtil_feetToMeters(f)

class ArMath(object):
    """Proxy of C++ ArMath class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def epsilon():
        """epsilon() -> double"""
        return _AriaPy.ArMath_epsilon()

    epsilon = staticmethod(epsilon)

    def addAngle(ang1, ang2):
        """addAngle(double ang1, double ang2) -> double"""
        return _AriaPy.ArMath_addAngle(ang1, ang2)

    addAngle = staticmethod(addAngle)

    def subAngle(ang1, ang2):
        """subAngle(double ang1, double ang2) -> double"""
        return _AriaPy.ArMath_subAngle(ang1, ang2)

    subAngle = staticmethod(subAngle)

    def fixAngle(angle):
        """fixAngle(double angle) -> double"""
        return _AriaPy.ArMath_fixAngle(angle)

    fixAngle = staticmethod(fixAngle)

    def degToRad(deg):
        """degToRad(double deg) -> double"""
        return _AriaPy.ArMath_degToRad(deg)

    degToRad = staticmethod(degToRad)

    def radToDeg(rad):
        """radToDeg(double rad) -> double"""
        return _AriaPy.ArMath_radToDeg(rad)

    radToDeg = staticmethod(radToDeg)

    def cos(angle):
        """cos(double angle) -> double"""
        return _AriaPy.ArMath_cos(angle)

    cos = staticmethod(cos)

    def sin(angle):
        """sin(double angle) -> double"""
        return _AriaPy.ArMath_sin(angle)

    sin = staticmethod(sin)

    def tan(angle):
        """tan(double angle) -> double"""
        return _AriaPy.ArMath_tan(angle)

    tan = staticmethod(tan)

    def atan2(y, x):
        """atan2(double y, double x) -> double"""
        return _AriaPy.ArMath_atan2(y, x)

    atan2 = staticmethod(atan2)

    def angleBetween(angle, startAngle, endAngle):
        """angleBetween(double angle, double startAngle, double endAngle) -> bool"""
        return _AriaPy.ArMath_angleBetween(angle, startAngle, endAngle)

    angleBetween = staticmethod(angleBetween)

    def fabs(val):
        """fabs(double val) -> double"""
        return _AriaPy.ArMath_fabs(val)

    fabs = staticmethod(fabs)

    def roundInt(val):
        """roundInt(double val) -> int"""
        return _AriaPy.ArMath_roundInt(val)

    roundInt = staticmethod(roundInt)

    def roundShort(val):
        """roundShort(double val) -> short"""
        return _AriaPy.ArMath_roundShort(val)

    roundShort = staticmethod(roundShort)

    def pointRotate(th):
        """pointRotate(double th)"""
        return _AriaPy.ArMath_pointRotate(th)

    pointRotate = staticmethod(pointRotate)

    def random():
        """random() -> long"""
        return _AriaPy.ArMath_random()

    random = staticmethod(random)

    def getRandMax():
        """getRandMax() -> long"""
        return _AriaPy.ArMath_getRandMax()

    getRandMax = staticmethod(getRandMax)

    def randomInRange(m, n):
        """randomInRange(long m, long n) -> long"""
        return _AriaPy.ArMath_randomInRange(m, n)

    randomInRange = staticmethod(randomInRange)

    def distanceBetween(x1, y1, x2, y2):
        """distanceBetween(double x1, double y1, double x2, double y2) -> double"""
        return _AriaPy.ArMath_distanceBetween(x1, y1, x2, y2)

    distanceBetween = staticmethod(distanceBetween)

    def squaredDistanceBetween(x1, y1, x2, y2):
        """squaredDistanceBetween(double x1, double y1, double x2, double y2) -> double"""
        return _AriaPy.ArMath_squaredDistanceBetween(x1, y1, x2, y2)

    squaredDistanceBetween = staticmethod(squaredDistanceBetween)

    def log2(x):
        """log2(double x) -> double"""
        return _AriaPy.ArMath_log2(x)

    log2 = staticmethod(log2)

    def isNan(*args):
        """
        isNan(double d) -> bool
        isNan(float f) -> bool
        """
        return _AriaPy.ArMath_isNan(*args)

    isNan = staticmethod(isNan)

    def isFinite(*args):
        """
        isFinite(float f) -> bool
        isFinite(double d) -> bool
        """
        return _AriaPy.ArMath_isFinite(*args)

    isFinite = staticmethod(isFinite)

    def compareFloats(*args):
        """
        compareFloats(double f1, double f2, double epsilon) -> bool
        compareFloats(double f1, double f2) -> bool
        """
        return _AriaPy.ArMath_compareFloats(*args)

    compareFloats = staticmethod(compareFloats)

    def __init__(self):
        """__init__(ArMath self) -> ArMath"""
        this = _AriaPy.new_ArMath()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMath
    __del__ = lambda self: None
ArMath_swigregister = _AriaPy.ArMath_swigregister
ArMath_swigregister(ArMath)

def ArMath_epsilon():
    """ArMath_epsilon() -> double"""
    return _AriaPy.ArMath_epsilon()

def ArMath_addAngle(ang1, ang2):
    """ArMath_addAngle(double ang1, double ang2) -> double"""
    return _AriaPy.ArMath_addAngle(ang1, ang2)

def ArMath_subAngle(ang1, ang2):
    """ArMath_subAngle(double ang1, double ang2) -> double"""
    return _AriaPy.ArMath_subAngle(ang1, ang2)

def ArMath_fixAngle(angle):
    """ArMath_fixAngle(double angle) -> double"""
    return _AriaPy.ArMath_fixAngle(angle)

def ArMath_degToRad(deg):
    """ArMath_degToRad(double deg) -> double"""
    return _AriaPy.ArMath_degToRad(deg)

def ArMath_radToDeg(rad):
    """ArMath_radToDeg(double rad) -> double"""
    return _AriaPy.ArMath_radToDeg(rad)

def ArMath_cos(angle):
    """ArMath_cos(double angle) -> double"""
    return _AriaPy.ArMath_cos(angle)

def ArMath_sin(angle):
    """ArMath_sin(double angle) -> double"""
    return _AriaPy.ArMath_sin(angle)

def ArMath_tan(angle):
    """ArMath_tan(double angle) -> double"""
    return _AriaPy.ArMath_tan(angle)

def ArMath_atan2(y, x):
    """ArMath_atan2(double y, double x) -> double"""
    return _AriaPy.ArMath_atan2(y, x)

def ArMath_angleBetween(angle, startAngle, endAngle):
    """ArMath_angleBetween(double angle, double startAngle, double endAngle) -> bool"""
    return _AriaPy.ArMath_angleBetween(angle, startAngle, endAngle)

def ArMath_fabs(val):
    """ArMath_fabs(double val) -> double"""
    return _AriaPy.ArMath_fabs(val)

def ArMath_roundInt(val):
    """ArMath_roundInt(double val) -> int"""
    return _AriaPy.ArMath_roundInt(val)

def ArMath_roundShort(val):
    """ArMath_roundShort(double val) -> short"""
    return _AriaPy.ArMath_roundShort(val)

def ArMath_pointRotate(th):
    """ArMath_pointRotate(double th)"""
    return _AriaPy.ArMath_pointRotate(th)

def ArMath_random():
    """ArMath_random() -> long"""
    return _AriaPy.ArMath_random()

def ArMath_getRandMax():
    """ArMath_getRandMax() -> long"""
    return _AriaPy.ArMath_getRandMax()

def ArMath_randomInRange(m, n):
    """ArMath_randomInRange(long m, long n) -> long"""
    return _AriaPy.ArMath_randomInRange(m, n)

def ArMath_distanceBetween(x1, y1, x2, y2):
    """ArMath_distanceBetween(double x1, double y1, double x2, double y2) -> double"""
    return _AriaPy.ArMath_distanceBetween(x1, y1, x2, y2)

def ArMath_squaredDistanceBetween(x1, y1, x2, y2):
    """ArMath_squaredDistanceBetween(double x1, double y1, double x2, double y2) -> double"""
    return _AriaPy.ArMath_squaredDistanceBetween(x1, y1, x2, y2)

def ArMath_log2(x):
    """ArMath_log2(double x) -> double"""
    return _AriaPy.ArMath_log2(x)

def ArMath_isNan(*args):
    """
    isNan(double d) -> bool
    ArMath_isNan(float f) -> bool
    """
    return _AriaPy.ArMath_isNan(*args)

def ArMath_isFinite(*args):
    """
    isFinite(float f) -> bool
    ArMath_isFinite(double d) -> bool
    """
    return _AriaPy.ArMath_isFinite(*args)

def ArMath_compareFloats(*args):
    """
    compareFloats(double f1, double f2, double epsilon) -> bool
    ArMath_compareFloats(double f1, double f2) -> bool
    """
    return _AriaPy.ArMath_compareFloats(*args)

class ArPose(object):
    """Proxy of C++ ArPose 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__(ArPose self, double x=0, double y=0, double th=0) -> ArPose
        __init__(ArPose self, double x=0, double y=0) -> ArPose
        __init__(ArPose self, double x=0) -> ArPose
        __init__(ArPose self) -> ArPose
        __init__(ArPose self, ArPose pose) -> ArPose
        """
        this = _AriaPy.new_ArPose(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArPose
    __del__ = lambda self: None

    def setPose(self, *args):
        """
        setPose(ArPose self, double x, double y, double th=0)
        setPose(ArPose self, double x, double y)
        setPose(ArPose self, ArPose position)
        """
        return _AriaPy.ArPose_setPose(self, *args)


    def setX(self, x):
        """setX(ArPose self, double x)"""
        return _AriaPy.ArPose_setX(self, x)


    def setY(self, y):
        """setY(ArPose self, double y)"""
        return _AriaPy.ArPose_setY(self, y)


    def setTh(self, th):
        """setTh(ArPose self, double th)"""
        return _AriaPy.ArPose_setTh(self, th)


    def setThRad(self, th):
        """setThRad(ArPose self, double th)"""
        return _AriaPy.ArPose_setThRad(self, th)


    def getX(self):
        """getX(ArPose self) -> double"""
        return _AriaPy.ArPose_getX(self)


    def getY(self):
        """getY(ArPose self) -> double"""
        return _AriaPy.ArPose_getY(self)


    def getTh(self):
        """getTh(ArPose self) -> double"""
        return _AriaPy.ArPose_getTh(self)


    def getThRad(self):
        """getThRad(ArPose self) -> double"""
        return _AriaPy.ArPose_getThRad(self)


    def getPose(self):
        """
        getPose(ArPose self)
        getPose(ArPose self)
        """
        return _AriaPy.ArPose_getPose(self)


    def findDistanceTo(self, position):
        """findDistanceTo(ArPose self, ArPose position) -> double"""
        return _AriaPy.ArPose_findDistanceTo(self, position)


    def squaredFindDistanceTo(self, position):
        """squaredFindDistanceTo(ArPose self, ArPose position) -> double"""
        return _AriaPy.ArPose_squaredFindDistanceTo(self, position)


    def findAngleTo(self, position):
        """findAngleTo(ArPose self, ArPose position) -> double"""
        return _AriaPy.ArPose_findAngleTo(self, position)


    def log(self):
        """log(ArPose self)"""
        return _AriaPy.ArPose_log(self)


    def __add__(self, other):
        """__add__(ArPose self, ArPose other) -> ArPose"""
        return _AriaPy.ArPose___add__(self, other)


    def __sub__(self, other):
        """__sub__(ArPose self, ArPose other) -> ArPose"""
        return _AriaPy.ArPose___sub__(self, other)


    def __iadd__(self, other):
        """__iadd__(ArPose self, ArPose other) -> ArPose"""
        return _AriaPy.ArPose___iadd__(self, other)


    def __isub__(self, other):
        """__isub__(ArPose self, ArPose other) -> ArPose"""
        return _AriaPy.ArPose___isub__(self, other)


    def __eq__(self, other):
        """__eq__(ArPose self, ArPose other) -> bool"""
        return _AriaPy.ArPose___eq__(self, other)


    def __ne__(self, other):
        """__ne__(ArPose self, ArPose other) -> bool"""
        return _AriaPy.ArPose___ne__(self, other)


    def __lt__(self, other):
        """__lt__(ArPose self, ArPose other) -> bool"""
        return _AriaPy.ArPose___lt__(self, other)


    def distanceBetween(pose1, pose2):
        """distanceBetween(ArPose pose1, ArPose pose2) -> double"""
        return _AriaPy.ArPose_distanceBetween(pose1, pose2)

    distanceBetween = staticmethod(distanceBetween)

    def __str__(self):
        """__str__(ArPose self) -> char *"""
        return _AriaPy.ArPose___str__(self)

    x = _swig_property(_AriaPy.ArPose_x_get, _AriaPy.ArPose_x_set)
    y = _swig_property(_AriaPy.ArPose_y_get, _AriaPy.ArPose_y_set)
    th = _swig_property(_AriaPy.ArPose_th_get, _AriaPy.ArPose_th_set)
ArPose_swigregister = _AriaPy.ArPose_swigregister
ArPose_swigregister(ArPose)

def ArPose_distanceBetween(pose1, pose2):
    """ArPose_distanceBetween(ArPose pose1, ArPose pose2) -> double"""
    return _AriaPy.ArPose_distanceBetween(pose1, pose2)

class ArTime(object):
    """Proxy of C++ ArTime 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__(ArTime self) -> ArTime
        __init__(ArTime self, ArTime other) -> ArTime
        """
        this = _AriaPy.new_ArTime(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArTime
    __del__ = lambda self: None

    def mSecTo(self):
        """mSecTo(ArTime self) -> long"""
        return _AriaPy.ArTime_mSecTo(self)


    def mSecToLL(self):
        """mSecToLL(ArTime self) -> long long"""
        return _AriaPy.ArTime_mSecToLL(self)


    def secTo(self):
        """secTo(ArTime self) -> long"""
        return _AriaPy.ArTime_secTo(self)


    def secToLL(self):
        """secToLL(ArTime self) -> long long"""
        return _AriaPy.ArTime_secToLL(self)


    def mSecSince(self, *args):
        """
        mSecSince(ArTime self, ArTime since) -> long
        mSecSince(ArTime self) -> long
        """
        return _AriaPy.ArTime_mSecSince(self, *args)


    def mSecSinceLL(self, *args):
        """
        mSecSinceLL(ArTime self, ArTime since) -> long long
        mSecSinceLL(ArTime self) -> long long
        """
        return _AriaPy.ArTime_mSecSinceLL(self, *args)


    def secSince(self, *args):
        """
        secSince(ArTime self, ArTime since) -> long
        secSince(ArTime self) -> long
        """
        return _AriaPy.ArTime_secSince(self, *args)


    def secSinceLL(self, *args):
        """
        secSinceLL(ArTime self, ArTime since) -> long long
        secSinceLL(ArTime self) -> long long
        """
        return _AriaPy.ArTime_secSinceLL(self, *args)


    def isBefore(self, testTime):
        """isBefore(ArTime self, ArTime testTime) -> bool"""
        return _AriaPy.ArTime_isBefore(self, testTime)


    def isAt(self, testTime):
        """isAt(ArTime self, ArTime testTime) -> bool"""
        return _AriaPy.ArTime_isAt(self, testTime)


    def isAfter(self, testTime):
        """isAfter(ArTime self, ArTime testTime) -> bool"""
        return _AriaPy.ArTime_isAfter(self, testTime)


    def setToNow(self):
        """setToNow(ArTime self)"""
        return _AriaPy.ArTime_setToNow(self)


    def addMSec(self, ms):
        """addMSec(ArTime self, long ms) -> bool"""
        return _AriaPy.ArTime_addMSec(self, ms)


    def addMSecLL(self, ms):
        """addMSecLL(ArTime self, long long ms) -> bool"""
        return _AriaPy.ArTime_addMSecLL(self, ms)


    def setSec(self, sec):
        """setSec(ArTime self, unsigned long sec)"""
        return _AriaPy.ArTime_setSec(self, sec)


    def setMSec(self, msec):
        """setMSec(ArTime self, unsigned long msec)"""
        return _AriaPy.ArTime_setMSec(self, msec)


    def getSec(self):
        """getSec(ArTime self) -> unsigned long"""
        return _AriaPy.ArTime_getSec(self)


    def getMSec(self):
        """getMSec(ArTime self) -> unsigned long"""
        return _AriaPy.ArTime_getMSec(self)


    def setSecLL(self, sec):
        """setSecLL(ArTime self, unsigned long long sec)"""
        return _AriaPy.ArTime_setSecLL(self, sec)


    def setMSecLL(self, msec):
        """setMSecLL(ArTime self, unsigned long long msec)"""
        return _AriaPy.ArTime_setMSecLL(self, msec)


    def getSecLL(self):
        """getSecLL(ArTime self) -> unsigned long long"""
        return _AriaPy.ArTime_getSecLL(self)


    def getMSecLL(self):
        """getMSecLL(ArTime self) -> unsigned long long"""
        return _AriaPy.ArTime_getMSecLL(self)


    def log(self, prefix=None):
        """
        log(ArTime self, char const * prefix=None)
        log(ArTime self)
        """
        return _AriaPy.ArTime_log(self, prefix)


    def usingMonotonicClock():
        """usingMonotonicClock() -> bool"""
        return _AriaPy.ArTime_usingMonotonicClock()

    usingMonotonicClock = staticmethod(usingMonotonicClock)

    def __eq__(self, other):
        """__eq__(ArTime self, ArTime other) -> bool"""
        return _AriaPy.ArTime___eq__(self, other)


    def __ne__(self, other):
        """__ne__(ArTime self, ArTime other) -> bool"""
        return _AriaPy.ArTime___ne__(self, other)


    def __lt__(self, other):
        """__lt__(ArTime self, ArTime other) -> bool"""
        return _AriaPy.ArTime___lt__(self, other)

ArTime_swigregister = _AriaPy.ArTime_swigregister
ArTime_swigregister(ArTime)

def ArTime_usingMonotonicClock():
    """ArTime_usingMonotonicClock() -> bool"""
    return _AriaPy.ArTime_usingMonotonicClock()

class ArPoseWithTime(ArPose):
    """Proxy of C++ ArPoseWithTime 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__(ArPoseWithTime self, double x=0, double y=0, double th=0, ArTime thisTime) -> ArPoseWithTime
        __init__(ArPoseWithTime self, double x=0, double y=0, double th=0) -> ArPoseWithTime
        __init__(ArPoseWithTime self, double x=0, double y=0) -> ArPoseWithTime
        __init__(ArPoseWithTime self, double x=0) -> ArPoseWithTime
        __init__(ArPoseWithTime self) -> ArPoseWithTime
        __init__(ArPoseWithTime self, ArPose pose) -> ArPoseWithTime
        """
        this = _AriaPy.new_ArPoseWithTime(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArPoseWithTime
    __del__ = lambda self: None

    def setTime(self, newTime):
        """setTime(ArPoseWithTime self, ArTime newTime)"""
        return _AriaPy.ArPoseWithTime_setTime(self, newTime)


    def setTimeToNow(self):
        """setTimeToNow(ArPoseWithTime self)"""
        return _AriaPy.ArPoseWithTime_setTimeToNow(self)


    def getTime(self):
        """getTime(ArPoseWithTime self) -> ArTime"""
        return _AriaPy.ArPoseWithTime_getTime(self)

ArPoseWithTime_swigregister = _AriaPy.ArPoseWithTime_swigregister
ArPoseWithTime_swigregister(ArPoseWithTime)

class ArSectors(object):
    """Proxy of C++ ArSectors 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, numSectors=8):
        """
        __init__(ArSectors self, int numSectors=8) -> ArSectors
        __init__(ArSectors self) -> ArSectors
        """
        this = _AriaPy.new_ArSectors(numSectors)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSectors
    __del__ = lambda self: None

    def clear(self):
        """clear(ArSectors self)"""
        return _AriaPy.ArSectors_clear(self)


    def update(self, angle):
        """update(ArSectors self, double angle)"""
        return _AriaPy.ArSectors_update(self, angle)


    def didAll(self):
        """didAll(ArSectors self) -> bool"""
        return _AriaPy.ArSectors_didAll(self)

ArSectors_swigregister = _AriaPy.ArSectors_swigregister
ArSectors_swigregister(ArSectors)

class ArLine(object):
    """Proxy of C++ ArLine 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__(ArLine self) -> ArLine
        __init__(ArLine self, double a, double b, double c) -> ArLine
        __init__(ArLine self, double x1, double y1, double x2, double y2) -> ArLine
        """
        this = _AriaPy.new_ArLine(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLine
    __del__ = lambda self: None

    def newParameters(self, a, b, c):
        """newParameters(ArLine self, double a, double b, double c)"""
        return _AriaPy.ArLine_newParameters(self, a, b, c)


    def newParametersFromEndpoints(self, x1, y1, x2, y2):
        """newParametersFromEndpoints(ArLine self, double x1, double y1, double x2, double y2)"""
        return _AriaPy.ArLine_newParametersFromEndpoints(self, x1, y1, x2, y2)


    def getA(self):
        """getA(ArLine self) -> double"""
        return _AriaPy.ArLine_getA(self)


    def getB(self):
        """getB(ArLine self) -> double"""
        return _AriaPy.ArLine_getB(self)


    def getC(self):
        """getC(ArLine self) -> double"""
        return _AriaPy.ArLine_getC(self)


    def intersects(self, line, pose):
        """intersects(ArLine self, ArLine line, ArPose pose) -> bool"""
        return _AriaPy.ArLine_intersects(self, line, pose)


    def makeLinePerp(self, pose, line):
        """makeLinePerp(ArLine self, ArPose pose, ArLine line)"""
        return _AriaPy.ArLine_makeLinePerp(self, pose, line)


    def getPerpDist(self, pose):
        """getPerpDist(ArLine self, ArPose pose) -> double"""
        return _AriaPy.ArLine_getPerpDist(self, pose)


    def getPerpSquaredDist(self, pose):
        """getPerpSquaredDist(ArLine self, ArPose pose) -> double"""
        return _AriaPy.ArLine_getPerpSquaredDist(self, pose)


    def getPerpPoint(self, pose, perpPoint):
        """getPerpPoint(ArLine self, ArPose pose, ArPose perpPoint) -> bool"""
        return _AriaPy.ArLine_getPerpPoint(self, pose, perpPoint)


    def __eq__(self, other):
        """__eq__(ArLine self, ArLine other) -> bool"""
        return _AriaPy.ArLine___eq__(self, other)


    def __ne__(self, other):
        """__ne__(ArLine self, ArLine other) -> bool"""
        return _AriaPy.ArLine___ne__(self, other)

ArLine_swigregister = _AriaPy.ArLine_swigregister
ArLine_swigregister(ArLine)

class ArLineSegment(object):
    """Proxy of C++ ArLineSegment 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, pose1, pose2):
        """__init__(ArLineSegment self, ArPose pose1, ArPose pose2) -> ArLineSegment"""
        this = _AriaPy.new_ArLineSegment(pose1, pose2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLineSegment
    __del__ = lambda self: None

    def newEndPoints(self, *args):
        """
        newEndPoints(ArLineSegment self, double x1, double y1, double x2, double y2)
        newEndPoints(ArLineSegment self, ArPose pt1, ArPose pt2)
        """
        return _AriaPy.ArLineSegment_newEndPoints(self, *args)


    def getEndPoint1(self):
        """getEndPoint1(ArLineSegment self) -> ArPose"""
        return _AriaPy.ArLineSegment_getEndPoint1(self)


    def getEndPoint2(self):
        """getEndPoint2(ArLineSegment self) -> ArPose"""
        return _AriaPy.ArLineSegment_getEndPoint2(self)


    def intersects(self, *args):
        """
        intersects(ArLineSegment self, ArLine line, ArPose pose) -> bool
        intersects(ArLineSegment self, ArLineSegment line, ArPose pose) -> bool
        """
        return _AriaPy.ArLineSegment_intersects(self, *args)


    def getPerpPoint(self, pose, perpPoint):
        """getPerpPoint(ArLineSegment self, ArPose pose, ArPose perpPoint) -> bool"""
        return _AriaPy.ArLineSegment_getPerpPoint(self, pose, perpPoint)


    def getPerpDist(self, pose):
        """getPerpDist(ArLineSegment self, ArPose pose) -> double"""
        return _AriaPy.ArLineSegment_getPerpDist(self, pose)


    def getPerpSquaredDist(self, pose):
        """getPerpSquaredDist(ArLineSegment self, ArPose pose) -> double"""
        return _AriaPy.ArLineSegment_getPerpSquaredDist(self, pose)


    def getDistToLine(self, pose):
        """getDistToLine(ArLineSegment self, ArPose pose) -> double"""
        return _AriaPy.ArLineSegment_getDistToLine(self, pose)


    def getLengthOf(self):
        """getLengthOf(ArLineSegment self) -> double"""
        return _AriaPy.ArLineSegment_getLengthOf(self)


    def getMidPoint(self):
        """getMidPoint(ArLineSegment self) -> ArPose"""
        return _AriaPy.ArLineSegment_getMidPoint(self)


    def getX1(self):
        """getX1(ArLineSegment self) -> double"""
        return _AriaPy.ArLineSegment_getX1(self)


    def getY1(self):
        """getY1(ArLineSegment self) -> double"""
        return _AriaPy.ArLineSegment_getY1(self)


    def getX2(self):
        """getX2(ArLineSegment self) -> double"""
        return _AriaPy.ArLineSegment_getX2(self)


    def getY2(self):
        """getY2(ArLineSegment self) -> double"""
        return _AriaPy.ArLineSegment_getY2(self)


    def getA(self):
        """getA(ArLineSegment self) -> double"""
        return _AriaPy.ArLineSegment_getA(self)


    def getB(self):
        """getB(ArLineSegment self) -> double"""
        return _AriaPy.ArLineSegment_getB(self)


    def getC(self):
        """getC(ArLineSegment self) -> double"""
        return _AriaPy.ArLineSegment_getC(self)


    def linePointIsInSegment(self, pose):
        """linePointIsInSegment(ArLineSegment self, ArPose pose) -> bool"""
        return _AriaPy.ArLineSegment_linePointIsInSegment(self, pose)


    def getLine(self):
        """getLine(ArLineSegment self) -> ArLine"""
        return _AriaPy.ArLineSegment_getLine(self)


    def __eq__(self, other):
        """__eq__(ArLineSegment self, ArLineSegment other) -> bool"""
        return _AriaPy.ArLineSegment___eq__(self, other)


    def __ne__(self, other):
        """__ne__(ArLineSegment self, ArLineSegment other) -> bool"""
        return _AriaPy.ArLineSegment___ne__(self, other)


    def __lt__(self, other):
        """__lt__(ArLineSegment self, ArLineSegment other) -> bool"""
        return _AriaPy.ArLineSegment___lt__(self, other)

ArLineSegment_swigregister = _AriaPy.ArLineSegment_swigregister
ArLineSegment_swigregister(ArLineSegment)

class ArRunningAverage(object):
    """Proxy of C++ ArRunningAverage 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, numToAverage):
        """__init__(ArRunningAverage self, size_t numToAverage) -> ArRunningAverage"""
        this = _AriaPy.new_ArRunningAverage(numToAverage)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRunningAverage
    __del__ = lambda self: None

    def getAverage(self):
        """getAverage(ArRunningAverage self) -> double"""
        return _AriaPy.ArRunningAverage_getAverage(self)


    def add(self, val):
        """add(ArRunningAverage self, double val)"""
        return _AriaPy.ArRunningAverage_add(self, val)


    def clear(self):
        """clear(ArRunningAverage self)"""
        return _AriaPy.ArRunningAverage_clear(self)


    def getNumToAverage(self):
        """getNumToAverage(ArRunningAverage self) -> size_t"""
        return _AriaPy.ArRunningAverage_getNumToAverage(self)


    def setNumToAverage(self, numToAverage):
        """setNumToAverage(ArRunningAverage self, size_t numToAverage)"""
        return _AriaPy.ArRunningAverage_setNumToAverage(self, numToAverage)


    def setUseRootMeanSquare(self, useRootMeanSquare):
        """setUseRootMeanSquare(ArRunningAverage self, bool useRootMeanSquare)"""
        return _AriaPy.ArRunningAverage_setUseRootMeanSquare(self, useRootMeanSquare)


    def getUseRootMeanSquare(self):
        """getUseRootMeanSquare(ArRunningAverage self) -> bool"""
        return _AriaPy.ArRunningAverage_getUseRootMeanSquare(self)


    def getCurrentNumAveraged(self):
        """getCurrentNumAveraged(ArRunningAverage self) -> size_t"""
        return _AriaPy.ArRunningAverage_getCurrentNumAveraged(self)

ArRunningAverage_swigregister = _AriaPy.ArRunningAverage_swigregister
ArRunningAverage_swigregister(ArRunningAverage)

class ArRootMeanSquareCalculator(object):
    """Proxy of C++ ArRootMeanSquareCalculator 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):
        """__init__(ArRootMeanSquareCalculator self) -> ArRootMeanSquareCalculator"""
        this = _AriaPy.new_ArRootMeanSquareCalculator()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRootMeanSquareCalculator
    __del__ = lambda self: None

    def getRootMeanSquare(self):
        """getRootMeanSquare(ArRootMeanSquareCalculator self) -> double"""
        return _AriaPy.ArRootMeanSquareCalculator_getRootMeanSquare(self)


    def add(self, val):
        """add(ArRootMeanSquareCalculator self, int val)"""
        return _AriaPy.ArRootMeanSquareCalculator_add(self, val)


    def clear(self):
        """clear(ArRootMeanSquareCalculator self)"""
        return _AriaPy.ArRootMeanSquareCalculator_clear(self)


    def setName(self, name):
        """setName(ArRootMeanSquareCalculator self, char const * name)"""
        return _AriaPy.ArRootMeanSquareCalculator_setName(self, name)


    def getName(self):
        """getName(ArRootMeanSquareCalculator self) -> char const *"""
        return _AriaPy.ArRootMeanSquareCalculator_getName(self)


    def getCurrentNumAveraged(self):
        """getCurrentNumAveraged(ArRootMeanSquareCalculator self) -> size_t"""
        return _AriaPy.ArRootMeanSquareCalculator_getCurrentNumAveraged(self)

ArRootMeanSquareCalculator_swigregister = _AriaPy.ArRootMeanSquareCalculator_swigregister
ArRootMeanSquareCalculator_swigregister(ArRootMeanSquareCalculator)

class ArStrCaseCmpOp(object):
    """Proxy of C++ ArStrCaseCmpOp class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __call__(self, s1, s2):
        """__call__(ArStrCaseCmpOp self, std::string const & s1, std::string const & s2) -> bool"""
        return _AriaPy.ArStrCaseCmpOp___call__(self, s1, s2)


    def __init__(self):
        """__init__(ArStrCaseCmpOp self) -> ArStrCaseCmpOp"""
        this = _AriaPy.new_ArStrCaseCmpOp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArStrCaseCmpOp
    __del__ = lambda self: None
ArStrCaseCmpOp_swigregister = _AriaPy.ArStrCaseCmpOp_swigregister
ArStrCaseCmpOp_swigregister(ArStrCaseCmpOp)

class ArPoseCmpOp(object):
    """Proxy of C++ ArPoseCmpOp class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __call__(self, pose1, pose2):
        """__call__(ArPoseCmpOp self, ArPose pose1, ArPose pose2) -> bool"""
        return _AriaPy.ArPoseCmpOp___call__(self, pose1, pose2)


    def __init__(self):
        """__init__(ArPoseCmpOp self) -> ArPoseCmpOp"""
        this = _AriaPy.new_ArPoseCmpOp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArPoseCmpOp
    __del__ = lambda self: None
ArPoseCmpOp_swigregister = _AriaPy.ArPoseCmpOp_swigregister
ArPoseCmpOp_swigregister(ArPoseCmpOp)

class ArLineSegmentCmpOp(object):
    """Proxy of C++ ArLineSegmentCmpOp class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __call__(self, line1, line2):
        """__call__(ArLineSegmentCmpOp self, ArLineSegment line1, ArLineSegment line2) -> bool"""
        return _AriaPy.ArLineSegmentCmpOp___call__(self, line1, line2)


    def __init__(self):
        """__init__(ArLineSegmentCmpOp self) -> ArLineSegmentCmpOp"""
        this = _AriaPy.new_ArLineSegmentCmpOp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLineSegmentCmpOp
    __del__ = lambda self: None
ArLineSegmentCmpOp_swigregister = _AriaPy.ArLineSegmentCmpOp_swigregister
ArLineSegmentCmpOp_swigregister(ArLineSegmentCmpOp)

class ArPriority(object):
    """Proxy of C++ ArPriority class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    IMPORTANT = _AriaPy.ArPriority_IMPORTANT
    BASIC = _AriaPy.ArPriority_BASIC
    FIRST_PRIORITY = _AriaPy.ArPriority_FIRST_PRIORITY
    NORMAL = _AriaPy.ArPriority_NORMAL
    INTERMEDIATE = _AriaPy.ArPriority_INTERMEDIATE
    DETAILED = _AriaPy.ArPriority_DETAILED
    TRIVIAL = _AriaPy.ArPriority_TRIVIAL
    ADVANCED = _AriaPy.ArPriority_ADVANCED
    EXPERT = _AriaPy.ArPriority_EXPERT
    FACTORY = _AriaPy.ArPriority_FACTORY
    CALIBRATION = _AriaPy.ArPriority_CALIBRATION
    LAST_PRIORITY = _AriaPy.ArPriority_LAST_PRIORITY
    PRIORITY_COUNT = _AriaPy.ArPriority_PRIORITY_COUNT

    def getPriorityName(priority):
        """getPriorityName(ArPriority::Priority priority) -> char const *"""
        return _AriaPy.ArPriority_getPriorityName(priority)

    getPriorityName = staticmethod(getPriorityName)

    def getPriorityFromName(text):
        """getPriorityFromName(char const * text) -> ArPriority::Priority"""
        return _AriaPy.ArPriority_getPriorityFromName(text)

    getPriorityFromName = staticmethod(getPriorityFromName)

    def __init__(self):
        """__init__(ArPriority self) -> ArPriority"""
        this = _AriaPy.new_ArPriority()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArPriority
    __del__ = lambda self: None
ArPriority_swigregister = _AriaPy.ArPriority_swigregister
ArPriority_swigregister(ArPriority)

def ArPriority_getPriorityName(priority):
    """ArPriority_getPriorityName(ArPriority::Priority priority) -> char const *"""
    return _AriaPy.ArPriority_getPriorityName(priority)

def ArPriority_getPriorityFromName(text):
    """ArPriority_getPriorityFromName(char const * text) -> ArPriority::Priority"""
    return _AriaPy.ArPriority_getPriorityFromName(text)

class ArStringInfoHolder(object):
    """Proxy of C++ ArStringInfoHolder 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, name, maxLength, functor):
        """__init__(ArStringInfoHolder self, char const * name, ArTypes::UByte2 maxLength, ArFunctor2< char *,ArTypes::UByte2 > * functor) -> ArStringInfoHolder"""
        this = _AriaPy.new_ArStringInfoHolder(name, maxLength, functor)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArStringInfoHolder
    __del__ = lambda self: None

    def getName(self):
        """getName(ArStringInfoHolder self) -> char const *"""
        return _AriaPy.ArStringInfoHolder_getName(self)


    def getMaxLength(self):
        """getMaxLength(ArStringInfoHolder self) -> ArTypes::UByte2"""
        return _AriaPy.ArStringInfoHolder_getMaxLength(self)


    def getFunctor(self):
        """getFunctor(ArStringInfoHolder self) -> ArFunctor2< char *,ArTypes::UByte2 > *"""
        return _AriaPy.ArStringInfoHolder_getFunctor(self)

ArStringInfoHolder_swigregister = _AriaPy.ArStringInfoHolder_swigregister
ArStringInfoHolder_swigregister(ArStringInfoHolder)

class ArStringInfoHolderFunctions(object):
    """Proxy of C++ ArStringInfoHolderFunctions class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def intWrapper(buffer, bufferLen, functor, format):
        """intWrapper(char * buffer, ArTypes::UByte2 bufferLen, ArRetFunctor_Int functor, char const * format)"""
        return _AriaPy.ArStringInfoHolderFunctions_intWrapper(buffer, bufferLen, functor, format)

    intWrapper = staticmethod(intWrapper)

    def doubleWrapper(buffer, bufferLen, functor, format):
        """doubleWrapper(char * buffer, ArTypes::UByte2 bufferLen, ArRetFunctor_Double functor, char const * format)"""
        return _AriaPy.ArStringInfoHolderFunctions_doubleWrapper(buffer, bufferLen, functor, format)

    doubleWrapper = staticmethod(doubleWrapper)

    def boolWrapper(buffer, bufferLen, functor, format):
        """boolWrapper(char * buffer, ArTypes::UByte2 bufferLen, ArRetFunctor_Bool functor, char const * format)"""
        return _AriaPy.ArStringInfoHolderFunctions_boolWrapper(buffer, bufferLen, functor, format)

    boolWrapper = staticmethod(boolWrapper)

    def stringWrapper(buffer, bufferLen, functor, format):
        """stringWrapper(char * buffer, ArTypes::UByte2 bufferLen, ArRetFunctor< char const * > * functor, char const * format)"""
        return _AriaPy.ArStringInfoHolderFunctions_stringWrapper(buffer, bufferLen, functor, format)

    stringWrapper = staticmethod(stringWrapper)

    def unsignedLongWrapper(buffer, bufferLen, functor, format):
        """unsignedLongWrapper(char * buffer, ArTypes::UByte2 bufferLen, ArRetFunctor< unsigned long > * functor, char const * format)"""
        return _AriaPy.ArStringInfoHolderFunctions_unsignedLongWrapper(buffer, bufferLen, functor, format)

    unsignedLongWrapper = staticmethod(unsignedLongWrapper)

    def longWrapper(buffer, bufferLen, functor, format):
        """longWrapper(char * buffer, ArTypes::UByte2 bufferLen, ArRetFunctor< long > * functor, char const * format)"""
        return _AriaPy.ArStringInfoHolderFunctions_longWrapper(buffer, bufferLen, functor, format)

    longWrapper = staticmethod(longWrapper)

    def __init__(self):
        """__init__(ArStringInfoHolderFunctions self) -> ArStringInfoHolderFunctions"""
        this = _AriaPy.new_ArStringInfoHolderFunctions()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArStringInfoHolderFunctions
    __del__ = lambda self: None
ArStringInfoHolderFunctions_swigregister = _AriaPy.ArStringInfoHolderFunctions_swigregister
ArStringInfoHolderFunctions_swigregister(ArStringInfoHolderFunctions)

def ArStringInfoHolderFunctions_intWrapper(buffer, bufferLen, functor, format):
    """ArStringInfoHolderFunctions_intWrapper(char * buffer, ArTypes::UByte2 bufferLen, ArRetFunctor_Int functor, char const * format)"""
    return _AriaPy.ArStringInfoHolderFunctions_intWrapper(buffer, bufferLen, functor, format)

def ArStringInfoHolderFunctions_doubleWrapper(buffer, bufferLen, functor, format):
    """ArStringInfoHolderFunctions_doubleWrapper(char * buffer, ArTypes::UByte2 bufferLen, ArRetFunctor_Double functor, char const * format)"""
    return _AriaPy.ArStringInfoHolderFunctions_doubleWrapper(buffer, bufferLen, functor, format)

def ArStringInfoHolderFunctions_boolWrapper(buffer, bufferLen, functor, format):
    """ArStringInfoHolderFunctions_boolWrapper(char * buffer, ArTypes::UByte2 bufferLen, ArRetFunctor_Bool functor, char const * format)"""
    return _AriaPy.ArStringInfoHolderFunctions_boolWrapper(buffer, bufferLen, functor, format)

def ArStringInfoHolderFunctions_stringWrapper(buffer, bufferLen, functor, format):
    """ArStringInfoHolderFunctions_stringWrapper(char * buffer, ArTypes::UByte2 bufferLen, ArRetFunctor< char const * > * functor, char const * format)"""
    return _AriaPy.ArStringInfoHolderFunctions_stringWrapper(buffer, bufferLen, functor, format)

def ArStringInfoHolderFunctions_unsignedLongWrapper(buffer, bufferLen, functor, format):
    """ArStringInfoHolderFunctions_unsignedLongWrapper(char * buffer, ArTypes::UByte2 bufferLen, ArRetFunctor< unsigned long > * functor, char const * format)"""
    return _AriaPy.ArStringInfoHolderFunctions_unsignedLongWrapper(buffer, bufferLen, functor, format)

def ArStringInfoHolderFunctions_longWrapper(buffer, bufferLen, functor, format):
    """ArStringInfoHolderFunctions_longWrapper(char * buffer, ArTypes::UByte2 bufferLen, ArRetFunctor< long > * functor, char const * format)"""
    return _AriaPy.ArStringInfoHolderFunctions_longWrapper(buffer, bufferLen, functor, format)

class ArCallbackList(object):
    """Proxy of C++ ArCallbackList 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__(ArCallbackList self, char const * name, ArLog::LogLevel logLevel, bool singleShot=False) -> ArCallbackList
        __init__(ArCallbackList self, char const * name, ArLog::LogLevel logLevel) -> ArCallbackList
        __init__(ArCallbackList self, char const * name) -> ArCallbackList
        __init__(ArCallbackList self) -> ArCallbackList
        """
        this = _AriaPy.new_ArCallbackList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArCallbackList
    __del__ = lambda self: None

    def invoke(self):
        """invoke(ArCallbackList self)"""
        return _AriaPy.ArCallbackList_invoke(self)

ArCallbackList_swigregister = _AriaPy.ArCallbackList_swigregister
ArCallbackList_swigregister(ArCallbackList)

class ArPoseUtil(object):
    """Proxy of C++ ArPoseUtil class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def findCornersFromRobotBounds(radius, widthLeft, widthRight, lengthFront, lengthRear, fastButUnsafe):
        """findCornersFromRobotBounds(double radius, double widthLeft, double widthRight, double lengthFront, double lengthRear, bool fastButUnsafe) -> ArPoseList"""
        return _AriaPy.ArPoseUtil_findCornersFromRobotBounds(radius, widthLeft, widthRight, lengthFront, lengthRear, fastButUnsafe)

    findCornersFromRobotBounds = staticmethod(findCornersFromRobotBounds)

    def breakUpDistanceEvenly(start, end, resolution):
        """breakUpDistanceEvenly(ArPose start, ArPose end, int resolution) -> ArPoseList"""
        return _AriaPy.ArPoseUtil_breakUpDistanceEvenly(start, end, resolution)

    breakUpDistanceEvenly = staticmethod(breakUpDistanceEvenly)

    def __init__(self):
        """__init__(ArPoseUtil self) -> ArPoseUtil"""
        this = _AriaPy.new_ArPoseUtil()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArPoseUtil
    __del__ = lambda self: None
ArPoseUtil_swigregister = _AriaPy.ArPoseUtil_swigregister
ArPoseUtil_swigregister(ArPoseUtil)

def ArPoseUtil_findCornersFromRobotBounds(radius, widthLeft, widthRight, lengthFront, lengthRear, fastButUnsafe):
    """ArPoseUtil_findCornersFromRobotBounds(double radius, double widthLeft, double widthRight, double lengthFront, double lengthRear, bool fastButUnsafe) -> ArPoseList"""
    return _AriaPy.ArPoseUtil_findCornersFromRobotBounds(radius, widthLeft, widthRight, lengthFront, lengthRear, fastButUnsafe)

def ArPoseUtil_breakUpDistanceEvenly(start, end, resolution):
    """ArPoseUtil_breakUpDistanceEvenly(ArPose start, ArPose end, int resolution) -> ArPoseList"""
    return _AriaPy.ArPoseUtil_breakUpDistanceEvenly(start, end, resolution)

class md5_state_t(object):
    """Proxy of C++ md5_state_s class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    count = _swig_property(_AriaPy.md5_state_t_count_get, _AriaPy.md5_state_t_count_set)
    abcd = _swig_property(_AriaPy.md5_state_t_abcd_get, _AriaPy.md5_state_t_abcd_set)
    buf = _swig_property(_AriaPy.md5_state_t_buf_get, _AriaPy.md5_state_t_buf_set)

    def __init__(self):
        """__init__(md5_state_s self) -> md5_state_t"""
        this = _AriaPy.new_md5_state_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_md5_state_t
    __del__ = lambda self: None
md5_state_t_swigregister = _AriaPy.md5_state_t_swigregister
md5_state_t_swigregister(md5_state_t)


def md5_init(pms):
    """md5_init(md5_state_t pms)"""
    return _AriaPy.md5_init(pms)

def md5_append(pms, data, nbytes):
    """md5_append(md5_state_t pms, md5_byte_t const * data, int nbytes)"""
    return _AriaPy.md5_append(pms, data, nbytes)

def md5_finish(pms, digest):
    """md5_finish(md5_state_t pms, md5_byte_t [16] digest)"""
    return _AriaPy.md5_finish(pms, digest)
class ArBasePacket(object):
    """Proxy of C++ ArBasePacket 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__(ArBasePacket self, ArTypes::UByte2 bufferSize=0, ArTypes::UByte2 headerLength=0, char * buf=None, ArTypes::UByte2 footerLength=0) -> ArBasePacket
        __init__(ArBasePacket self, ArTypes::UByte2 bufferSize=0, ArTypes::UByte2 headerLength=0, char * buf=None) -> ArBasePacket
        __init__(ArBasePacket self, ArTypes::UByte2 bufferSize=0, ArTypes::UByte2 headerLength=0) -> ArBasePacket
        __init__(ArBasePacket self, ArTypes::UByte2 bufferSize=0) -> ArBasePacket
        __init__(ArBasePacket self) -> ArBasePacket
        __init__(ArBasePacket self, ArBasePacket other) -> ArBasePacket
        """
        this = _AriaPy.new_ArBasePacket(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArBasePacket
    __del__ = lambda self: None

    def empty(self):
        """empty(ArBasePacket self)"""
        return _AriaPy.ArBasePacket_empty(self)


    def finalizePacket(self):
        """finalizePacket(ArBasePacket self)"""
        return _AriaPy.ArBasePacket_finalizePacket(self)


    def log(self):
        """log(ArBasePacket self)"""
        return _AriaPy.ArBasePacket_log(self)


    def printHex(self):
        """printHex(ArBasePacket self)"""
        return _AriaPy.ArBasePacket_printHex(self)


    def isValid(self):
        """isValid(ArBasePacket self) -> bool"""
        return _AriaPy.ArBasePacket_isValid(self)


    def resetValid(self):
        """resetValid(ArBasePacket self)"""
        return _AriaPy.ArBasePacket_resetValid(self)


    def byteToBuf(self, val):
        """byteToBuf(ArBasePacket self, ArTypes::Byte val)"""
        return _AriaPy.ArBasePacket_byteToBuf(self, val)


    def byte2ToBuf(self, val):
        """byte2ToBuf(ArBasePacket self, ArTypes::Byte2 val)"""
        return _AriaPy.ArBasePacket_byte2ToBuf(self, val)


    def byte4ToBuf(self, val):
        """byte4ToBuf(ArBasePacket self, ArTypes::Byte4 val)"""
        return _AriaPy.ArBasePacket_byte4ToBuf(self, val)


    def uByteToBuf(self, val):
        """uByteToBuf(ArBasePacket self, ArTypes::UByte val)"""
        return _AriaPy.ArBasePacket_uByteToBuf(self, val)


    def uByte2ToBuf(self, val):
        """uByte2ToBuf(ArBasePacket self, ArTypes::UByte2 val)"""
        return _AriaPy.ArBasePacket_uByte2ToBuf(self, val)


    def uByte4ToBuf(self, val):
        """uByte4ToBuf(ArBasePacket self, ArTypes::UByte4 val)"""
        return _AriaPy.ArBasePacket_uByte4ToBuf(self, val)


    def strToBuf(self, str):
        """strToBuf(ArBasePacket self, char const * str)"""
        return _AriaPy.ArBasePacket_strToBuf(self, str)


    def strNToBuf(self, str, length):
        """strNToBuf(ArBasePacket self, char const * str, int length)"""
        return _AriaPy.ArBasePacket_strNToBuf(self, str, length)


    def strToBufPadded(self, str, length):
        """strToBufPadded(ArBasePacket self, char const * str, int length)"""
        return _AriaPy.ArBasePacket_strToBufPadded(self, str, length)


    def dataToBuf(self, *args):
        """
        dataToBuf(ArBasePacket self, char const * data, int length)
        dataToBuf(ArBasePacket self, unsigned char const * data, int length)
        """
        return _AriaPy.ArBasePacket_dataToBuf(self, *args)


    def bufToByte(self):
        """bufToByte(ArBasePacket self) -> ArTypes::Byte"""
        return _AriaPy.ArBasePacket_bufToByte(self)


    def bufToByte2(self):
        """bufToByte2(ArBasePacket self) -> ArTypes::Byte2"""
        return _AriaPy.ArBasePacket_bufToByte2(self)


    def bufToByte4(self):
        """bufToByte4(ArBasePacket self) -> ArTypes::Byte4"""
        return _AriaPy.ArBasePacket_bufToByte4(self)


    def bufToUByte(self):
        """bufToUByte(ArBasePacket self) -> ArTypes::UByte"""
        return _AriaPy.ArBasePacket_bufToUByte(self)


    def bufToUByte2(self):
        """bufToUByte2(ArBasePacket self) -> ArTypes::UByte2"""
        return _AriaPy.ArBasePacket_bufToUByte2(self)


    def bufToUByte4(self):
        """bufToUByte4(ArBasePacket self) -> ArTypes::UByte4"""
        return _AriaPy.ArBasePacket_bufToUByte4(self)


    def bufToStr(self, buf, len):
        """bufToStr(ArBasePacket self, char * buf, int len)"""
        return _AriaPy.ArBasePacket_bufToStr(self, buf, len)


    def bufToData(self, *args):
        """
        bufToData(ArBasePacket self, char * data, int length)
        bufToData(ArBasePacket self, unsigned char * data, int length)
        """
        return _AriaPy.ArBasePacket_bufToData(self, *args)


    def resetRead(self):
        """resetRead(ArBasePacket self)"""
        return _AriaPy.ArBasePacket_resetRead(self)


    def getLength(self):
        """getLength(ArBasePacket self) -> ArTypes::UByte2"""
        return _AriaPy.ArBasePacket_getLength(self)


    def getDataLength(self):
        """getDataLength(ArBasePacket self) -> ArTypes::UByte2"""
        return _AriaPy.ArBasePacket_getDataLength(self)


    def getReadLength(self):
        """getReadLength(ArBasePacket self) -> ArTypes::UByte2"""
        return _AriaPy.ArBasePacket_getReadLength(self)


    def getDataReadLength(self):
        """getDataReadLength(ArBasePacket self) -> ArTypes::UByte2"""
        return _AriaPy.ArBasePacket_getDataReadLength(self)


    def getHeaderLength(self):
        """getHeaderLength(ArBasePacket self) -> ArTypes::UByte2"""
        return _AriaPy.ArBasePacket_getHeaderLength(self)


    def getFooterLength(self):
        """getFooterLength(ArBasePacket self) -> ArTypes::UByte2"""
        return _AriaPy.ArBasePacket_getFooterLength(self)


    def getMaxLength(self):
        """getMaxLength(ArBasePacket self) -> ArTypes::UByte2"""
        return _AriaPy.ArBasePacket_getMaxLength(self)


    def getBuf(self, *args):
        """
        getBuf(ArBasePacket self) -> char const
        getBuf(ArBasePacket self) -> char *
        """
        return _AriaPy.ArBasePacket_getBuf(self, *args)


    def setBuf(self, buf, bufferSize):
        """setBuf(ArBasePacket self, char * buf, ArTypes::UByte2 bufferSize)"""
        return _AriaPy.ArBasePacket_setBuf(self, buf, bufferSize)


    def setMaxLength(self, bufferSize):
        """setMaxLength(ArBasePacket self, ArTypes::UByte2 bufferSize)"""
        return _AriaPy.ArBasePacket_setMaxLength(self, bufferSize)


    def setLength(self, length):
        """setLength(ArBasePacket self, ArTypes::UByte2 length) -> bool"""
        return _AriaPy.ArBasePacket_setLength(self, length)


    def setReadLength(self, readLength):
        """setReadLength(ArBasePacket self, ArTypes::UByte2 readLength)"""
        return _AriaPy.ArBasePacket_setReadLength(self, readLength)


    def setHeaderLength(self, length):
        """setHeaderLength(ArBasePacket self, ArTypes::UByte2 length) -> bool"""
        return _AriaPy.ArBasePacket_setHeaderLength(self, length)


    def duplicatePacket(self, packet):
        """duplicatePacket(ArBasePacket self, ArBasePacket packet)"""
        return _AriaPy.ArBasePacket_duplicatePacket(self, packet)

ArBasePacket_swigregister = _AriaPy.ArBasePacket_swigregister
ArBasePacket_swigregister(ArBasePacket)

class ArPTZ(object):
    """Proxy of C++ ArPTZ 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__ = _AriaPy.delete_ArPTZ
    __del__ = lambda self: None

    def init(self):
        """init(ArPTZ self) -> bool"""
        return _AriaPy.ArPTZ_init(self)


    def getTypeName(self):
        """getTypeName(ArPTZ self) -> char const *"""
        return _AriaPy.ArPTZ_getTypeName(self)


    def reset(self):
        """reset(ArPTZ self)"""
        return _AriaPy.ArPTZ_reset(self)


    def pan(self, degrees):
        """pan(ArPTZ self, double degrees) -> bool"""
        return _AriaPy.ArPTZ_pan(self, degrees)


    def panRel(self, degrees):
        """panRel(ArPTZ self, double degrees) -> bool"""
        return _AriaPy.ArPTZ_panRel(self, degrees)


    def tilt(self, degrees):
        """tilt(ArPTZ self, double degrees) -> bool"""
        return _AriaPy.ArPTZ_tilt(self, degrees)


    def tiltRel(self, degrees):
        """tiltRel(ArPTZ self, double degrees) -> bool"""
        return _AriaPy.ArPTZ_tiltRel(self, degrees)


    def panTilt(self, degreesPan, degreesTilt):
        """panTilt(ArPTZ self, double degreesPan, double degreesTilt) -> bool"""
        return _AriaPy.ArPTZ_panTilt(self, degreesPan, degreesTilt)


    def panTiltRel(self, degreesPan, degreesTilt):
        """panTiltRel(ArPTZ self, double degreesPan, double degreesTilt) -> bool"""
        return _AriaPy.ArPTZ_panTiltRel(self, degreesPan, degreesTilt)


    def canZoom(self):
        """canZoom(ArPTZ self) -> bool"""
        return _AriaPy.ArPTZ_canZoom(self)


    def zoom(self, zoomValue):
        """zoom(ArPTZ self, int zoomValue) -> bool"""
        return _AriaPy.ArPTZ_zoom(self, zoomValue)


    def zoomRel(self, zoomValue):
        """zoomRel(ArPTZ self, int zoomValue) -> bool"""
        return _AriaPy.ArPTZ_zoomRel(self, zoomValue)


    def getPan(self):
        """getPan(ArPTZ self) -> double"""
        return _AriaPy.ArPTZ_getPan(self)


    def getTilt(self):
        """getTilt(ArPTZ self) -> double"""
        return _AriaPy.ArPTZ_getTilt(self)


    def getZoom(self):
        """getZoom(ArPTZ self) -> int"""
        return _AriaPy.ArPTZ_getZoom(self)


    def canGetRealPanTilt(self):
        """canGetRealPanTilt(ArPTZ self) -> bool"""
        return _AriaPy.ArPTZ_canGetRealPanTilt(self)


    def canGetRealZoom(self):
        """canGetRealZoom(ArPTZ self) -> bool"""
        return _AriaPy.ArPTZ_canGetRealZoom(self)


    def getMaxPosPan(self):
        """getMaxPosPan(ArPTZ self) -> double"""
        return _AriaPy.ArPTZ_getMaxPosPan(self)


    def getMaxPan(self):
        """getMaxPan(ArPTZ self) -> double"""
        return _AriaPy.ArPTZ_getMaxPan(self)


    def getMaxNegPan(self):
        """getMaxNegPan(ArPTZ self) -> double"""
        return _AriaPy.ArPTZ_getMaxNegPan(self)


    def getMinPan(self):
        """getMinPan(ArPTZ self) -> double"""
        return _AriaPy.ArPTZ_getMinPan(self)


    def getMaxPosTilt(self):
        """getMaxPosTilt(ArPTZ self) -> double"""
        return _AriaPy.ArPTZ_getMaxPosTilt(self)


    def getMaxTilt(self):
        """getMaxTilt(ArPTZ self) -> double"""
        return _AriaPy.ArPTZ_getMaxTilt(self)


    def getMaxNegTilt(self):
        """getMaxNegTilt(ArPTZ self) -> double"""
        return _AriaPy.ArPTZ_getMaxNegTilt(self)


    def getMinTilt(self):
        """getMinTilt(ArPTZ self) -> double"""
        return _AriaPy.ArPTZ_getMinTilt(self)


    def haltPanTilt(self):
        """haltPanTilt(ArPTZ self) -> bool"""
        return _AriaPy.ArPTZ_haltPanTilt(self)


    def haltZoom(self):
        """haltZoom(ArPTZ self) -> bool"""
        return _AriaPy.ArPTZ_haltZoom(self)


    def canPanTiltSlew(self):
        """canPanTiltSlew(ArPTZ self) -> bool"""
        return _AriaPy.ArPTZ_canPanTiltSlew(self)


    def panSlew(self, s):
        """panSlew(ArPTZ self, double s) -> bool"""
        return _AriaPy.ArPTZ_panSlew(self, s)


    def tiltSlew(self, s):
        """tiltSlew(ArPTZ self, double s) -> bool"""
        return _AriaPy.ArPTZ_tiltSlew(self, s)


    def getMaxZoom(self):
        """getMaxZoom(ArPTZ self) -> int"""
        return _AriaPy.ArPTZ_getMaxZoom(self)


    def getMinZoom(self):
        """getMinZoom(ArPTZ self) -> int"""
        return _AriaPy.ArPTZ_getMinZoom(self)


    def canGetFOV(self):
        """canGetFOV(ArPTZ self) -> bool"""
        return _AriaPy.ArPTZ_canGetFOV(self)


    def getFOVAtMaxZoom(self):
        """getFOVAtMaxZoom(ArPTZ self) -> double"""
        return _AriaPy.ArPTZ_getFOVAtMaxZoom(self)


    def getFOVAtMinZoom(self):
        """getFOVAtMinZoom(ArPTZ self) -> double"""
        return _AriaPy.ArPTZ_getFOVAtMinZoom(self)


    def setGain(self, gain):
        """setGain(ArPTZ self, double gain) -> bool"""
        return _AriaPy.ArPTZ_setGain(self, gain)


    def getGain(self, gain):
        """getGain(ArPTZ self, double gain) -> double"""
        return _AriaPy.ArPTZ_getGain(self, gain)


    def canSetGain(self):
        """canSetGain(ArPTZ self) -> bool"""
        return _AriaPy.ArPTZ_canSetGain(self)


    def setFocus(self, focus):
        """setFocus(ArPTZ self, double focus) -> bool"""
        return _AriaPy.ArPTZ_setFocus(self, focus)


    def getFocus(self, focus):
        """getFocus(ArPTZ self, double focus) -> double"""
        return _AriaPy.ArPTZ_getFocus(self, focus)


    def canSetFocus(self):
        """canSetFocus(ArPTZ self) -> bool"""
        return _AriaPy.ArPTZ_canSetFocus(self)


    def setInverted(self, inv):
        """setInverted(ArPTZ self, bool inv)"""
        return _AriaPy.ArPTZ_setInverted(self, inv)


    def getInverted(self):
        """getInverted(ArPTZ self) -> bool"""
        return _AriaPy.ArPTZ_getInverted(self)


    def setDeviceConnection(self, connection, driveFromRobotLoop=True):
        """
        setDeviceConnection(ArPTZ self, ArDeviceConnection connection, bool driveFromRobotLoop=True) -> bool
        setDeviceConnection(ArPTZ self, ArDeviceConnection connection) -> bool
        """
        return _AriaPy.ArPTZ_setDeviceConnection(self, connection, driveFromRobotLoop)


    def getDeviceConnection(self):
        """getDeviceConnection(ArPTZ self) -> ArDeviceConnection"""
        return _AriaPy.ArPTZ_getDeviceConnection(self)


    def setAuxPort(self, auxPort):
        """setAuxPort(ArPTZ self, int auxPort) -> bool"""
        return _AriaPy.ArPTZ_setAuxPort(self, auxPort)


    def getAuxPort(self):
        """getAuxPort(ArPTZ self) -> int"""
        return _AriaPy.ArPTZ_getAuxPort(self)


    def readPacket(self):
        """readPacket(ArPTZ self) -> ArBasePacket"""
        return _AriaPy.ArPTZ_readPacket(self)


    def sendPacket(self, packet):
        """sendPacket(ArPTZ self, ArBasePacket packet) -> bool"""
        return _AriaPy.ArPTZ_sendPacket(self, packet)


    def packetHandler(self, packet):
        """packetHandler(ArPTZ self, ArBasePacket packet) -> bool"""
        return _AriaPy.ArPTZ_packetHandler(self, packet)


    def robotPacketHandler(self, packet):
        """robotPacketHandler(ArPTZ self, ArRobotPacket packet) -> bool"""
        return _AriaPy.ArPTZ_robotPacketHandler(self, packet)


    def connectHandler(self):
        """connectHandler(ArPTZ self)"""
        return _AriaPy.ArPTZ_connectHandler(self)


    def sensorInterpHandler(self):
        """sensorInterpHandler(ArPTZ self)"""
        return _AriaPy.ArPTZ_sensorInterpHandler(self)


    def getRobot(self):
        """getRobot(ArPTZ self) -> ArRobot"""
        return _AriaPy.ArPTZ_getRobot(self)

ArPTZ_swigregister = _AriaPy.ArPTZ_swigregister
ArPTZ_swigregister(ArPTZ)

class ArRangeDevice(object):
    """Proxy of C++ ArRangeDevice 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, currentBufferSize, cumulativeBufferSize, name, maxRange, maxSecondsToKeepCurrent=0, maxSecondsToKeepCumulative=0, maxDistToKeepCumulative=0, locationDependent=False):
        """
        __init__(ArRangeDevice self, size_t currentBufferSize, size_t cumulativeBufferSize, char const * name, unsigned int maxRange, int maxSecondsToKeepCurrent=0, int maxSecondsToKeepCumulative=0, double maxDistToKeepCumulative=0, bool locationDependent=False) -> ArRangeDevice
        __init__(ArRangeDevice self, size_t currentBufferSize, size_t cumulativeBufferSize, char const * name, unsigned int maxRange, int maxSecondsToKeepCurrent=0, int maxSecondsToKeepCumulative=0, double maxDistToKeepCumulative=0) -> ArRangeDevice
        __init__(ArRangeDevice self, size_t currentBufferSize, size_t cumulativeBufferSize, char const * name, unsigned int maxRange, int maxSecondsToKeepCurrent=0, int maxSecondsToKeepCumulative=0) -> ArRangeDevice
        __init__(ArRangeDevice self, size_t currentBufferSize, size_t cumulativeBufferSize, char const * name, unsigned int maxRange, int maxSecondsToKeepCurrent=0) -> ArRangeDevice
        __init__(ArRangeDevice self, size_t currentBufferSize, size_t cumulativeBufferSize, char const * name, unsigned int maxRange) -> ArRangeDevice
        """
        this = _AriaPy.new_ArRangeDevice(currentBufferSize, cumulativeBufferSize, name, maxRange, maxSecondsToKeepCurrent, maxSecondsToKeepCumulative, maxDistToKeepCumulative, locationDependent)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRangeDevice
    __del__ = lambda self: None

    def getName(self):
        """getName(ArRangeDevice self) -> char const *"""
        return _AriaPy.ArRangeDevice_getName(self)


    def setRobot(self, robot):
        """setRobot(ArRangeDevice self, ArRobot robot)"""
        return _AriaPy.ArRangeDevice_setRobot(self, robot)


    def getRobot(self):
        """getRobot(ArRangeDevice self) -> ArRobot"""
        return _AriaPy.ArRangeDevice_getRobot(self)


    def setCurrentBufferSize(self, size):
        """setCurrentBufferSize(ArRangeDevice self, size_t size)"""
        return _AriaPy.ArRangeDevice_setCurrentBufferSize(self, size)


    def getCurrentBufferSize(self):
        """getCurrentBufferSize(ArRangeDevice self) -> size_t"""
        return _AriaPy.ArRangeDevice_getCurrentBufferSize(self)


    def setCumulativeBufferSize(self, size):
        """setCumulativeBufferSize(ArRangeDevice self, size_t size)"""
        return _AriaPy.ArRangeDevice_setCumulativeBufferSize(self, size)


    def getCumulativeBufferSize(self):
        """getCumulativeBufferSize(ArRangeDevice self) -> size_t"""
        return _AriaPy.ArRangeDevice_getCumulativeBufferSize(self)


    def addReading(self, x, y, wasAdded=None):
        """
        addReading(ArRangeDevice self, double x, double y, bool * wasAdded=None)
        addReading(ArRangeDevice self, double x, double y)
        """
        return _AriaPy.ArRangeDevice_addReading(self, x, y, wasAdded)


    def isLocationDependent(self):
        """isLocationDependent(ArRangeDevice self) -> bool"""
        return _AriaPy.ArRangeDevice_isLocationDependent(self)


    def currentReadingPolar(self, startAngle, endAngle, angle=None):
        """
        currentReadingPolar(ArRangeDevice self, double startAngle, double endAngle, double * angle=None) -> double
        currentReadingPolar(ArRangeDevice self, double startAngle, double endAngle) -> double
        """
        return _AriaPy.ArRangeDevice_currentReadingPolar(self, startAngle, endAngle, angle)


    def cumulativeReadingPolar(self, startAngle, endAngle, angle=None):
        """
        cumulativeReadingPolar(ArRangeDevice self, double startAngle, double endAngle, double * angle=None) -> double
        cumulativeReadingPolar(ArRangeDevice self, double startAngle, double endAngle) -> double
        """
        return _AriaPy.ArRangeDevice_cumulativeReadingPolar(self, startAngle, endAngle, angle)


    def currentReadingBox(self, x1, y1, x2, y2, readingPos=None):
        """
        currentReadingBox(ArRangeDevice self, double x1, double y1, double x2, double y2, ArPose readingPos=None) -> double
        currentReadingBox(ArRangeDevice self, double x1, double y1, double x2, double y2) -> double
        """
        return _AriaPy.ArRangeDevice_currentReadingBox(self, x1, y1, x2, y2, readingPos)


    def cumulativeReadingBox(self, x1, y1, x2, y2, readingPos=None):
        """
        cumulativeReadingBox(ArRangeDevice self, double x1, double y1, double x2, double y2, ArPose readingPos=None) -> double
        cumulativeReadingBox(ArRangeDevice self, double x1, double y1, double x2, double y2) -> double
        """
        return _AriaPy.ArRangeDevice_cumulativeReadingBox(self, x1, y1, x2, y2, readingPos)


    def getCurrentRangeBuffer(self):
        """getCurrentRangeBuffer(ArRangeDevice self) -> ArRangeBuffer"""
        return _AriaPy.ArRangeDevice_getCurrentRangeBuffer(self)


    def getCumulativeRangeBuffer(self):
        """getCumulativeRangeBuffer(ArRangeDevice self) -> ArRangeBuffer"""
        return _AriaPy.ArRangeDevice_getCumulativeRangeBuffer(self)


    def getCurrentBuffer(self):
        """getCurrentBuffer(ArRangeDevice self) -> ArPoseWithTimePtrList"""
        return _AriaPy.ArRangeDevice_getCurrentBuffer(self)


    def getCurrentBufferAsVector(self):
        """getCurrentBufferAsVector(ArRangeDevice self) -> ArPoseWithTimeVector"""
        return _AriaPy.ArRangeDevice_getCurrentBufferAsVector(self)


    def getCumulativeBuffer(self):
        """getCumulativeBuffer(ArRangeDevice self) -> ArPoseWithTimePtrList"""
        return _AriaPy.ArRangeDevice_getCumulativeBuffer(self)


    def getCumulativeBufferAsVector(self):
        """getCumulativeBufferAsVector(ArRangeDevice self) -> ArPoseWithTimeVector"""
        return _AriaPy.ArRangeDevice_getCumulativeBufferAsVector(self)


    def getRawReadings(self):
        """getRawReadings(ArRangeDevice self) -> std::list< ArSensorReading *,std::allocator< ArSensorReading * > > const *"""
        return _AriaPy.ArRangeDevice_getRawReadings(self)


    def getRawReadingsAsVector(self):
        """getRawReadingsAsVector(ArRangeDevice self) -> ArSensorReadingVector"""
        return _AriaPy.ArRangeDevice_getRawReadingsAsVector(self)


    def getAdjustedRawReadings(self):
        """getAdjustedRawReadings(ArRangeDevice self) -> std::list< ArSensorReading *,std::allocator< ArSensorReading * > > const *"""
        return _AriaPy.ArRangeDevice_getAdjustedRawReadings(self)


    def getAdjustedRawReadingsAsVector(self):
        """getAdjustedRawReadingsAsVector(ArRangeDevice self) -> ArSensorReadingVector"""
        return _AriaPy.ArRangeDevice_getAdjustedRawReadingsAsVector(self)


    def setMaxSecondsToKeepCurrent(self, maxSecondsToKeepCurrent):
        """setMaxSecondsToKeepCurrent(ArRangeDevice self, int maxSecondsToKeepCurrent)"""
        return _AriaPy.ArRangeDevice_setMaxSecondsToKeepCurrent(self, maxSecondsToKeepCurrent)


    def getMaxSecondsToKeepCurrent(self):
        """getMaxSecondsToKeepCurrent(ArRangeDevice self) -> int"""
        return _AriaPy.ArRangeDevice_getMaxSecondsToKeepCurrent(self)


    def setMinDistBetweenCurrent(self, minDistBetweenCurrent):
        """setMinDistBetweenCurrent(ArRangeDevice self, double minDistBetweenCurrent)"""
        return _AriaPy.ArRangeDevice_setMinDistBetweenCurrent(self, minDistBetweenCurrent)


    def getMinDistBetweenCurrent(self):
        """getMinDistBetweenCurrent(ArRangeDevice self) -> double"""
        return _AriaPy.ArRangeDevice_getMinDistBetweenCurrent(self)


    def setMaxSecondsToKeepCumulative(self, maxSecondsToKeepCumulative):
        """setMaxSecondsToKeepCumulative(ArRangeDevice self, int maxSecondsToKeepCumulative)"""
        return _AriaPy.ArRangeDevice_setMaxSecondsToKeepCumulative(self, maxSecondsToKeepCumulative)


    def getMaxSecondsToKeepCumulative(self):
        """getMaxSecondsToKeepCumulative(ArRangeDevice self) -> int"""
        return _AriaPy.ArRangeDevice_getMaxSecondsToKeepCumulative(self)


    def setMaxDistToKeepCumulative(self, maxDistToKeepCumulative):
        """setMaxDistToKeepCumulative(ArRangeDevice self, double maxDistToKeepCumulative)"""
        return _AriaPy.ArRangeDevice_setMaxDistToKeepCumulative(self, maxDistToKeepCumulative)


    def getMaxDistToKeepCumulative(self):
        """getMaxDistToKeepCumulative(ArRangeDevice self) -> double"""
        return _AriaPy.ArRangeDevice_getMaxDistToKeepCumulative(self)


    def setMinDistBetweenCumulative(self, minDistBetweenCumulative):
        """setMinDistBetweenCumulative(ArRangeDevice self, double minDistBetweenCumulative)"""
        return _AriaPy.ArRangeDevice_setMinDistBetweenCumulative(self, minDistBetweenCumulative)


    def getMinDistBetweenCumulative(self):
        """getMinDistBetweenCumulative(ArRangeDevice self) -> double"""
        return _AriaPy.ArRangeDevice_getMinDistBetweenCumulative(self)


    def setMaxInsertDistCumulative(self, maxInsertDistCumulative):
        """setMaxInsertDistCumulative(ArRangeDevice self, double maxInsertDistCumulative)"""
        return _AriaPy.ArRangeDevice_setMaxInsertDistCumulative(self, maxInsertDistCumulative)


    def getMaxInsertDistCumulative(self):
        """getMaxInsertDistCumulative(ArRangeDevice self) -> double"""
        return _AriaPy.ArRangeDevice_getMaxInsertDistCumulative(self)


    def clearCurrentReadings(self):
        """clearCurrentReadings(ArRangeDevice self)"""
        return _AriaPy.ArRangeDevice_clearCurrentReadings(self)


    def clearCumulativeReadings(self):
        """clearCumulativeReadings(ArRangeDevice self)"""
        return _AriaPy.ArRangeDevice_clearCumulativeReadings(self)


    def clearCumulativeOlderThan(self, milliSeconds):
        """clearCumulativeOlderThan(ArRangeDevice self, int milliSeconds)"""
        return _AriaPy.ArRangeDevice_clearCumulativeOlderThan(self, milliSeconds)


    def clearCumulativeOlderThanSeconds(self, seconds):
        """clearCumulativeOlderThanSeconds(ArRangeDevice self, int seconds)"""
        return _AriaPy.ArRangeDevice_clearCumulativeOlderThanSeconds(self, seconds)


    def getMaxRange(self):
        """getMaxRange(ArRangeDevice self) -> unsigned int"""
        return _AriaPy.ArRangeDevice_getMaxRange(self)


    def setMaxRange(self, maxRange):
        """setMaxRange(ArRangeDevice self, unsigned int maxRange)"""
        return _AriaPy.ArRangeDevice_setMaxRange(self, maxRange)


    def applyTransform(self, trans, doCumulative=True):
        """
        applyTransform(ArRangeDevice self, ArTransform trans, bool doCumulative=True)
        applyTransform(ArRangeDevice self, ArTransform trans)
        """
        return _AriaPy.ArRangeDevice_applyTransform(self, trans, doCumulative)


    def getCurrentDrawingData(self):
        """getCurrentDrawingData(ArRangeDevice self) -> ArDrawingData"""
        return _AriaPy.ArRangeDevice_getCurrentDrawingData(self)


    def getCumulativeDrawingData(self):
        """getCumulativeDrawingData(ArRangeDevice self) -> ArDrawingData"""
        return _AriaPy.ArRangeDevice_getCumulativeDrawingData(self)


    def setCurrentDrawingData(self, data, takeOwnershipOfData):
        """setCurrentDrawingData(ArRangeDevice self, ArDrawingData data, bool takeOwnershipOfData)"""
        return _AriaPy.ArRangeDevice_setCurrentDrawingData(self, data, takeOwnershipOfData)


    def setCumulativeDrawingData(self, data, takeOwnershipOfData):
        """setCumulativeDrawingData(ArRangeDevice self, ArDrawingData data, bool takeOwnershipOfData)"""
        return _AriaPy.ArRangeDevice_setCumulativeDrawingData(self, data, takeOwnershipOfData)


    def lockDevice(self):
        """lockDevice(ArRangeDevice self) -> int"""
        return _AriaPy.ArRangeDevice_lockDevice(self)


    def tryLockDevice(self):
        """tryLockDevice(ArRangeDevice self) -> int"""
        return _AriaPy.ArRangeDevice_tryLockDevice(self)


    def unlockDevice(self):
        """unlockDevice(ArRangeDevice self) -> int"""
        return _AriaPy.ArRangeDevice_unlockDevice(self)


    def filterCallback(self):
        """filterCallback(ArRangeDevice self)"""
        return _AriaPy.ArRangeDevice_filterCallback(self)

ArRangeDevice_swigregister = _AriaPy.ArRangeDevice_swigregister
ArRangeDevice_swigregister(ArRangeDevice)

class ArRangeDeviceThreaded(ArRangeDevice):
    """Proxy of C++ ArRangeDeviceThreaded 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__ = _AriaPy.delete_ArRangeDeviceThreaded
    __del__ = lambda self: None

    def runThread(self, arg):
        """runThread(ArRangeDeviceThreaded self, void * arg) -> void *"""
        return _AriaPy.ArRangeDeviceThreaded_runThread(self, arg)


    def run(self):
        """run(ArRangeDeviceThreaded self)"""
        return _AriaPy.ArRangeDeviceThreaded_run(self)


    def runAsync(self):
        """runAsync(ArRangeDeviceThreaded self)"""
        return _AriaPy.ArRangeDeviceThreaded_runAsync(self)


    def stopRunning(self):
        """stopRunning(ArRangeDeviceThreaded self)"""
        return _AriaPy.ArRangeDeviceThreaded_stopRunning(self)


    def getRunning(self):
        """getRunning(ArRangeDeviceThreaded self) -> bool"""
        return _AriaPy.ArRangeDeviceThreaded_getRunning(self)


    def getRunningWithLock(self):
        """getRunningWithLock(ArRangeDeviceThreaded self) -> bool"""
        return _AriaPy.ArRangeDeviceThreaded_getRunningWithLock(self)


    def lockDevice(self):
        """lockDevice(ArRangeDeviceThreaded self) -> int"""
        return _AriaPy.ArRangeDeviceThreaded_lockDevice(self)


    def tryLockDevice(self):
        """tryLockDevice(ArRangeDeviceThreaded self) -> int"""
        return _AriaPy.ArRangeDeviceThreaded_tryLockDevice(self)


    def unlockDevice(self):
        """unlockDevice(ArRangeDeviceThreaded self) -> int"""
        return _AriaPy.ArRangeDeviceThreaded_unlockDevice(self)

ArRangeDeviceThreaded_swigregister = _AriaPy.ArRangeDeviceThreaded_swigregister
ArRangeDeviceThreaded_swigregister(ArRangeDeviceThreaded)

class ArLaser(ArRangeDeviceThreaded):
    """Proxy of C++ ArLaser 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__ = _AriaPy.delete_ArLaser
    __del__ = lambda self: None

    def blockingConnect(self):
        """blockingConnect(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_blockingConnect(self)


    def asyncConnect(self):
        """asyncConnect(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_asyncConnect(self)


    def disconnect(self):
        """disconnect(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_disconnect(self)


    def isConnected(self):
        """isConnected(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_isConnected(self)


    def isTryingToConnect(self):
        """isTryingToConnect(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_isTryingToConnect(self)


    def setConnectionTimeoutSeconds(self, seconds):
        """setConnectionTimeoutSeconds(ArLaser self, double seconds)"""
        return _AriaPy.ArLaser_setConnectionTimeoutSeconds(self, seconds)


    def getConnectionTimeoutSeconds(self):
        """getConnectionTimeoutSeconds(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getConnectionTimeoutSeconds(self)


    def getLastReadingTime(self):
        """getLastReadingTime(ArLaser self) -> ArTime"""
        return _AriaPy.ArLaser_getLastReadingTime(self)


    def getReadingCount(self):
        """getReadingCount(ArLaser self) -> int"""
        return _AriaPy.ArLaser_getReadingCount(self)


    def setDeviceConnection(self, conn):
        """setDeviceConnection(ArLaser self, ArDeviceConnection conn)"""
        return _AriaPy.ArLaser_setDeviceConnection(self, conn)


    def getDeviceConnection(self):
        """getDeviceConnection(ArLaser self) -> ArDeviceConnection"""
        return _AriaPy.ArLaser_getDeviceConnection(self)


    def setSensorPosition(self, *args):
        """
        setSensorPosition(ArLaser self, double x, double y, double th, double z=0)
        setSensorPosition(ArLaser self, double x, double y, double th)
        setSensorPosition(ArLaser self, ArPose pose, double z=0)
        setSensorPosition(ArLaser self, ArPose pose)
        """
        return _AriaPy.ArLaser_setSensorPosition(self, *args)


    def hasSensorPosition(self):
        """hasSensorPosition(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_hasSensorPosition(self)


    def getSensorPosition(self):
        """getSensorPosition(ArLaser self) -> ArPose"""
        return _AriaPy.ArLaser_getSensorPosition(self)


    def getSensorPositionX(self):
        """getSensorPositionX(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getSensorPositionX(self)


    def getSensorPositionY(self):
        """getSensorPositionY(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getSensorPositionY(self)


    def getSensorPositionZ(self):
        """getSensorPositionZ(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getSensorPositionZ(self)


    def getSensorPositionTh(self):
        """getSensorPositionTh(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getSensorPositionTh(self)


    def getLaserNumber(self):
        """getLaserNumber(ArLaser self) -> int"""
        return _AriaPy.ArLaser_getLaserNumber(self)


    def setInfoLogLevel(self, infoLogLevel):
        """setInfoLogLevel(ArLaser self, ArLog::LogLevel infoLogLevel)"""
        return _AriaPy.ArLaser_setInfoLogLevel(self, infoLogLevel)


    def getInfoLogLevel(self):
        """getInfoLogLevel(ArLaser self) -> ArLog::LogLevel"""
        return _AriaPy.ArLaser_getInfoLogLevel(self)


    def setCumulativeCleanDist(self, dist):
        """setCumulativeCleanDist(ArLaser self, double dist)"""
        return _AriaPy.ArLaser_setCumulativeCleanDist(self, dist)


    def getCumulativeCleanDist(self):
        """getCumulativeCleanDist(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getCumulativeCleanDist(self)


    def setCumulativeCleanInterval(self, milliSeconds):
        """setCumulativeCleanInterval(ArLaser self, int milliSeconds)"""
        return _AriaPy.ArLaser_setCumulativeCleanInterval(self, milliSeconds)


    def getCumulativeCleanInterval(self):
        """getCumulativeCleanInterval(ArLaser self) -> int"""
        return _AriaPy.ArLaser_getCumulativeCleanInterval(self)


    def setCumulativeCleanOffset(self, milliSeconds):
        """setCumulativeCleanOffset(ArLaser self, int milliSeconds)"""
        return _AriaPy.ArLaser_setCumulativeCleanOffset(self, milliSeconds)


    def getCumulativeCleanOffset(self):
        """getCumulativeCleanOffset(ArLaser self) -> int"""
        return _AriaPy.ArLaser_getCumulativeCleanOffset(self)


    def resetLastCumulativeCleanTime(self):
        """resetLastCumulativeCleanTime(ArLaser self)"""
        return _AriaPy.ArLaser_resetLastCumulativeCleanTime(self)


    def addIgnoreReadings(self, ignoreReadings):
        """addIgnoreReadings(ArLaser self, char const * ignoreReadings) -> bool"""
        return _AriaPy.ArLaser_addIgnoreReadings(self, ignoreReadings)


    def addIgnoreReading(self, ignoreReading):
        """addIgnoreReading(ArLaser self, double ignoreReading)"""
        return _AriaPy.ArLaser_addIgnoreReading(self, ignoreReading)


    def clearIgnoreReadings(self):
        """clearIgnoreReadings(ArLaser self)"""
        return _AriaPy.ArLaser_clearIgnoreReadings(self)


    def getIgnoreReadings(self):
        """getIgnoreReadings(ArLaser self) -> IntSet"""
        return _AriaPy.ArLaser_getIgnoreReadings(self)


    def getFlipped(self):
        """getFlipped(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_getFlipped(self)


    def setFlipped(self, flipped):
        """setFlipped(ArLaser self, bool flipped) -> bool"""
        return _AriaPy.ArLaser_setFlipped(self, flipped)


    def getDefaultTcpPort(self):
        """getDefaultTcpPort(ArLaser self) -> int"""
        return _AriaPy.ArLaser_getDefaultTcpPort(self)


    def getDefaultPortType(self):
        """getDefaultPortType(ArLaser self) -> char const *"""
        return _AriaPy.ArLaser_getDefaultPortType(self)


    def canSetDegrees(self):
        """canSetDegrees(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_canSetDegrees(self)


    def getStartDegreesMin(self):
        """getStartDegreesMin(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getStartDegreesMin(self)


    def getStartDegreesMax(self):
        """getStartDegreesMax(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getStartDegreesMax(self)


    def getStartDegrees(self):
        """getStartDegrees(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getStartDegrees(self)


    def setStartDegrees(self, startDegrees):
        """setStartDegrees(ArLaser self, double startDegrees) -> bool"""
        return _AriaPy.ArLaser_setStartDegrees(self, startDegrees)


    def getEndDegreesMin(self):
        """getEndDegreesMin(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getEndDegreesMin(self)


    def getEndDegreesMax(self):
        """getEndDegreesMax(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getEndDegreesMax(self)


    def getEndDegrees(self):
        """getEndDegrees(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getEndDegrees(self)


    def setEndDegrees(self, endDegrees):
        """setEndDegrees(ArLaser self, double endDegrees) -> bool"""
        return _AriaPy.ArLaser_setEndDegrees(self, endDegrees)


    def canChooseDegrees(self):
        """canChooseDegrees(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_canChooseDegrees(self)


    def getDegreesChoices(self):
        """getDegreesChoices(ArLaser self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArLaser_getDegreesChoices(self)


    def getDegreesChoicesString(self):
        """getDegreesChoicesString(ArLaser self) -> char const *"""
        return _AriaPy.ArLaser_getDegreesChoicesString(self)


    def chooseDegrees(self, range):
        """chooseDegrees(ArLaser self, char const * range) -> bool"""
        return _AriaPy.ArLaser_chooseDegrees(self, range)


    def getDegreesChoice(self):
        """getDegreesChoice(ArLaser self) -> char const *"""
        return _AriaPy.ArLaser_getDegreesChoice(self)


    def getDegreesChoiceDouble(self):
        """getDegreesChoiceDouble(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getDegreesChoiceDouble(self)


    def getDegreesChoicesMap(self):
        """getDegreesChoicesMap(ArLaser self) -> std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >"""
        return _AriaPy.ArLaser_getDegreesChoicesMap(self)


    def canSetIncrement(self):
        """canSetIncrement(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_canSetIncrement(self)


    def getIncrementMin(self):
        """getIncrementMin(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getIncrementMin(self)


    def getIncrementMax(self):
        """getIncrementMax(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getIncrementMax(self)


    def getIncrement(self):
        """getIncrement(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getIncrement(self)


    def setIncrement(self, increment):
        """setIncrement(ArLaser self, double increment) -> bool"""
        return _AriaPy.ArLaser_setIncrement(self, increment)


    def canChooseIncrement(self):
        """canChooseIncrement(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_canChooseIncrement(self)


    def getIncrementChoices(self):
        """getIncrementChoices(ArLaser self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArLaser_getIncrementChoices(self)


    def getIncrementChoicesString(self):
        """getIncrementChoicesString(ArLaser self) -> char const *"""
        return _AriaPy.ArLaser_getIncrementChoicesString(self)


    def chooseIncrement(self, increment):
        """chooseIncrement(ArLaser self, char const * increment) -> bool"""
        return _AriaPy.ArLaser_chooseIncrement(self, increment)


    def getIncrementChoice(self):
        """getIncrementChoice(ArLaser self) -> char const *"""
        return _AriaPy.ArLaser_getIncrementChoice(self)


    def getIncrementChoiceDouble(self):
        """getIncrementChoiceDouble(ArLaser self) -> double"""
        return _AriaPy.ArLaser_getIncrementChoiceDouble(self)


    def getIncrementChoicesMap(self):
        """getIncrementChoicesMap(ArLaser self) -> std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >"""
        return _AriaPy.ArLaser_getIncrementChoicesMap(self)


    def canChooseUnits(self):
        """canChooseUnits(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_canChooseUnits(self)


    def getUnitsChoices(self):
        """getUnitsChoices(ArLaser self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArLaser_getUnitsChoices(self)


    def getUnitsChoicesString(self):
        """getUnitsChoicesString(ArLaser self) -> char const *"""
        return _AriaPy.ArLaser_getUnitsChoicesString(self)


    def chooseUnits(self, units):
        """chooseUnits(ArLaser self, char const * units) -> bool"""
        return _AriaPy.ArLaser_chooseUnits(self, units)


    def getUnitsChoice(self):
        """getUnitsChoice(ArLaser self) -> char const *"""
        return _AriaPy.ArLaser_getUnitsChoice(self)


    def canChooseReflectorBits(self):
        """canChooseReflectorBits(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_canChooseReflectorBits(self)


    def getReflectorBitsChoices(self):
        """getReflectorBitsChoices(ArLaser self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArLaser_getReflectorBitsChoices(self)


    def getReflectorBitsChoicesString(self):
        """getReflectorBitsChoicesString(ArLaser self) -> char const *"""
        return _AriaPy.ArLaser_getReflectorBitsChoicesString(self)


    def chooseReflectorBits(self, reflectorBits):
        """chooseReflectorBits(ArLaser self, char const * reflectorBits) -> bool"""
        return _AriaPy.ArLaser_chooseReflectorBits(self, reflectorBits)


    def getReflectorBitsChoice(self):
        """getReflectorBitsChoice(ArLaser self) -> char const *"""
        return _AriaPy.ArLaser_getReflectorBitsChoice(self)


    def canSetPowerControlled(self):
        """canSetPowerControlled(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_canSetPowerControlled(self)


    def setPowerControlled(self, powerControlled):
        """setPowerControlled(ArLaser self, bool powerControlled) -> bool"""
        return _AriaPy.ArLaser_setPowerControlled(self, powerControlled)


    def getPowerControlled(self):
        """getPowerControlled(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_getPowerControlled(self)


    def canChooseStartingBaud(self):
        """canChooseStartingBaud(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_canChooseStartingBaud(self)


    def getStartingBaudChoices(self):
        """getStartingBaudChoices(ArLaser self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArLaser_getStartingBaudChoices(self)


    def getStartingBaudChoicesString(self):
        """getStartingBaudChoicesString(ArLaser self) -> char const *"""
        return _AriaPy.ArLaser_getStartingBaudChoicesString(self)


    def chooseStartingBaud(self, reflectorBits):
        """chooseStartingBaud(ArLaser self, char const * reflectorBits) -> bool"""
        return _AriaPy.ArLaser_chooseStartingBaud(self, reflectorBits)


    def getStartingBaudChoice(self):
        """getStartingBaudChoice(ArLaser self) -> char const *"""
        return _AriaPy.ArLaser_getStartingBaudChoice(self)


    def canChooseAutoBaud(self):
        """canChooseAutoBaud(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_canChooseAutoBaud(self)


    def getAutoBaudChoices(self):
        """getAutoBaudChoices(ArLaser self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArLaser_getAutoBaudChoices(self)


    def getAutoBaudChoicesString(self):
        """getAutoBaudChoicesString(ArLaser self) -> char const *"""
        return _AriaPy.ArLaser_getAutoBaudChoicesString(self)


    def chooseAutoBaud(self, reflectorBits):
        """chooseAutoBaud(ArLaser self, char const * reflectorBits) -> bool"""
        return _AriaPy.ArLaser_chooseAutoBaud(self, reflectorBits)


    def getAutoBaudChoice(self):
        """getAutoBaudChoice(ArLaser self) -> char const *"""
        return _AriaPy.ArLaser_getAutoBaudChoice(self)


    def addConnectCB(self, functor, position=50):
        """
        addConnectCB(ArLaser self, ArFunctor functor, int position=50)
        addConnectCB(ArLaser self, ArFunctor functor)
        """
        return _AriaPy.ArLaser_addConnectCB(self, functor, position)


    def remConnectCB(self, functor):
        """remConnectCB(ArLaser self, ArFunctor functor)"""
        return _AriaPy.ArLaser_remConnectCB(self, functor)


    def addFailedConnectCB(self, functor, position=50):
        """
        addFailedConnectCB(ArLaser self, ArFunctor functor, int position=50)
        addFailedConnectCB(ArLaser self, ArFunctor functor)
        """
        return _AriaPy.ArLaser_addFailedConnectCB(self, functor, position)


    def remFailedConnectCB(self, functor):
        """remFailedConnectCB(ArLaser self, ArFunctor functor)"""
        return _AriaPy.ArLaser_remFailedConnectCB(self, functor)


    def addDisconnectNormallyCB(self, functor, position=50):
        """
        addDisconnectNormallyCB(ArLaser self, ArFunctor functor, int position=50)
        addDisconnectNormallyCB(ArLaser self, ArFunctor functor)
        """
        return _AriaPy.ArLaser_addDisconnectNormallyCB(self, functor, position)


    def remDisconnectNormallyCB(self, functor):
        """remDisconnectNormallyCB(ArLaser self, ArFunctor functor)"""
        return _AriaPy.ArLaser_remDisconnectNormallyCB(self, functor)


    def addDisconnectOnErrorCB(self, functor, position=50):
        """
        addDisconnectOnErrorCB(ArLaser self, ArFunctor functor, int position=50)
        addDisconnectOnErrorCB(ArLaser self, ArFunctor functor)
        """
        return _AriaPy.ArLaser_addDisconnectOnErrorCB(self, functor, position)


    def remDisconnectOnErrorCB(self, functor):
        """remDisconnectOnErrorCB(ArLaser self, ArFunctor functor)"""
        return _AriaPy.ArLaser_remDisconnectOnErrorCB(self, functor)


    def addReadingCB(self, functor, position=50):
        """
        addReadingCB(ArLaser self, ArFunctor functor, int position=50)
        addReadingCB(ArLaser self, ArFunctor functor)
        """
        return _AriaPy.ArLaser_addReadingCB(self, functor, position)


    def remReadingCB(self, functor):
        """remReadingCB(ArLaser self, ArFunctor functor)"""
        return _AriaPy.ArLaser_remReadingCB(self, functor)


    def getAbsoluteMaxRange(self):
        """getAbsoluteMaxRange(ArLaser self) -> unsigned int"""
        return _AriaPy.ArLaser_getAbsoluteMaxRange(self)


    def copyReadingCount(self, laser):
        """copyReadingCount(ArLaser self, ArLaser laser)"""
        return _AriaPy.ArLaser_copyReadingCount(self, laser)


    def setMaxRange(self, maxRange):
        """setMaxRange(ArLaser self, unsigned int maxRange)"""
        return _AriaPy.ArLaser_setMaxRange(self, maxRange)


    def setCumulativeBufferSize(self, size):
        """setCumulativeBufferSize(ArLaser self, size_t size)"""
        return _AriaPy.ArLaser_setCumulativeBufferSize(self, size)


    def laserCheckParams(self):
        """laserCheckParams(ArLaser self) -> bool"""
        return _AriaPy.ArLaser_laserCheckParams(self)


    def applyTransform(self, trans, doCumulative=True):
        """
        applyTransform(ArLaser self, ArTransform trans, bool doCumulative=True)
        applyTransform(ArLaser self, ArTransform trans)
        """
        return _AriaPy.ArLaser_applyTransform(self, trans, doCumulative)


    def useSimpleNamingForAllLasers():
        """useSimpleNamingForAllLasers()"""
        return _AriaPy.ArLaser_useSimpleNamingForAllLasers()

    useSimpleNamingForAllLasers = staticmethod(useSimpleNamingForAllLasers)
ArLaser_swigregister = _AriaPy.ArLaser_swigregister
ArLaser_swigregister(ArLaser)

def ArLaser_useSimpleNamingForAllLasers():
    """ArLaser_useSimpleNamingForAllLasers()"""
    return _AriaPy.ArLaser_useSimpleNamingForAllLasers()

class ArResolver(object):
    """Proxy of C++ ArResolver 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__ = _AriaPy.delete_ArResolver
    __del__ = lambda self: None

    def resolve(self, actions, robot, logActions=False):
        """
        resolve(ArResolver self, ArResolver::ActionMap * actions, ArRobot robot, bool logActions=False) -> ArActionDesired
        resolve(ArResolver self, ArResolver::ActionMap * actions, ArRobot robot) -> ArActionDesired
        """
        return _AriaPy.ArResolver_resolve(self, actions, robot, logActions)


    def getName(self):
        """getName(ArResolver self) -> char const *"""
        return _AriaPy.ArResolver_getName(self)


    def getDescription(self):
        """getDescription(ArResolver self) -> char const *"""
        return _AriaPy.ArResolver_getDescription(self)

ArResolver_swigregister = _AriaPy.ArResolver_swigregister
ArResolver_swigregister(ArResolver)

class ArThread(object):
    """Proxy of C++ ArThread class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    STATUS_FAILED = _AriaPy.ArThread_STATUS_FAILED
    STATUS_NORESOURCE = _AriaPy.ArThread_STATUS_NORESOURCE
    STATUS_NO_SUCH_THREAD = _AriaPy.ArThread_STATUS_NO_SUCH_THREAD
    STATUS_INVALID = _AriaPy.ArThread_STATUS_INVALID
    STATUS_JOIN_SELF = _AriaPy.ArThread_STATUS_JOIN_SELF
    STATUS_ALREADY_DETATCHED = _AriaPy.ArThread_STATUS_ALREADY_DETATCHED

    def __init__(self, *args):
        """
        __init__(ArThread self, bool blockAllSignals=True) -> ArThread
        __init__(ArThread self) -> ArThread
        __init__(ArThread self, ArThread::ThreadType thread, bool joinable, bool blockAllSignals=True) -> ArThread
        __init__(ArThread self, ArThread::ThreadType thread, bool joinable) -> ArThread
        __init__(ArThread self, ArFunctor func, bool joinable=True, bool blockAllSignals=True) -> ArThread
        __init__(ArThread self, ArFunctor func, bool joinable=True) -> ArThread
        __init__(ArThread self, ArFunctor func) -> ArThread
        """
        this = _AriaPy.new_ArThread(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArThread
    __del__ = lambda self: None

    def init():
        """init()"""
        return _AriaPy.ArThread_init()

    init = staticmethod(init)

    def _self():
        """_self() -> ArThread"""
        return _AriaPy.ArThread__self()

    _self = staticmethod(_self)

    def osSelf():
        """osSelf() -> ArThread::ThreadType"""
        return _AriaPy.ArThread_osSelf()

    osSelf = staticmethod(osSelf)

    def stopAll():
        """stopAll()"""
        return _AriaPy.ArThread_stopAll()

    stopAll = staticmethod(stopAll)

    def cancelAll():
        """cancelAll()"""
        return _AriaPy.ArThread_cancelAll()

    cancelAll = staticmethod(cancelAll)

    def joinAll():
        """joinAll()"""
        return _AriaPy.ArThread_joinAll()

    joinAll = staticmethod(joinAll)

    def shutdown():
        """shutdown()"""
        return _AriaPy.ArThread_shutdown()

    shutdown = staticmethod(shutdown)

    def yieldProcessor():
        """yieldProcessor()"""
        return _AriaPy.ArThread_yieldProcessor()

    yieldProcessor = staticmethod(yieldProcessor)

    def getLogLevel():
        """getLogLevel() -> ArLog::LogLevel"""
        return _AriaPy.ArThread_getLogLevel()

    getLogLevel = staticmethod(getLogLevel)

    def setLogLevel(level):
        """setLogLevel(ArLog::LogLevel level)"""
        return _AriaPy.ArThread_setLogLevel(level)

    setLogLevel = staticmethod(setLogLevel)

    def create(self, func, joinable=True, lowerPriority=True):
        """
        create(ArThread self, ArFunctor func, bool joinable=True, bool lowerPriority=True) -> int
        create(ArThread self, ArFunctor func, bool joinable=True) -> int
        create(ArThread self, ArFunctor func) -> int
        """
        return _AriaPy.ArThread_create(self, func, joinable, lowerPriority)


    def stopRunning(self):
        """stopRunning(ArThread self)"""
        return _AriaPy.ArThread_stopRunning(self)


    def join(self, ret=None):
        """
        join(ArThread self, void ** ret=None) -> int
        join(ArThread self) -> int
        """
        return _AriaPy.ArThread_join(self, ret)


    def detach(self):
        """detach(ArThread self) -> int"""
        return _AriaPy.ArThread_detach(self)


    def cancel(self):
        """cancel(ArThread self)"""
        return _AriaPy.ArThread_cancel(self)


    def getRunning(self):
        """getRunning(ArThread self) -> bool"""
        return _AriaPy.ArThread_getRunning(self)


    def getRunningWithLock(self):
        """getRunningWithLock(ArThread self) -> bool"""
        return _AriaPy.ArThread_getRunningWithLock(self)


    def getJoinable(self):
        """getJoinable(ArThread self) -> bool"""
        return _AriaPy.ArThread_getJoinable(self)


    def getThread(self):
        """getThread(ArThread self) -> ArThread::ThreadType const *"""
        return _AriaPy.ArThread_getThread(self)


    def getOSThread(self):
        """getOSThread(ArThread self) -> ArThread::ThreadType"""
        return _AriaPy.ArThread_getOSThread(self)


    def getFunc(self):
        """getFunc(ArThread self) -> ArFunctor"""
        return _AriaPy.ArThread_getFunc(self)


    def setRunning(self, running):
        """setRunning(ArThread self, bool running)"""
        return _AriaPy.ArThread_setRunning(self, running)


    def getBlockAllSignals(self):
        """getBlockAllSignals(ArThread self) -> bool"""
        return _AriaPy.ArThread_getBlockAllSignals(self)


    def getThreadName(self):
        """getThreadName(ArThread self) -> char const *"""
        return _AriaPy.ArThread_getThreadName(self)


    def setThreadName(self, name):
        """setThreadName(ArThread self, char const * name)"""
        return _AriaPy.ArThread_setThreadName(self, name)


    def getThreadActivity(self):
        """getThreadActivity(ArThread self) -> char const *"""
        return _AriaPy.ArThread_getThreadActivity(self)


    def threadStarted(self):
        """threadStarted(ArThread self)"""
        return _AriaPy.ArThread_threadStarted(self)


    def threadFinished(self):
        """threadFinished(ArThread self)"""
        return _AriaPy.ArThread_threadFinished(self)


    def isThreadStarted(self):
        """isThreadStarted(ArThread self) -> bool"""
        return _AriaPy.ArThread_isThreadStarted(self)


    def isThreadFinished(self):
        """isThreadFinished(ArThread self) -> bool"""
        return _AriaPy.ArThread_isThreadFinished(self)


    def logThreadInfo(self):
        """logThreadInfo(ArThread self)"""
        return _AriaPy.ArThread_logThreadInfo(self)


    def getPID(self):
        """getPID(ArThread self) -> pid_t"""
        return _AriaPy.ArThread_getPID(self)


    def getTID(self):
        """getTID(ArThread self) -> pid_t"""
        return _AriaPy.ArThread_getTID(self)


    def getThisThreadName():
        """getThisThreadName() -> char const *"""
        return _AriaPy.ArThread_getThisThreadName()

    getThisThreadName = staticmethod(getThisThreadName)

    def getThisThread():
        """getThisThread() -> ArThread::ThreadType const *"""
        return _AriaPy.ArThread_getThisThread()

    getThisThread = staticmethod(getThisThread)

    def getThisOSThread():
        """getThisOSThread() -> ArThread::ThreadType"""
        return _AriaPy.ArThread_getThisOSThread()

    getThisOSThread = staticmethod(getThisOSThread)
ArThread_swigregister = _AriaPy.ArThread_swigregister
ArThread_swigregister(ArThread)

def ArThread_init():
    """ArThread_init()"""
    return _AriaPy.ArThread_init()

def ArThread__self():
    """ArThread__self() -> ArThread"""
    return _AriaPy.ArThread__self()

def ArThread_osSelf():
    """ArThread_osSelf() -> ArThread::ThreadType"""
    return _AriaPy.ArThread_osSelf()

def ArThread_stopAll():
    """ArThread_stopAll()"""
    return _AriaPy.ArThread_stopAll()

def ArThread_cancelAll():
    """ArThread_cancelAll()"""
    return _AriaPy.ArThread_cancelAll()

def ArThread_joinAll():
    """ArThread_joinAll()"""
    return _AriaPy.ArThread_joinAll()

def ArThread_shutdown():
    """ArThread_shutdown()"""
    return _AriaPy.ArThread_shutdown()

def ArThread_yieldProcessor():
    """ArThread_yieldProcessor()"""
    return _AriaPy.ArThread_yieldProcessor()

def ArThread_getLogLevel():
    """ArThread_getLogLevel() -> ArLog::LogLevel"""
    return _AriaPy.ArThread_getLogLevel()

def ArThread_setLogLevel(level):
    """ArThread_setLogLevel(ArLog::LogLevel level)"""
    return _AriaPy.ArThread_setLogLevel(level)

def ArThread_getThisThreadName():
    """ArThread_getThisThreadName() -> char const *"""
    return _AriaPy.ArThread_getThisThreadName()

def ArThread_getThisThread():
    """ArThread_getThisThread() -> ArThread::ThreadType const *"""
    return _AriaPy.ArThread_getThisThread()

def ArThread_getThisOSThread():
    """ArThread_getThisOSThread() -> ArThread::ThreadType"""
    return _AriaPy.ArThread_getThisOSThread()

class ArFunctor(object):
    """Proxy of C++ ArFunctor 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__ = _AriaPy.delete_ArFunctor
    __del__ = lambda self: None

    def invoke(self):
        """invoke(ArFunctor self)"""
        return _AriaPy.ArFunctor_invoke(self)


    def getName(self):
        """getName(ArFunctor self) -> char const *"""
        return _AriaPy.ArFunctor_getName(self)


    def setName(self, name):
        """setName(ArFunctor self, char const * name)"""
        return _AriaPy.ArFunctor_setName(self, name)

ArFunctor_swigregister = _AriaPy.ArFunctor_swigregister
ArFunctor_swigregister(ArFunctor)

class ArRetFunctor_VoidP(ArFunctor):
    """Proxy of C++ ArRetFunctor<(p.void)> 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__ = _AriaPy.delete_ArRetFunctor_VoidP
    __del__ = lambda self: None

    def invoke(self):
        """invoke(ArRetFunctor_VoidP self)"""
        return _AriaPy.ArRetFunctor_VoidP_invoke(self)


    def invokeR(self):
        """invokeR(ArRetFunctor_VoidP self) -> void *"""
        return _AriaPy.ArRetFunctor_VoidP_invokeR(self)

ArRetFunctor_VoidP_swigregister = _AriaPy.ArRetFunctor_VoidP_swigregister
ArRetFunctor_VoidP_swigregister(ArRetFunctor_VoidP)

class ArRetFunctor_Bool(ArFunctor):
    """Proxy of C++ ArRetFunctor<(bool)> 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__ = _AriaPy.delete_ArRetFunctor_Bool
    __del__ = lambda self: None

    def invoke(self):
        """invoke(ArRetFunctor_Bool self)"""
        return _AriaPy.ArRetFunctor_Bool_invoke(self)


    def invokeR(self):
        """invokeR(ArRetFunctor_Bool self) -> bool"""
        return _AriaPy.ArRetFunctor_Bool_invokeR(self)

ArRetFunctor_Bool_swigregister = _AriaPy.ArRetFunctor_Bool_swigregister
ArRetFunctor_Bool_swigregister(ArRetFunctor_Bool)

class ArFunctor1_CString(ArFunctor):
    """Proxy of C++ ArFunctor1<(p.q(const).char)> 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__ = _AriaPy.delete_ArFunctor1_CString
    __del__ = lambda self: None

    def invoke(self, *args):
        """
        invoke(ArFunctor1_CString self)
        invoke(ArFunctor1_CString self, char const * p1)
        """
        return _AriaPy.ArFunctor1_CString_invoke(self, *args)

ArFunctor1_CString_swigregister = _AriaPy.ArFunctor1_CString_swigregister
ArFunctor1_CString_swigregister(ArFunctor1_CString)

class ArFunctor1_Int(ArFunctor):
    """Proxy of C++ ArFunctor1<(int)> 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__ = _AriaPy.delete_ArFunctor1_Int
    __del__ = lambda self: None

    def invoke(self, *args):
        """
        invoke(ArFunctor1_Int self)
        invoke(ArFunctor1_Int self, int p1)
        """
        return _AriaPy.ArFunctor1_Int_invoke(self, *args)

ArFunctor1_Int_swigregister = _AriaPy.ArFunctor1_Int_swigregister
ArFunctor1_Int_swigregister(ArFunctor1_Int)

class ArFunctor1_ArRobotPacketP(ArFunctor):
    """Proxy of C++ ArFunctor1<(p.ArRobotPacket)> 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__ = _AriaPy.delete_ArFunctor1_ArRobotPacketP
    __del__ = lambda self: None

    def invoke(self, *args):
        """
        invoke(ArFunctor1_ArRobotPacketP self)
        invoke(ArFunctor1_ArRobotPacketP self, ArRobotPacket p1)
        """
        return _AriaPy.ArFunctor1_ArRobotPacketP_invoke(self, *args)

ArFunctor1_ArRobotPacketP_swigregister = _AriaPy.ArFunctor1_ArRobotPacketP_swigregister
ArFunctor1_ArRobotPacketP_swigregister(ArFunctor1_ArRobotPacketP)

class ArRetFunctor_Int(ArFunctor):
    """Proxy of C++ ArRetFunctor<(int)> 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__ = _AriaPy.delete_ArRetFunctor_Int
    __del__ = lambda self: None

    def invoke(self):
        """invoke(ArRetFunctor_Int self)"""
        return _AriaPy.ArRetFunctor_Int_invoke(self)


    def invokeR(self):
        """invokeR(ArRetFunctor_Int self) -> int"""
        return _AriaPy.ArRetFunctor_Int_invokeR(self)

ArRetFunctor_Int_swigregister = _AriaPy.ArRetFunctor_Int_swigregister
ArRetFunctor_Int_swigregister(ArRetFunctor_Int)

class ArRetFunctor_Double(ArFunctor):
    """Proxy of C++ ArRetFunctor<(double)> 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__ = _AriaPy.delete_ArRetFunctor_Double
    __del__ = lambda self: None

    def invoke(self):
        """invoke(ArRetFunctor_Double self)"""
        return _AriaPy.ArRetFunctor_Double_invoke(self)


    def invokeR(self):
        """invokeR(ArRetFunctor_Double self) -> double"""
        return _AriaPy.ArRetFunctor_Double_invokeR(self)

ArRetFunctor_Double_swigregister = _AriaPy.ArRetFunctor_Double_swigregister
ArRetFunctor_Double_swigregister(ArRetFunctor_Double)

class ArRetFunctor_UnsignedInt(ArFunctor):
    """Proxy of C++ ArRetFunctor<(unsigned int)> 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__ = _AriaPy.delete_ArRetFunctor_UnsignedInt
    __del__ = lambda self: None

    def invoke(self):
        """invoke(ArRetFunctor_UnsignedInt self)"""
        return _AriaPy.ArRetFunctor_UnsignedInt_invoke(self)


    def invokeR(self):
        """invokeR(ArRetFunctor_UnsignedInt self) -> unsigned int"""
        return _AriaPy.ArRetFunctor_UnsignedInt_invokeR(self)

ArRetFunctor_UnsignedInt_swigregister = _AriaPy.ArRetFunctor_UnsignedInt_swigregister
ArRetFunctor_UnsignedInt_swigregister(ArRetFunctor_UnsignedInt)

class ArRetFunctor1_Double_ArPoseWithTime(ArRetFunctor_Double):
    """Proxy of C++ ArRetFunctor1<(double,ArPoseWithTime)> 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__ = _AriaPy.delete_ArRetFunctor1_Double_ArPoseWithTime
    __del__ = lambda self: None

    def invokeR(self, *args):
        """
        invokeR(ArRetFunctor1_Double_ArPoseWithTime self) -> double
        invokeR(ArRetFunctor1_Double_ArPoseWithTime self, ArPoseWithTime p1) -> double
        """
        return _AriaPy.ArRetFunctor1_Double_ArPoseWithTime_invokeR(self, *args)

ArRetFunctor1_Double_ArPoseWithTime_swigregister = _AriaPy.ArRetFunctor1_Double_ArPoseWithTime_swigregister
ArRetFunctor1_Double_ArPoseWithTime_swigregister(ArRetFunctor1_Double_ArPoseWithTime)

class ArRetFunctor1_Bool_ArRobotPacketP(ArRetFunctor_Bool):
    """Proxy of C++ ArRetFunctor1<(bool,p.ArRobotPacket)> 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__ = _AriaPy.delete_ArRetFunctor1_Bool_ArRobotPacketP
    __del__ = lambda self: None

    def invokeR(self, *args):
        """
        invokeR(ArRetFunctor1_Bool_ArRobotPacketP self) -> bool
        invokeR(ArRetFunctor1_Bool_ArRobotPacketP self, ArRobotPacket p1) -> bool
        """
        return _AriaPy.ArRetFunctor1_Bool_ArRobotPacketP_invokeR(self, *args)

ArRetFunctor1_Bool_ArRobotPacketP_swigregister = _AriaPy.ArRetFunctor1_Bool_ArRobotPacketP_swigregister
ArRetFunctor1_Bool_ArRobotPacketP_swigregister(ArRetFunctor1_Bool_ArRobotPacketP)

class ArRetFunctor1_Bool_ArgumentBuilder(ArRetFunctor_Bool):
    """Proxy of C++ ArRetFunctor1<(bool,ArArgumentBuilder)> 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__ = _AriaPy.delete_ArRetFunctor1_Bool_ArgumentBuilder
    __del__ = lambda self: None

    def invokeR(self, *args):
        """
        invokeR(ArRetFunctor1_Bool_ArgumentBuilder self) -> bool
        invokeR(ArRetFunctor1_Bool_ArgumentBuilder self, ArArgumentBuilder p1) -> bool
        """
        return _AriaPy.ArRetFunctor1_Bool_ArgumentBuilder_invokeR(self, *args)

ArRetFunctor1_Bool_ArgumentBuilder_swigregister = _AriaPy.ArRetFunctor1_Bool_ArgumentBuilder_swigregister
ArRetFunctor1_Bool_ArgumentBuilder_swigregister(ArRetFunctor1_Bool_ArgumentBuilder)

class ArRetFunctor1_Bool_ArgumentBuilderP(ArRetFunctor_Bool):
    """Proxy of C++ ArRetFunctor1<(bool,p.ArArgumentBuilder)> 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__ = _AriaPy.delete_ArRetFunctor1_Bool_ArgumentBuilderP
    __del__ = lambda self: None

    def invokeR(self, *args):
        """
        invokeR(ArRetFunctor1_Bool_ArgumentBuilderP self) -> bool
        invokeR(ArRetFunctor1_Bool_ArgumentBuilderP self, ArArgumentBuilder p1) -> bool
        """
        return _AriaPy.ArRetFunctor1_Bool_ArgumentBuilderP_invokeR(self, *args)

ArRetFunctor1_Bool_ArgumentBuilderP_swigregister = _AriaPy.ArRetFunctor1_Bool_ArgumentBuilderP_swigregister
ArRetFunctor1_Bool_ArgumentBuilderP_swigregister(ArRetFunctor1_Bool_ArgumentBuilderP)

class ArRetFunctor1_VoidP_VoidP(ArRetFunctor_VoidP):
    """Proxy of C++ ArRetFunctor1<(p.void,p.void)> 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__ = _AriaPy.delete_ArRetFunctor1_VoidP_VoidP
    __del__ = lambda self: None

    def invokeR(self, *args):
        """
        invokeR(ArRetFunctor1_VoidP_VoidP self) -> void *
        invokeR(ArRetFunctor1_VoidP_VoidP self, void * p1) -> void *
        """
        return _AriaPy.ArRetFunctor1_VoidP_VoidP_invokeR(self, *args)

ArRetFunctor1_VoidP_VoidP_swigregister = _AriaPy.ArRetFunctor1_VoidP_VoidP_swigregister
ArRetFunctor1_VoidP_VoidP_swigregister(ArRetFunctor1_VoidP_VoidP)

class ArACTSBlob(object):
    """Proxy of C++ ArACTSBlob 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):
        """__init__(ArACTSBlob self) -> ArACTSBlob"""
        this = _AriaPy.new_ArACTSBlob()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArACTSBlob
    __del__ = lambda self: None

    def getArea(self):
        """getArea(ArACTSBlob self) -> int"""
        return _AriaPy.ArACTSBlob_getArea(self)


    def getXCG(self):
        """getXCG(ArACTSBlob self) -> int"""
        return _AriaPy.ArACTSBlob_getXCG(self)


    def getYCG(self):
        """getYCG(ArACTSBlob self) -> int"""
        return _AriaPy.ArACTSBlob_getYCG(self)


    def getLeft(self):
        """getLeft(ArACTSBlob self) -> int"""
        return _AriaPy.ArACTSBlob_getLeft(self)


    def getRight(self):
        """getRight(ArACTSBlob self) -> int"""
        return _AriaPy.ArACTSBlob_getRight(self)


    def getTop(self):
        """getTop(ArACTSBlob self) -> int"""
        return _AriaPy.ArACTSBlob_getTop(self)


    def getBottom(self):
        """getBottom(ArACTSBlob self) -> int"""
        return _AriaPy.ArACTSBlob_getBottom(self)


    def setArea(self, area):
        """setArea(ArACTSBlob self, int area)"""
        return _AriaPy.ArACTSBlob_setArea(self, area)


    def setXCG(self, xcg):
        """setXCG(ArACTSBlob self, int xcg)"""
        return _AriaPy.ArACTSBlob_setXCG(self, xcg)


    def setYCG(self, ycg):
        """setYCG(ArACTSBlob self, int ycg)"""
        return _AriaPy.ArACTSBlob_setYCG(self, ycg)


    def setLeft(self, left):
        """setLeft(ArACTSBlob self, int left)"""
        return _AriaPy.ArACTSBlob_setLeft(self, left)


    def setRight(self, right):
        """setRight(ArACTSBlob self, int right)"""
        return _AriaPy.ArACTSBlob_setRight(self, right)


    def setTop(self, top):
        """setTop(ArACTSBlob self, int top)"""
        return _AriaPy.ArACTSBlob_setTop(self, top)


    def setBottom(self, bottom):
        """setBottom(ArACTSBlob self, int bottom)"""
        return _AriaPy.ArACTSBlob_setBottom(self, bottom)


    def log(self):
        """log(ArACTSBlob self)"""
        return _AriaPy.ArACTSBlob_log(self)

ArACTSBlob_swigregister = _AriaPy.ArACTSBlob_swigregister
ArACTSBlob_swigregister(ArACTSBlob)

class ArACTS_1_2(object):
    """Proxy of C++ ArACTS_1_2 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):
        """__init__(ArACTS_1_2 self) -> ArACTS_1_2"""
        this = _AriaPy.new_ArACTS_1_2()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArACTS_1_2
    __del__ = lambda self: None

    def openPort(self, *args):
        """
        openPort(ArACTS_1_2 self, ArRobot robot, char const * host, int port=5001) -> bool
        openPort(ArACTS_1_2 self, ArRobot robot, char const * host) -> bool
        openPort(ArACTS_1_2 self, ArRobot robot) -> bool
        """
        return _AriaPy.ArACTS_1_2_openPort(self, *args)


    def closePort(self):
        """closePort(ArACTS_1_2 self) -> bool"""
        return _AriaPy.ArACTS_1_2_closePort(self)


    def isConnected(self):
        """isConnected(ArACTS_1_2 self) -> bool"""
        return _AriaPy.ArACTS_1_2_isConnected(self)


    def getRobot(self):
        """getRobot(ArACTS_1_2 self) -> ArRobot"""
        return _AriaPy.ArACTS_1_2_getRobot(self)


    def setRobot(self, robot):
        """setRobot(ArACTS_1_2 self, ArRobot robot)"""
        return _AriaPy.ArACTS_1_2_setRobot(self, robot)


    def requestPacket(self):
        """requestPacket(ArACTS_1_2 self) -> bool"""
        return _AriaPy.ArACTS_1_2_requestPacket(self)


    def requestQuit(self):
        """requestQuit(ArACTS_1_2 self) -> bool"""
        return _AriaPy.ArACTS_1_2_requestQuit(self)


    def receiveBlobInfo(self):
        """receiveBlobInfo(ArACTS_1_2 self) -> bool"""
        return _AriaPy.ArACTS_1_2_receiveBlobInfo(self)


    def getNumBlobs(self, channel):
        """getNumBlobs(ArACTS_1_2 self, int channel) -> int"""
        return _AriaPy.ArACTS_1_2_getNumBlobs(self, channel)


    def getBlob(self, channel, blobNumber, blob):
        """getBlob(ArACTS_1_2 self, int channel, int blobNumber, ArACTSBlob blob) -> bool"""
        return _AriaPy.ArACTS_1_2_getBlob(self, channel, blobNumber, blob)


    def actsHandler(self):
        """actsHandler(ArACTS_1_2 self)"""
        return _AriaPy.ArACTS_1_2_actsHandler(self)

    NUM_CHANNELS = _AriaPy.ArACTS_1_2_NUM_CHANNELS
    MAX_BLOBS = _AriaPy.ArACTS_1_2_MAX_BLOBS
    ACTS_BLOB_DATA_SIZE = _AriaPy.ArACTS_1_2_ACTS_BLOB_DATA_SIZE
    DATA_HEADER = _AriaPy.ArACTS_1_2_DATA_HEADER
    MAX_DATA = _AriaPy.ArACTS_1_2_MAX_DATA

    def invert(self, width=160, height=120):
        """
        invert(ArACTS_1_2 self, int width=160, int height=120)
        invert(ArACTS_1_2 self, int width=160)
        invert(ArACTS_1_2 self)
        """
        return _AriaPy.ArACTS_1_2_invert(self, width, height)

ArACTS_1_2_swigregister = _AriaPy.ArACTS_1_2_swigregister
ArACTS_1_2_swigregister(ArACTS_1_2)

class ArAMPTUCommands(object):
    """Proxy of C++ ArAMPTUCommands class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ABSTILT = _AriaPy.ArAMPTUCommands_ABSTILT
    RELTILTU = _AriaPy.ArAMPTUCommands_RELTILTU
    RELTILTD = _AriaPy.ArAMPTUCommands_RELTILTD
    ABSPAN = _AriaPy.ArAMPTUCommands_ABSPAN
    RELPANCW = _AriaPy.ArAMPTUCommands_RELPANCW
    RELPANCCW = _AriaPy.ArAMPTUCommands_RELPANCCW
    PANTILT = _AriaPy.ArAMPTUCommands_PANTILT
    PANTILTUCW = _AriaPy.ArAMPTUCommands_PANTILTUCW
    PANTILTDCW = _AriaPy.ArAMPTUCommands_PANTILTDCW
    PANTILTUCCW = _AriaPy.ArAMPTUCommands_PANTILTUCCW
    PANTILTDCCW = _AriaPy.ArAMPTUCommands_PANTILTDCCW
    ZOOM = _AriaPy.ArAMPTUCommands_ZOOM
    PAUSE = _AriaPy.ArAMPTUCommands_PAUSE
    CONT = _AriaPy.ArAMPTUCommands_CONT
    PURGE = _AriaPy.ArAMPTUCommands_PURGE
    STATUS = _AriaPy.ArAMPTUCommands_STATUS
    INIT = _AriaPy.ArAMPTUCommands_INIT
    RESP = _AriaPy.ArAMPTUCommands_RESP
    PANSLEW = _AriaPy.ArAMPTUCommands_PANSLEW
    TILTSLEW = _AriaPy.ArAMPTUCommands_TILTSLEW

    def __init__(self):
        """__init__(ArAMPTUCommands self) -> ArAMPTUCommands"""
        this = _AriaPy.new_ArAMPTUCommands()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArAMPTUCommands
    __del__ = lambda self: None
ArAMPTUCommands_swigregister = _AriaPy.ArAMPTUCommands_swigregister
ArAMPTUCommands_swigregister(ArAMPTUCommands)

class ArAMPTUPacket(ArBasePacket):
    """Proxy of C++ ArAMPTUPacket 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, bufferSize=30):
        """
        __init__(ArAMPTUPacket self, ArTypes::UByte2 bufferSize=30) -> ArAMPTUPacket
        __init__(ArAMPTUPacket self) -> ArAMPTUPacket
        """
        this = _AriaPy.new_ArAMPTUPacket(bufferSize)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArAMPTUPacket
    __del__ = lambda self: None

    def getUnitNumber(self):
        """getUnitNumber(ArAMPTUPacket self) -> unsigned char"""
        return _AriaPy.ArAMPTUPacket_getUnitNumber(self)


    def setUnitNumber(self, unitNumber):
        """setUnitNumber(ArAMPTUPacket self, unsigned char unitNumber) -> bool"""
        return _AriaPy.ArAMPTUPacket_setUnitNumber(self, unitNumber)


    def byteToBuf(self, val):
        """byteToBuf(ArAMPTUPacket self, ArTypes::Byte val)"""
        return _AriaPy.ArAMPTUPacket_byteToBuf(self, val)


    def byte2ToBuf(self, val):
        """byte2ToBuf(ArAMPTUPacket self, ArTypes::Byte2 val)"""
        return _AriaPy.ArAMPTUPacket_byte2ToBuf(self, val)


    def finalizePacket(self):
        """finalizePacket(ArAMPTUPacket self)"""
        return _AriaPy.ArAMPTUPacket_finalizePacket(self)

ArAMPTUPacket_swigregister = _AriaPy.ArAMPTUPacket_swigregister
ArAMPTUPacket_swigregister(ArAMPTUPacket)

class ArAMPTU(ArPTZ):
    """Proxy of C++ ArAMPTU 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, robot, unitNumber=0):
        """
        __init__(ArAMPTU self, ArRobot robot, int unitNumber=0) -> ArAMPTU
        __init__(ArAMPTU self, ArRobot robot) -> ArAMPTU
        """
        this = _AriaPy.new_ArAMPTU(robot, unitNumber)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArAMPTU
    __del__ = lambda self: None

    def init(self):
        """init(ArAMPTU self) -> bool"""
        return _AriaPy.ArAMPTU_init(self)


    def getTypeName(self):
        """getTypeName(ArAMPTU self) -> char const *"""
        return _AriaPy.ArAMPTU_getTypeName(self)


    def panSlew(self, deg):
        """panSlew(ArAMPTU self, double deg) -> bool"""
        return _AriaPy.ArAMPTU_panSlew(self, deg)


    def tiltSlew(self, deg):
        """tiltSlew(ArAMPTU self, double deg) -> bool"""
        return _AriaPy.ArAMPTU_tiltSlew(self, deg)


    def canZoom(self):
        """canZoom(ArAMPTU self) -> bool"""
        return _AriaPy.ArAMPTU_canZoom(self)


    def canPanTiltSlew(self):
        """canPanTiltSlew(ArAMPTU self) -> bool"""
        return _AriaPy.ArAMPTU_canPanTiltSlew(self)


    def pause(self):
        """pause(ArAMPTU self) -> bool"""
        return _AriaPy.ArAMPTU_pause(self)


    def resume(self):
        """resume(ArAMPTU self) -> bool"""
        return _AriaPy.ArAMPTU_resume(self)


    def purge(self):
        """purge(ArAMPTU self) -> bool"""
        return _AriaPy.ArAMPTU_purge(self)


    def requestStatus(self):
        """requestStatus(ArAMPTU self) -> bool"""
        return _AriaPy.ArAMPTU_requestStatus(self)


    def getPan_i(self):
        """getPan_i(ArAMPTU self) -> double"""
        return _AriaPy.ArAMPTU_getPan_i(self)


    def getTilt_i(self):
        """getTilt_i(ArAMPTU self) -> double"""
        return _AriaPy.ArAMPTU_getTilt_i(self)

    MIN_SLEW = _AriaPy.ArAMPTU_MIN_SLEW
    MAX_TILT_SLEW = _AriaPy.ArAMPTU_MAX_TILT_SLEW
    MAX_PAN_SLEW = _AriaPy.ArAMPTU_MAX_PAN_SLEW
ArAMPTU_swigregister = _AriaPy.ArAMPTU_swigregister
ArAMPTU_swigregister(ArAMPTU)

class ArASyncTask(ArThread):
    """Proxy of C++ ArASyncTask 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__ = _AriaPy.delete_ArASyncTask
    __del__ = lambda self: None

    def runThread(self, arg):
        """runThread(ArASyncTask self, void * arg) -> void *"""
        return _AriaPy.ArASyncTask_runThread(self, arg)


    def run(self):
        """run(ArASyncTask self)"""
        return _AriaPy.ArASyncTask_run(self)


    def runAsync(self):
        """runAsync(ArASyncTask self)"""
        return _AriaPy.ArASyncTask_runAsync(self)


    def stopRunning(self):
        """stopRunning(ArASyncTask self)"""
        return _AriaPy.ArASyncTask_stopRunning(self)


    def create(self, joinable=True, lowerPriority=True):
        """
        create(ArASyncTask self, bool joinable=True, bool lowerPriority=True) -> int
        create(ArASyncTask self, bool joinable=True) -> int
        create(ArASyncTask self) -> int
        """
        return _AriaPy.ArASyncTask_create(self, joinable, lowerPriority)


    def runInThisThread(self, arg=None):
        """
        runInThisThread(ArASyncTask self, void * arg=None)
        runInThisThread(ArASyncTask self) -> void *
        """
        return _AriaPy.ArASyncTask_runInThisThread(self, arg)


    def getThreadActivity(self):
        """getThreadActivity(ArASyncTask self) -> char const *"""
        return _AriaPy.ArASyncTask_getThreadActivity(self)

ArASyncTask_swigregister = _AriaPy.ArASyncTask_swigregister
ArASyncTask_swigregister(ArASyncTask)

class ArAction(object):
    """Proxy of C++ ArAction 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__(ArAction self, char const * name, char const * description) -> ArAction
        __init__(ArAction self, char const * name) -> ArAction
        """
        if self.__class__ == ArAction:
            _self = None
        else:
            _self = self
        this = _AriaPy.new_ArAction(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArAction
    __del__ = lambda self: None

    def isActive(self):
        """isActive(ArAction self) -> bool"""
        return _AriaPy.ArAction_isActive(self)


    def activate(self):
        """activate(ArAction self)"""
        return _AriaPy.ArAction_activate(self)


    def deactivate(self):
        """deactivate(ArAction self)"""
        return _AriaPy.ArAction_deactivate(self)


    def fire(self, currentDesired):
        """fire(ArAction self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArAction_fire(self, currentDesired)


    def setRobot(self, robot):
        """setRobot(ArAction self, ArRobot robot)"""
        return _AriaPy.ArAction_setRobot(self, robot)


    def getNumArgs(self):
        """getNumArgs(ArAction self) -> int"""
        return _AriaPy.ArAction_getNumArgs(self)


    def getArg(self, number):
        """getArg(ArAction self, int number) -> ArArg"""
        return _AriaPy.ArAction_getArg(self, number)


    def getName(self):
        """getName(ArAction self) -> char const *"""
        return _AriaPy.ArAction_getName(self)


    def getDescription(self):
        """getDescription(ArAction self) -> char const *"""
        return _AriaPy.ArAction_getDescription(self)


    def getDesired(self, *args):
        """
        getDesired(ArAction self) -> ArActionDesired
        getDesired(ArAction self) -> ArActionDesired
        """
        return _AriaPy.ArAction_getDesired(self, *args)


    def log(self, verbose=True):
        """
        log(ArAction self, bool verbose=True)
        log(ArAction self)
        """
        return _AriaPy.ArAction_log(self, verbose)


    def getRobot(self):
        """getRobot(ArAction self) -> ArRobot"""
        return _AriaPy.ArAction_getRobot(self)


    def setDefaultActivationState(defaultActivationState):
        """setDefaultActivationState(bool defaultActivationState)"""
        return _AriaPy.ArAction_setDefaultActivationState(defaultActivationState)

    setDefaultActivationState = staticmethod(setDefaultActivationState)

    def getDefaultActivationState():
        """getDefaultActivationState() -> bool"""
        return _AriaPy.ArAction_getDefaultActivationState()

    getDefaultActivationState = staticmethod(getDefaultActivationState)

    def setActionRobot(self, robot):
        """setActionRobot(ArAction self, ArRobot robot)"""
        return _AriaPy.ArAction_setActionRobot(self, robot)

    def __disown__(self):
        self.this.disown()
        _AriaPy.disown_ArAction(self)
        return weakref_proxy(self)
ArAction_swigregister = _AriaPy.ArAction_swigregister
ArAction_swigregister(ArAction)

def ArAction_setDefaultActivationState(defaultActivationState):
    """ArAction_setDefaultActivationState(bool defaultActivationState)"""
    return _AriaPy.ArAction_setDefaultActivationState(defaultActivationState)

def ArAction_getDefaultActivationState():
    """ArAction_getDefaultActivationState() -> bool"""
    return _AriaPy.ArAction_getDefaultActivationState()

class ArActionAvoidFront(ArAction):
    """Proxy of C++ ArActionAvoidFront 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__(ArActionAvoidFront self, char const * name, double obstacleDistance=450, double avoidVelocity=200, double turnAmount=15, bool useTableIRIfAvail=True) -> ArActionAvoidFront
        __init__(ArActionAvoidFront self, char const * name, double obstacleDistance=450, double avoidVelocity=200, double turnAmount=15) -> ArActionAvoidFront
        __init__(ArActionAvoidFront self, char const * name, double obstacleDistance=450, double avoidVelocity=200) -> ArActionAvoidFront
        __init__(ArActionAvoidFront self, char const * name, double obstacleDistance=450) -> ArActionAvoidFront
        __init__(ArActionAvoidFront self, char const * name) -> ArActionAvoidFront
        __init__(ArActionAvoidFront self) -> ArActionAvoidFront
        """
        this = _AriaPy.new_ArActionAvoidFront(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionAvoidFront
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionAvoidFront self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionAvoidFront_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionAvoidFront self) -> ArActionDesired"""
        return _AriaPy.ArActionAvoidFront_getDesired(self)

ArActionAvoidFront_swigregister = _AriaPy.ArActionAvoidFront_swigregister
ArActionAvoidFront_swigregister(ArActionAvoidFront)

class ArActionAvoidSide(ArAction):
    """Proxy of C++ ArActionAvoidSide 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__(ArActionAvoidSide self, char const * name, double obstacleDistance=300, double turnAmount=5) -> ArActionAvoidSide
        __init__(ArActionAvoidSide self, char const * name, double obstacleDistance=300) -> ArActionAvoidSide
        __init__(ArActionAvoidSide self, char const * name) -> ArActionAvoidSide
        __init__(ArActionAvoidSide self) -> ArActionAvoidSide
        """
        this = _AriaPy.new_ArActionAvoidSide(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionAvoidSide
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionAvoidSide self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionAvoidSide_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionAvoidSide self) -> ArActionDesired"""
        return _AriaPy.ArActionAvoidSide_getDesired(self)

ArActionAvoidSide_swigregister = _AriaPy.ArActionAvoidSide_swigregister
ArActionAvoidSide_swigregister(ArActionAvoidSide)

class ArActionBumpers(ArAction):
    """Proxy of C++ ArActionBumpers 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__(ArActionBumpers self, char const * name, double backOffSpeed=100, int backOffTime=3000, int turnTime=3000, bool setMaximums=False) -> ArActionBumpers
        __init__(ArActionBumpers self, char const * name, double backOffSpeed=100, int backOffTime=3000, int turnTime=3000) -> ArActionBumpers
        __init__(ArActionBumpers self, char const * name, double backOffSpeed=100, int backOffTime=3000) -> ArActionBumpers
        __init__(ArActionBumpers self, char const * name, double backOffSpeed=100) -> ArActionBumpers
        __init__(ArActionBumpers self, char const * name) -> ArActionBumpers
        __init__(ArActionBumpers self) -> ArActionBumpers
        """
        this = _AriaPy.new_ArActionBumpers(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionBumpers
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionBumpers self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionBumpers_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionBumpers self) -> ArActionDesired"""
        return _AriaPy.ArActionBumpers_getDesired(self)


    def findDegreesToTurn(self, bumpValue, whichBumper):
        """findDegreesToTurn(ArActionBumpers self, int bumpValue, int whichBumper) -> double"""
        return _AriaPy.ArActionBumpers_findDegreesToTurn(self, bumpValue, whichBumper)


    def activate(self):
        """activate(ArActionBumpers self)"""
        return _AriaPy.ArActionBumpers_activate(self)

ArActionBumpers_swigregister = _AriaPy.ArActionBumpers_swigregister
ArActionBumpers_swigregister(ArActionBumpers)

class ArActionColorFollow(ArAction):
    """Proxy of C++ ArActionColorFollow 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, name, acts, camera, speed=200, width=160, height=120):
        """
        __init__(ArActionColorFollow self, char const * name, ArACTS_1_2 acts, ArPTZ camera, double speed=200, int width=160, int height=120) -> ArActionColorFollow
        __init__(ArActionColorFollow self, char const * name, ArACTS_1_2 acts, ArPTZ camera, double speed=200, int width=160) -> ArActionColorFollow
        __init__(ArActionColorFollow self, char const * name, ArACTS_1_2 acts, ArPTZ camera, double speed=200) -> ArActionColorFollow
        __init__(ArActionColorFollow self, char const * name, ArACTS_1_2 acts, ArPTZ camera) -> ArActionColorFollow
        """
        this = _AriaPy.new_ArActionColorFollow(name, acts, camera, speed, width, height)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionColorFollow
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionColorFollow self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionColorFollow_fire(self, currentDesired)


    def setChannel(self, channel):
        """setChannel(ArActionColorFollow self, int channel) -> bool"""
        return _AriaPy.ArActionColorFollow_setChannel(self, channel)


    def setCamera(self, camera):
        """setCamera(ArActionColorFollow self, ArPTZ camera)"""
        return _AriaPy.ArActionColorFollow_setCamera(self, camera)


    def setAcquire(self, acquire):
        """setAcquire(ArActionColorFollow self, bool acquire)"""
        return _AriaPy.ArActionColorFollow_setAcquire(self, acquire)


    def stopMovement(self):
        """stopMovement(ArActionColorFollow self)"""
        return _AriaPy.ArActionColorFollow_stopMovement(self)


    def startMovement(self):
        """startMovement(ArActionColorFollow self)"""
        return _AriaPy.ArActionColorFollow_startMovement(self)


    def getChannel(self):
        """getChannel(ArActionColorFollow self) -> int"""
        return _AriaPy.ArActionColorFollow_getChannel(self)


    def getAcquire(self):
        """getAcquire(ArActionColorFollow self) -> bool"""
        return _AriaPy.ArActionColorFollow_getAcquire(self)


    def getMovement(self):
        """getMovement(ArActionColorFollow self) -> bool"""
        return _AriaPy.ArActionColorFollow_getMovement(self)


    def getBlob(self):
        """getBlob(ArActionColorFollow self) -> bool"""
        return _AriaPy.ArActionColorFollow_getBlob(self)

    NO_TARGET = _AriaPy.ArActionColorFollow_NO_TARGET
    TARGET = _AriaPy.ArActionColorFollow_TARGET
    FOLLOWING = _AriaPy.ArActionColorFollow_FOLLOWING
    ACQUIRING = _AriaPy.ArActionColorFollow_ACQUIRING
    STOPPED = _AriaPy.ArActionColorFollow_STOPPED
    LEFT = _AriaPy.ArActionColorFollow_LEFT
    RIGHT = _AriaPy.ArActionColorFollow_RIGHT
    CENTER = _AriaPy.ArActionColorFollow_CENTER

    def getDesired(self):
        """getDesired(ArActionColorFollow self) -> ArActionDesired"""
        return _AriaPy.ArActionColorFollow_getDesired(self)

ArActionColorFollow_swigregister = _AriaPy.ArActionColorFollow_swigregister
ArActionColorFollow_swigregister(ArActionColorFollow)

class ArActionConstantVelocity(ArAction):
    """Proxy of C++ ArActionConstantVelocity 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__(ArActionConstantVelocity self, char const * name, double velocity=400) -> ArActionConstantVelocity
        __init__(ArActionConstantVelocity self, char const * name) -> ArActionConstantVelocity
        __init__(ArActionConstantVelocity self) -> ArActionConstantVelocity
        """
        this = _AriaPy.new_ArActionConstantVelocity(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionConstantVelocity
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionConstantVelocity self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionConstantVelocity_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionConstantVelocity self) -> ArActionDesired"""
        return _AriaPy.ArActionConstantVelocity_getDesired(self)

ArActionConstantVelocity_swigregister = _AriaPy.ArActionConstantVelocity_swigregister
ArActionConstantVelocity_swigregister(ArActionConstantVelocity)

class ArActionDeceleratingLimiter(ArAction):
    """Proxy of C++ ArActionDeceleratingLimiter class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    FORWARDS = _AriaPy.ArActionDeceleratingLimiter_FORWARDS
    BACKWARDS = _AriaPy.ArActionDeceleratingLimiter_BACKWARDS
    LATERAL_LEFT = _AriaPy.ArActionDeceleratingLimiter_LATERAL_LEFT
    LATERAL_RIGHT = _AriaPy.ArActionDeceleratingLimiter_LATERAL_RIGHT

    def __init__(self, *args):
        """
        __init__(ArActionDeceleratingLimiter self, char const * name, ArActionDeceleratingLimiter::LimiterType type) -> ArActionDeceleratingLimiter
        __init__(ArActionDeceleratingLimiter self, char const * name) -> ArActionDeceleratingLimiter
        __init__(ArActionDeceleratingLimiter self) -> ArActionDeceleratingLimiter
        """
        this = _AriaPy.new_ArActionDeceleratingLimiter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionDeceleratingLimiter
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionDeceleratingLimiter self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionDeceleratingLimiter_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionDeceleratingLimiter self) -> ArActionDesired"""
        return _AriaPy.ArActionDeceleratingLimiter_getDesired(self)


    def setParameters(self, clearance=100, sideClearanceAtSlowSpeed=50, paddingAtSlowSpeed=50, slowSpeed=200, sideClearanceAtFastSpeed=400, paddingAtFastSpeed=300, fastSpeed=1000, preferredDecel=600, useEStop=False, maxEmergencyDecel=0):
        """
        setParameters(ArActionDeceleratingLimiter self, double clearance=100, double sideClearanceAtSlowSpeed=50, double paddingAtSlowSpeed=50, double slowSpeed=200, double sideClearanceAtFastSpeed=400, double paddingAtFastSpeed=300, double fastSpeed=1000, double preferredDecel=600, bool useEStop=False, double maxEmergencyDecel=0)
        setParameters(ArActionDeceleratingLimiter self, double clearance=100, double sideClearanceAtSlowSpeed=50, double paddingAtSlowSpeed=50, double slowSpeed=200, double sideClearanceAtFastSpeed=400, double paddingAtFastSpeed=300, double fastSpeed=1000, double preferredDecel=600, bool useEStop=False)
        setParameters(ArActionDeceleratingLimiter self, double clearance=100, double sideClearanceAtSlowSpeed=50, double paddingAtSlowSpeed=50, double slowSpeed=200, double sideClearanceAtFastSpeed=400, double paddingAtFastSpeed=300, double fastSpeed=1000, double preferredDecel=600)
        setParameters(ArActionDeceleratingLimiter self, double clearance=100, double sideClearanceAtSlowSpeed=50, double paddingAtSlowSpeed=50, double slowSpeed=200, double sideClearanceAtFastSpeed=400, double paddingAtFastSpeed=300, double fastSpeed=1000)
        setParameters(ArActionDeceleratingLimiter self, double clearance=100, double sideClearanceAtSlowSpeed=50, double paddingAtSlowSpeed=50, double slowSpeed=200, double sideClearanceAtFastSpeed=400, double paddingAtFastSpeed=300)
        setParameters(ArActionDeceleratingLimiter self, double clearance=100, double sideClearanceAtSlowSpeed=50, double paddingAtSlowSpeed=50, double slowSpeed=200, double sideClearanceAtFastSpeed=400)
        setParameters(ArActionDeceleratingLimiter self, double clearance=100, double sideClearanceAtSlowSpeed=50, double paddingAtSlowSpeed=50, double slowSpeed=200)
        setParameters(ArActionDeceleratingLimiter self, double clearance=100, double sideClearanceAtSlowSpeed=50, double paddingAtSlowSpeed=50)
        setParameters(ArActionDeceleratingLimiter self, double clearance=100, double sideClearanceAtSlowSpeed=50)
        setParameters(ArActionDeceleratingLimiter self, double clearance=100)
        setParameters(ArActionDeceleratingLimiter self)
        """
        return _AriaPy.ArActionDeceleratingLimiter_setParameters(self, clearance, sideClearanceAtSlowSpeed, paddingAtSlowSpeed, slowSpeed, sideClearanceAtFastSpeed, paddingAtFastSpeed, fastSpeed, preferredDecel, useEStop, maxEmergencyDecel)


    def getType(self):
        """getType(ArActionDeceleratingLimiter self) -> ArActionDeceleratingLimiter::LimiterType"""
        return _AriaPy.ArActionDeceleratingLimiter_getType(self)


    def setType(self, type):
        """setType(ArActionDeceleratingLimiter self, ArActionDeceleratingLimiter::LimiterType type)"""
        return _AriaPy.ArActionDeceleratingLimiter_setType(self, type)


    def addToConfig(self, config, section, prefix=None):
        """
        addToConfig(ArActionDeceleratingLimiter self, ArConfig config, char const * section, char const * prefix=None)
        addToConfig(ArActionDeceleratingLimiter self, ArConfig config, char const * section)
        """
        return _AriaPy.ArActionDeceleratingLimiter_addToConfig(self, config, section, prefix)


    def getUseLocationDependentDevices(self):
        """getUseLocationDependentDevices(ArActionDeceleratingLimiter self) -> bool"""
        return _AriaPy.ArActionDeceleratingLimiter_getUseLocationDependentDevices(self)


    def setUseLocationDependentDevices(self, useLocationDependentDevices):
        """setUseLocationDependentDevices(ArActionDeceleratingLimiter self, bool useLocationDependentDevices)"""
        return _AriaPy.ArActionDeceleratingLimiter_setUseLocationDependentDevices(self, useLocationDependentDevices)


    def setStopRotationToo(self, stopRotationToo):
        """setStopRotationToo(ArActionDeceleratingLimiter self, bool stopRotationToo)"""
        return _AriaPy.ArActionDeceleratingLimiter_setStopRotationToo(self, stopRotationToo)

ArActionDeceleratingLimiter_swigregister = _AriaPy.ArActionDeceleratingLimiter_swigregister
ArActionDeceleratingLimiter_swigregister(ArActionDeceleratingLimiter)

class ArActionDesiredChannel(object):
    """Proxy of C++ ArActionDesiredChannel 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):
        """__init__(ArActionDesiredChannel self) -> ArActionDesiredChannel"""
        this = _AriaPy.new_ArActionDesiredChannel()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionDesiredChannel
    __del__ = lambda self: None

    def setOverrideDoesLessThan(self, overrideDoesLessThan):
        """setOverrideDoesLessThan(ArActionDesiredChannel self, bool overrideDoesLessThan)"""
        return _AriaPy.ArActionDesiredChannel_setOverrideDoesLessThan(self, overrideDoesLessThan)


    def setDesired(self, desired, desiredStrength, allowOverride=False):
        """
        setDesired(ArActionDesiredChannel self, double desired, double desiredStrength, bool allowOverride=False)
        setDesired(ArActionDesiredChannel self, double desired, double desiredStrength)
        """
        return _AriaPy.ArActionDesiredChannel_setDesired(self, desired, desiredStrength, allowOverride)


    def getDesired(self):
        """getDesired(ArActionDesiredChannel self) -> double"""
        return _AriaPy.ArActionDesiredChannel_getDesired(self)


    def getStrength(self):
        """getStrength(ArActionDesiredChannel self) -> double"""
        return _AriaPy.ArActionDesiredChannel_getStrength(self)


    def getAllowOverride(self):
        """getAllowOverride(ArActionDesiredChannel self) -> double"""
        return _AriaPy.ArActionDesiredChannel_getAllowOverride(self)


    def reset(self):
        """reset(ArActionDesiredChannel self)"""
        return _AriaPy.ArActionDesiredChannel_reset(self)


    def merge(self, desiredChannel):
        """merge(ArActionDesiredChannel self, ArActionDesiredChannel desiredChannel)"""
        return _AriaPy.ArActionDesiredChannel_merge(self, desiredChannel)


    def startAverage(self):
        """startAverage(ArActionDesiredChannel self)"""
        return _AriaPy.ArActionDesiredChannel_startAverage(self)


    def addAverage(self, desiredChannel):
        """addAverage(ArActionDesiredChannel self, ArActionDesiredChannel desiredChannel)"""
        return _AriaPy.ArActionDesiredChannel_addAverage(self, desiredChannel)


    def endAverage(self):
        """endAverage(ArActionDesiredChannel self)"""
        return _AriaPy.ArActionDesiredChannel_endAverage(self)


    def checkLowerBound(self, actionName, typeName, lowerBound):
        """checkLowerBound(ArActionDesiredChannel self, char const * actionName, char const * typeName, int lowerBound)"""
        return _AriaPy.ArActionDesiredChannel_checkLowerBound(self, actionName, typeName, lowerBound)


    def checkUpperBound(self, actionName, typeName, upperBound):
        """checkUpperBound(ArActionDesiredChannel self, char const * actionName, char const * typeName, int upperBound)"""
        return _AriaPy.ArActionDesiredChannel_checkUpperBound(self, actionName, typeName, upperBound)

ArActionDesiredChannel_swigregister = _AriaPy.ArActionDesiredChannel_swigregister
ArActionDesiredChannel_swigregister(ArActionDesiredChannel)
ArActionDesiredChannel.NO_STRENGTH = _AriaPy.cvar.ArActionDesiredChannel_NO_STRENGTH
ArActionDesiredChannel.MIN_STRENGTH = _AriaPy.cvar.ArActionDesiredChannel_MIN_STRENGTH
ArActionDesiredChannel.MAX_STRENGTH = _AriaPy.cvar.ArActionDesiredChannel_MAX_STRENGTH

class ArActionDesired(object):
    """Proxy of C++ ArActionDesired 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):
        """__init__(ArActionDesired self) -> ArActionDesired"""
        this = _AriaPy.new_ArActionDesired()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionDesired
    __del__ = lambda self: None

    def setVel(self, *args):
        """
        setVel(ArActionDesired self, double vel, double strength)
        setVel(ArActionDesired self, double vel)
        """
        return _AriaPy.ArActionDesired_setVel(self, *args)


    def setDeltaHeading(self, *args):
        """
        setDeltaHeading(ArActionDesired self, double deltaHeading, double strength)
        setDeltaHeading(ArActionDesired self, double deltaHeading)
        """
        return _AriaPy.ArActionDesired_setDeltaHeading(self, *args)


    def setHeading(self, *args):
        """
        setHeading(ArActionDesired self, double heading, double strength)
        setHeading(ArActionDesired self, double heading)
        """
        return _AriaPy.ArActionDesired_setHeading(self, *args)


    def setRotVel(self, *args):
        """
        setRotVel(ArActionDesired self, double rotVel, double strength)
        setRotVel(ArActionDesired self, double rotVel)
        """
        return _AriaPy.ArActionDesired_setRotVel(self, *args)


    def setMaxVel(self, *args):
        """
        setMaxVel(ArActionDesired self, double maxVel, double strength, bool useSlowest=True)
        setMaxVel(ArActionDesired self, double maxVel, double strength)
        setMaxVel(ArActionDesired self, double maxVel)
        """
        return _AriaPy.ArActionDesired_setMaxVel(self, *args)


    def setMaxNegVel(self, *args):
        """
        setMaxNegVel(ArActionDesired self, double maxVel, double strength, bool useSlowest=True)
        setMaxNegVel(ArActionDesired self, double maxVel, double strength)
        setMaxNegVel(ArActionDesired self, double maxVel)
        """
        return _AriaPy.ArActionDesired_setMaxNegVel(self, *args)


    def setTransAccel(self, *args):
        """
        setTransAccel(ArActionDesired self, double transAccel, double strength, bool useSlowest=True)
        setTransAccel(ArActionDesired self, double transAccel, double strength)
        setTransAccel(ArActionDesired self, double transAccel)
        """
        return _AriaPy.ArActionDesired_setTransAccel(self, *args)


    def setTransDecel(self, *args):
        """
        setTransDecel(ArActionDesired self, double transDecel, double strength, bool useFastestDecel=True)
        setTransDecel(ArActionDesired self, double transDecel, double strength)
        setTransDecel(ArActionDesired self, double transDecel)
        """
        return _AriaPy.ArActionDesired_setTransDecel(self, *args)


    def setMaxRotVel(self, *args):
        """
        setMaxRotVel(ArActionDesired self, double maxVel, double strength, bool useSlowest=True)
        setMaxRotVel(ArActionDesired self, double maxVel, double strength)
        setMaxRotVel(ArActionDesired self, double maxVel)
        """
        return _AriaPy.ArActionDesired_setMaxRotVel(self, *args)


    def setMaxRotVelPos(self, *args):
        """
        setMaxRotVelPos(ArActionDesired self, double maxVel, double strength, bool useSlowest=True)
        setMaxRotVelPos(ArActionDesired self, double maxVel, double strength)
        setMaxRotVelPos(ArActionDesired self, double maxVel)
        """
        return _AriaPy.ArActionDesired_setMaxRotVelPos(self, *args)


    def setMaxRotVelNeg(self, *args):
        """
        setMaxRotVelNeg(ArActionDesired self, double maxVel, double strength, bool useSlowest=True)
        setMaxRotVelNeg(ArActionDesired self, double maxVel, double strength)
        setMaxRotVelNeg(ArActionDesired self, double maxVel)
        """
        return _AriaPy.ArActionDesired_setMaxRotVelNeg(self, *args)


    def setRotAccel(self, *args):
        """
        setRotAccel(ArActionDesired self, double rotAccel, double strength, bool useSlowest=True)
        setRotAccel(ArActionDesired self, double rotAccel, double strength)
        setRotAccel(ArActionDesired self, double rotAccel)
        """
        return _AriaPy.ArActionDesired_setRotAccel(self, *args)


    def setRotDecel(self, *args):
        """
        setRotDecel(ArActionDesired self, double rotDecel, double strength, bool useFastest=True)
        setRotDecel(ArActionDesired self, double rotDecel, double strength)
        setRotDecel(ArActionDesired self, double rotDecel)
        """
        return _AriaPy.ArActionDesired_setRotDecel(self, *args)


    def setLeftLatVel(self, *args):
        """
        setLeftLatVel(ArActionDesired self, double latVel, double strength)
        setLeftLatVel(ArActionDesired self, double latVel)
        """
        return _AriaPy.ArActionDesired_setLeftLatVel(self, *args)


    def setRightLatVel(self, *args):
        """
        setRightLatVel(ArActionDesired self, double latVel, double strength)
        setRightLatVel(ArActionDesired self, double latVel)
        """
        return _AriaPy.ArActionDesired_setRightLatVel(self, *args)


    def setMaxLeftLatVel(self, *args):
        """
        setMaxLeftLatVel(ArActionDesired self, double maxVel, double strength, bool useSlowest=True)
        setMaxLeftLatVel(ArActionDesired self, double maxVel, double strength)
        setMaxLeftLatVel(ArActionDesired self, double maxVel)
        """
        return _AriaPy.ArActionDesired_setMaxLeftLatVel(self, *args)


    def setMaxRightLatVel(self, *args):
        """
        setMaxRightLatVel(ArActionDesired self, double maxVel, double strength, bool useSlowest=True)
        setMaxRightLatVel(ArActionDesired self, double maxVel, double strength)
        setMaxRightLatVel(ArActionDesired self, double maxVel)
        """
        return _AriaPy.ArActionDesired_setMaxRightLatVel(self, *args)


    def setLatAccel(self, *args):
        """
        setLatAccel(ArActionDesired self, double latAccel, double strength, bool useSlowest=True)
        setLatAccel(ArActionDesired self, double latAccel, double strength)
        setLatAccel(ArActionDesired self, double latAccel)
        """
        return _AriaPy.ArActionDesired_setLatAccel(self, *args)


    def setLatDecel(self, *args):
        """
        setLatDecel(ArActionDesired self, double latDecel, double strength, bool useFastest=True)
        setLatDecel(ArActionDesired self, double latDecel, double strength)
        setLatDecel(ArActionDesired self, double latDecel)
        """
        return _AriaPy.ArActionDesired_setLatDecel(self, *args)


    def reset(self):
        """reset(ArActionDesired self)"""
        return _AriaPy.ArActionDesired_reset(self)


    def getVel(self):
        """getVel(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getVel(self)


    def getVelStrength(self):
        """getVelStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getVelStrength(self)


    def getHeading(self):
        """getHeading(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getHeading(self)


    def getHeadingStrength(self):
        """getHeadingStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getHeadingStrength(self)


    def getDeltaHeading(self):
        """getDeltaHeading(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getDeltaHeading(self)


    def getDeltaHeadingStrength(self):
        """getDeltaHeadingStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getDeltaHeadingStrength(self)


    def getRotVel(self):
        """getRotVel(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getRotVel(self)


    def getRotVelStrength(self):
        """getRotVelStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getRotVelStrength(self)


    def getMaxVel(self):
        """getMaxVel(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxVel(self)


    def getMaxVelStrength(self):
        """getMaxVelStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxVelStrength(self)


    def getMaxVelSlowestUsed(self):
        """getMaxVelSlowestUsed(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxVelSlowestUsed(self)


    def getMaxNegVel(self):
        """getMaxNegVel(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxNegVel(self)


    def getMaxNegVelStrength(self):
        """getMaxNegVelStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxNegVelStrength(self)


    def getMaxNegVelSlowestUsed(self):
        """getMaxNegVelSlowestUsed(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxNegVelSlowestUsed(self)


    def getTransAccel(self):
        """getTransAccel(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getTransAccel(self)


    def getTransAccelStrength(self):
        """getTransAccelStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getTransAccelStrength(self)


    def getTransAccelSlowestUsed(self):
        """getTransAccelSlowestUsed(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getTransAccelSlowestUsed(self)


    def getTransDecel(self):
        """getTransDecel(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getTransDecel(self)


    def getTransDecelStrength(self):
        """getTransDecelStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getTransDecelStrength(self)


    def getTransDecelFastestUsed(self):
        """getTransDecelFastestUsed(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getTransDecelFastestUsed(self)


    def getMaxRotVel(self):
        """getMaxRotVel(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxRotVel(self)


    def getMaxRotVelStrength(self):
        """getMaxRotVelStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxRotVelStrength(self)


    def getMaxRotVelSlowestUsed(self):
        """getMaxRotVelSlowestUsed(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxRotVelSlowestUsed(self)


    def getMaxRotVelPos(self):
        """getMaxRotVelPos(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxRotVelPos(self)


    def getMaxRotVelPosStrength(self):
        """getMaxRotVelPosStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxRotVelPosStrength(self)


    def getMaxRotVelPosSlowestUsed(self):
        """getMaxRotVelPosSlowestUsed(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxRotVelPosSlowestUsed(self)


    def getMaxRotVelNeg(self):
        """getMaxRotVelNeg(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxRotVelNeg(self)


    def getMaxRotVelNegStrength(self):
        """getMaxRotVelNegStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxRotVelNegStrength(self)


    def getMaxRotVelNegSlowestUsed(self):
        """getMaxRotVelNegSlowestUsed(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxRotVelNegSlowestUsed(self)


    def getRotAccel(self):
        """getRotAccel(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getRotAccel(self)


    def getRotAccelStrength(self):
        """getRotAccelStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getRotAccelStrength(self)


    def getRotAccelSlowestUsed(self):
        """getRotAccelSlowestUsed(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getRotAccelSlowestUsed(self)


    def getRotDecel(self):
        """getRotDecel(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getRotDecel(self)


    def getRotDecelStrength(self):
        """getRotDecelStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getRotDecelStrength(self)


    def getRotDecelFastestUsed(self):
        """getRotDecelFastestUsed(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getRotDecelFastestUsed(self)


    def getLatVel(self):
        """getLatVel(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getLatVel(self)


    def getLatVelStrength(self):
        """getLatVelStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getLatVelStrength(self)


    def getMaxLeftLatVel(self):
        """getMaxLeftLatVel(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxLeftLatVel(self)


    def getMaxLeftLatVelStrength(self):
        """getMaxLeftLatVelStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxLeftLatVelStrength(self)


    def getMaxLeftLatVelSlowestUsed(self):
        """getMaxLeftLatVelSlowestUsed(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxLeftLatVelSlowestUsed(self)


    def getMaxRightLatVel(self):
        """getMaxRightLatVel(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxRightLatVel(self)


    def getMaxRightLatVelStrength(self):
        """getMaxRightLatVelStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxRightLatVelStrength(self)


    def getMaxRightLatVelSlowestUsed(self):
        """getMaxRightLatVelSlowestUsed(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getMaxRightLatVelSlowestUsed(self)


    def getLatAccel(self):
        """getLatAccel(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getLatAccel(self)


    def getLatAccelStrength(self):
        """getLatAccelStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getLatAccelStrength(self)


    def getLatAccelSlowestUsed(self):
        """getLatAccelSlowestUsed(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getLatAccelSlowestUsed(self)


    def getLatDecel(self):
        """getLatDecel(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getLatDecel(self)


    def getLatDecelStrength(self):
        """getLatDecelStrength(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getLatDecelStrength(self)


    def getLatDecelFastestUsed(self):
        """getLatDecelFastestUsed(ArActionDesired self) -> double"""
        return _AriaPy.ArActionDesired_getLatDecelFastestUsed(self)


    def merge(self, actDesired):
        """merge(ArActionDesired self, ArActionDesired actDesired)"""
        return _AriaPy.ArActionDesired_merge(self, actDesired)


    def startAverage(self):
        """startAverage(ArActionDesired self)"""
        return _AriaPy.ArActionDesired_startAverage(self)


    def addAverage(self, actDesired):
        """addAverage(ArActionDesired self, ArActionDesired actDesired)"""
        return _AriaPy.ArActionDesired_addAverage(self, actDesired)


    def endAverage(self):
        """endAverage(ArActionDesired self)"""
        return _AriaPy.ArActionDesired_endAverage(self)


    def accountForRobotHeading(self, robotHeading):
        """accountForRobotHeading(ArActionDesired self, double robotHeading)"""
        return _AriaPy.ArActionDesired_accountForRobotHeading(self, robotHeading)


    def log(self):
        """log(ArActionDesired self)"""
        return _AriaPy.ArActionDesired_log(self)


    def isAnythingDesired(self):
        """isAnythingDesired(ArActionDesired self) -> bool"""
        return _AriaPy.ArActionDesired_isAnythingDesired(self)


    def sanityCheck(self, actionName):
        """sanityCheck(ArActionDesired self, char const * actionName)"""
        return _AriaPy.ArActionDesired_sanityCheck(self, actionName)

ArActionDesired_swigregister = _AriaPy.ArActionDesired_swigregister
ArActionDesired_swigregister(ArActionDesired)
ArActionDesired.NO_STRENGTH = _AriaPy.cvar.ArActionDesired_NO_STRENGTH
ArActionDesired.MIN_STRENGTH = _AriaPy.cvar.ArActionDesired_MIN_STRENGTH
ArActionDesired.MAX_STRENGTH = _AriaPy.cvar.ArActionDesired_MAX_STRENGTH

class ArActionDriveDistance(ArAction):
    """Proxy of C++ ArActionDriveDistance 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__(ArActionDriveDistance self, char const * name, double speed=400, double deceleration=200) -> ArActionDriveDistance
        __init__(ArActionDriveDistance self, char const * name, double speed=400) -> ArActionDriveDistance
        __init__(ArActionDriveDistance self, char const * name) -> ArActionDriveDistance
        __init__(ArActionDriveDistance self) -> ArActionDriveDistance
        """
        this = _AriaPy.new_ArActionDriveDistance(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionDriveDistance
    __del__ = lambda self: None

    def haveAchievedDistance(self):
        """haveAchievedDistance(ArActionDriveDistance self) -> bool"""
        return _AriaPy.ArActionDriveDistance_haveAchievedDistance(self)


    def cancelDistance(self):
        """cancelDistance(ArActionDriveDistance self)"""
        return _AriaPy.ArActionDriveDistance_cancelDistance(self)


    def setDistance(self, distance, useEncoders=True):
        """
        setDistance(ArActionDriveDistance self, double distance, bool useEncoders=True)
        setDistance(ArActionDriveDistance self, double distance)
        """
        return _AriaPy.ArActionDriveDistance_setDistance(self, distance, useEncoders)


    def usingEncoders(self):
        """usingEncoders(ArActionDriveDistance self) -> bool"""
        return _AriaPy.ArActionDriveDistance_usingEncoders(self)


    def setSpeed(self, speed=400):
        """
        setSpeed(ArActionDriveDistance self, double speed=400)
        setSpeed(ArActionDriveDistance self)
        """
        return _AriaPy.ArActionDriveDistance_setSpeed(self, speed)


    def getSpeed(self):
        """getSpeed(ArActionDriveDistance self) -> double"""
        return _AriaPy.ArActionDriveDistance_getSpeed(self)


    def setDeceleration(self, deceleration=200):
        """
        setDeceleration(ArActionDriveDistance self, double deceleration=200)
        setDeceleration(ArActionDriveDistance self)
        """
        return _AriaPy.ArActionDriveDistance_setDeceleration(self, deceleration)


    def getDeceleration(self):
        """getDeceleration(ArActionDriveDistance self) -> double"""
        return _AriaPy.ArActionDriveDistance_getDeceleration(self)


    def setPrinting(self, printing):
        """setPrinting(ArActionDriveDistance self, bool printing)"""
        return _AriaPy.ArActionDriveDistance_setPrinting(self, printing)


    def fire(self, currentDesired):
        """fire(ArActionDriveDistance self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionDriveDistance_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionDriveDistance self) -> ArActionDesired"""
        return _AriaPy.ArActionDriveDistance_getDesired(self)

ArActionDriveDistance_swigregister = _AriaPy.ArActionDriveDistance_swigregister
ArActionDriveDistance_swigregister(ArActionDriveDistance)

class ArActionGoto(ArAction):
    """Proxy of C++ ArActionGoto 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__(ArActionGoto self, char const * name, ArPose goal, double closeDist=100, double speed=400, double speedToTurnAt=150, double turnAmount=7) -> ArActionGoto
        __init__(ArActionGoto self, char const * name, ArPose goal, double closeDist=100, double speed=400, double speedToTurnAt=150) -> ArActionGoto
        __init__(ArActionGoto self, char const * name, ArPose goal, double closeDist=100, double speed=400) -> ArActionGoto
        __init__(ArActionGoto self, char const * name, ArPose goal, double closeDist=100) -> ArActionGoto
        __init__(ArActionGoto self, char const * name, ArPose goal) -> ArActionGoto
        __init__(ArActionGoto self, char const * name) -> ArActionGoto
        __init__(ArActionGoto self) -> ArActionGoto
        """
        this = _AriaPy.new_ArActionGoto(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGoto
    __del__ = lambda self: None

    def haveAchievedGoal(self):
        """haveAchievedGoal(ArActionGoto self) -> bool"""
        return _AriaPy.ArActionGoto_haveAchievedGoal(self)


    def cancelGoal(self):
        """cancelGoal(ArActionGoto self)"""
        return _AriaPy.ArActionGoto_cancelGoal(self)


    def setGoal(self, goal):
        """setGoal(ArActionGoto self, ArPose goal)"""
        return _AriaPy.ArActionGoto_setGoal(self, goal)


    def getGoal(self):
        """getGoal(ArActionGoto self) -> ArPose"""
        return _AriaPy.ArActionGoto_getGoal(self)


    def setCloseDist(self, closeDist):
        """setCloseDist(ArActionGoto self, double closeDist)"""
        return _AriaPy.ArActionGoto_setCloseDist(self, closeDist)


    def getCloseDist(self):
        """getCloseDist(ArActionGoto self) -> double"""
        return _AriaPy.ArActionGoto_getCloseDist(self)


    def setSpeed(self, speed):
        """setSpeed(ArActionGoto self, double speed)"""
        return _AriaPy.ArActionGoto_setSpeed(self, speed)


    def getSpeed(self):
        """getSpeed(ArActionGoto self) -> double"""
        return _AriaPy.ArActionGoto_getSpeed(self)


    def fire(self, currentDesired):
        """fire(ArActionGoto self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionGoto_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionGoto self) -> ArActionDesired"""
        return _AriaPy.ArActionGoto_getDesired(self)

ArActionGoto_swigregister = _AriaPy.ArActionGoto_swigregister
ArActionGoto_swigregister(ArActionGoto)

class ArActionGotoStraight(ArAction):
    """Proxy of C++ ArActionGotoStraight 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__(ArActionGotoStraight self, char const * name, double speed=400) -> ArActionGotoStraight
        __init__(ArActionGotoStraight self, char const * name) -> ArActionGotoStraight
        __init__(ArActionGotoStraight self) -> ArActionGotoStraight
        """
        this = _AriaPy.new_ArActionGotoStraight(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGotoStraight
    __del__ = lambda self: None

    def haveAchievedGoal(self):
        """haveAchievedGoal(ArActionGotoStraight self) -> bool"""
        return _AriaPy.ArActionGotoStraight_haveAchievedGoal(self)


    def cancelGoal(self):
        """cancelGoal(ArActionGotoStraight self)"""
        return _AriaPy.ArActionGotoStraight_cancelGoal(self)


    def setGoal(self, goal, backwards=False, justDistance=True):
        """
        setGoal(ArActionGotoStraight self, ArPose goal, bool backwards=False, bool justDistance=True)
        setGoal(ArActionGotoStraight self, ArPose goal, bool backwards=False)
        setGoal(ArActionGotoStraight self, ArPose goal)
        """
        return _AriaPy.ArActionGotoStraight_setGoal(self, goal, backwards, justDistance)


    def setGoalRel(self, dist, deltaHeading, backwards=False, justDistance=True):
        """
        setGoalRel(ArActionGotoStraight self, double dist, double deltaHeading, bool backwards=False, bool justDistance=True)
        setGoalRel(ArActionGotoStraight self, double dist, double deltaHeading, bool backwards=False)
        setGoalRel(ArActionGotoStraight self, double dist, double deltaHeading)
        """
        return _AriaPy.ArActionGotoStraight_setGoalRel(self, dist, deltaHeading, backwards, justDistance)


    def getGoal(self):
        """getGoal(ArActionGotoStraight self) -> ArPose"""
        return _AriaPy.ArActionGotoStraight_getGoal(self)


    def usingEncoderGoal(self):
        """usingEncoderGoal(ArActionGotoStraight self) -> bool"""
        return _AriaPy.ArActionGotoStraight_usingEncoderGoal(self)


    def setEncoderGoal(self, encoderGoal, backwards=False, justDistance=True):
        """
        setEncoderGoal(ArActionGotoStraight self, ArPose encoderGoal, bool backwards=False, bool justDistance=True)
        setEncoderGoal(ArActionGotoStraight self, ArPose encoderGoal, bool backwards=False)
        setEncoderGoal(ArActionGotoStraight self, ArPose encoderGoal)
        """
        return _AriaPy.ArActionGotoStraight_setEncoderGoal(self, encoderGoal, backwards, justDistance)


    def setEncoderGoalRel(self, dist, deltaHeading, backwards=False, justDistance=True):
        """
        setEncoderGoalRel(ArActionGotoStraight self, double dist, double deltaHeading, bool backwards=False, bool justDistance=True)
        setEncoderGoalRel(ArActionGotoStraight self, double dist, double deltaHeading, bool backwards=False)
        setEncoderGoalRel(ArActionGotoStraight self, double dist, double deltaHeading)
        """
        return _AriaPy.ArActionGotoStraight_setEncoderGoalRel(self, dist, deltaHeading, backwards, justDistance)


    def getEncoderGoal(self):
        """getEncoderGoal(ArActionGotoStraight self) -> ArPose"""
        return _AriaPy.ArActionGotoStraight_getEncoderGoal(self)


    def setSpeed(self, speed):
        """setSpeed(ArActionGotoStraight self, double speed)"""
        return _AriaPy.ArActionGotoStraight_setSpeed(self, speed)


    def getSpeed(self):
        """getSpeed(ArActionGotoStraight self) -> double"""
        return _AriaPy.ArActionGotoStraight_getSpeed(self)


    def setCloseDist(self, closeDist=100):
        """
        setCloseDist(ArActionGotoStraight self, double closeDist=100)
        setCloseDist(ArActionGotoStraight self)
        """
        return _AriaPy.ArActionGotoStraight_setCloseDist(self, closeDist)


    def getCloseDist(self):
        """getCloseDist(ArActionGotoStraight self) -> double"""
        return _AriaPy.ArActionGotoStraight_getCloseDist(self)


    def getBacking(self):
        """getBacking(ArActionGotoStraight self) -> bool"""
        return _AriaPy.ArActionGotoStraight_getBacking(self)


    def fire(self, currentDesired):
        """fire(ArActionGotoStraight self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionGotoStraight_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionGotoStraight self) -> ArActionDesired"""
        return _AriaPy.ArActionGotoStraight_getDesired(self)

ArActionGotoStraight_swigregister = _AriaPy.ArActionGotoStraight_swigregister
ArActionGotoStraight_swigregister(ArActionGotoStraight)

class ArActionGroup(object):
    """Proxy of C++ ArActionGroup 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, robot):
        """__init__(ArActionGroup self, ArRobot robot) -> ArActionGroup"""
        this = _AriaPy.new_ArActionGroup(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroup
    __del__ = lambda self: None

    def addAction(self, action, priority):
        """addAction(ArActionGroup self, ArAction action, int priority)"""
        return _AriaPy.ArActionGroup_addAction(self, action, priority)


    def remAction(self, action):
        """remAction(ArActionGroup self, ArAction action)"""
        return _AriaPy.ArActionGroup_remAction(self, action)


    def activate(self):
        """activate(ArActionGroup self)"""
        return _AriaPy.ArActionGroup_activate(self)


    def activateExclusive(self):
        """activateExclusive(ArActionGroup self)"""
        return _AriaPy.ArActionGroup_activateExclusive(self)


    def deactivate(self):
        """deactivate(ArActionGroup self)"""
        return _AriaPy.ArActionGroup_deactivate(self)


    def removeActions(self):
        """removeActions(ArActionGroup self)"""
        return _AriaPy.ArActionGroup_removeActions(self)


    def deleteActions(self):
        """deleteActions(ArActionGroup self)"""
        return _AriaPy.ArActionGroup_deleteActions(self)


    def getActionList(self):
        """getActionList(ArActionGroup self) -> std::list< ArAction *,std::allocator< ArAction * > > *"""
        return _AriaPy.ArActionGroup_getActionList(self)

ArActionGroup_swigregister = _AriaPy.ArActionGroup_swigregister
ArActionGroup_swigregister(ArActionGroup)

class ArActionGroupInput(ArActionGroup):
    """Proxy of C++ ArActionGroupInput 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, robot):
        """__init__(ArActionGroupInput self, ArRobot robot) -> ArActionGroupInput"""
        this = _AriaPy.new_ArActionGroupInput(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupInput
    __del__ = lambda self: None

    def setVel(self, vel):
        """setVel(ArActionGroupInput self, double vel)"""
        return _AriaPy.ArActionGroupInput_setVel(self, vel)


    def setRotVel(self, rotVel):
        """setRotVel(ArActionGroupInput self, double rotVel)"""
        return _AriaPy.ArActionGroupInput_setRotVel(self, rotVel)


    def setHeading(self, heading):
        """setHeading(ArActionGroupInput self, double heading)"""
        return _AriaPy.ArActionGroupInput_setHeading(self, heading)


    def deltaHeadingFromCurrent(self, delta):
        """deltaHeadingFromCurrent(ArActionGroupInput self, double delta)"""
        return _AriaPy.ArActionGroupInput_deltaHeadingFromCurrent(self, delta)


    def clear(self):
        """clear(ArActionGroupInput self)"""
        return _AriaPy.ArActionGroupInput_clear(self)


    def getActionInput(self):
        """getActionInput(ArActionGroupInput self) -> ArActionInput"""
        return _AriaPy.ArActionGroupInput_getActionInput(self)

ArActionGroupInput_swigregister = _AriaPy.ArActionGroupInput_swigregister
ArActionGroupInput_swigregister(ArActionGroupInput)

class ArActionGroupStop(ArActionGroup):
    """Proxy of C++ ArActionGroupStop 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, robot):
        """__init__(ArActionGroupStop self, ArRobot robot) -> ArActionGroupStop"""
        this = _AriaPy.new_ArActionGroupStop(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupStop
    __del__ = lambda self: None

    def getActionStop(self):
        """getActionStop(ArActionGroupStop self) -> ArActionStop"""
        return _AriaPy.ArActionGroupStop_getActionStop(self)

    myActionStop = _swig_property(_AriaPy.ArActionGroupStop_myActionStop_get, _AriaPy.ArActionGroupStop_myActionStop_set)
ArActionGroupStop_swigregister = _AriaPy.ArActionGroupStop_swigregister
ArActionGroupStop_swigregister(ArActionGroupStop)

class ArActionGroupTeleop(ArActionGroup):
    """Proxy of C++ ArActionGroupTeleop 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, robot):
        """__init__(ArActionGroupTeleop self, ArRobot robot) -> ArActionGroupTeleop"""
        this = _AriaPy.new_ArActionGroupTeleop(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupTeleop
    __del__ = lambda self: None

    def setThrottleParams(self, lowSpeed, highSpeed):
        """setThrottleParams(ArActionGroupTeleop self, int lowSpeed, int highSpeed)"""
        return _AriaPy.ArActionGroupTeleop_setThrottleParams(self, lowSpeed, highSpeed)

ArActionGroupTeleop_swigregister = _AriaPy.ArActionGroupTeleop_swigregister
ArActionGroupTeleop_swigregister(ArActionGroupTeleop)

class ArActionGroupUnguardedTeleop(ArActionGroup):
    """Proxy of C++ ArActionGroupUnguardedTeleop 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, robot):
        """__init__(ArActionGroupUnguardedTeleop self, ArRobot robot) -> ArActionGroupUnguardedTeleop"""
        this = _AriaPy.new_ArActionGroupUnguardedTeleop(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupUnguardedTeleop
    __del__ = lambda self: None

    def setThrottleParams(self, lowSpeed, highSpeed):
        """setThrottleParams(ArActionGroupUnguardedTeleop self, int lowSpeed, int highSpeed)"""
        return _AriaPy.ArActionGroupUnguardedTeleop_setThrottleParams(self, lowSpeed, highSpeed)

ArActionGroupUnguardedTeleop_swigregister = _AriaPy.ArActionGroupUnguardedTeleop_swigregister
ArActionGroupUnguardedTeleop_swigregister(ArActionGroupUnguardedTeleop)

class ArActionGroupWander(ArActionGroup):
    """Proxy of C++ ArActionGroupWander 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, robot, forwardVel=400, avoidFrontDist=450, avoidVel=200, avoidTurnAmt=15):
        """
        __init__(ArActionGroupWander self, ArRobot robot, int forwardVel=400, int avoidFrontDist=450, int avoidVel=200, int avoidTurnAmt=15) -> ArActionGroupWander
        __init__(ArActionGroupWander self, ArRobot robot, int forwardVel=400, int avoidFrontDist=450, int avoidVel=200) -> ArActionGroupWander
        __init__(ArActionGroupWander self, ArRobot robot, int forwardVel=400, int avoidFrontDist=450) -> ArActionGroupWander
        __init__(ArActionGroupWander self, ArRobot robot, int forwardVel=400) -> ArActionGroupWander
        __init__(ArActionGroupWander self, ArRobot robot) -> ArActionGroupWander
        """
        this = _AriaPy.new_ArActionGroupWander(robot, forwardVel, avoidFrontDist, avoidVel, avoidTurnAmt)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupWander
    __del__ = lambda self: None
ArActionGroupWander_swigregister = _AriaPy.ArActionGroupWander_swigregister
ArActionGroupWander_swigregister(ArActionGroupWander)

class ArActionGroupColorFollow(ArActionGroup):
    """Proxy of C++ ArActionGroupColorFollow 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, robot, acts, camera):
        """__init__(ArActionGroupColorFollow self, ArRobot robot, ArACTS_1_2 acts, ArPTZ camera) -> ArActionGroupColorFollow"""
        this = _AriaPy.new_ArActionGroupColorFollow(robot, acts, camera)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupColorFollow
    __del__ = lambda self: None

    def setCamera(self, camera):
        """setCamera(ArActionGroupColorFollow self, ArPTZ camera)"""
        return _AriaPy.ArActionGroupColorFollow_setCamera(self, camera)


    def setChannel(self, channel):
        """setChannel(ArActionGroupColorFollow self, int channel)"""
        return _AriaPy.ArActionGroupColorFollow_setChannel(self, channel)


    def startMovement(self):
        """startMovement(ArActionGroupColorFollow self)"""
        return _AriaPy.ArActionGroupColorFollow_startMovement(self)


    def stopMovement(self):
        """stopMovement(ArActionGroupColorFollow self)"""
        return _AriaPy.ArActionGroupColorFollow_stopMovement(self)


    def setAcquire(self, acquire):
        """setAcquire(ArActionGroupColorFollow self, bool acquire)"""
        return _AriaPy.ArActionGroupColorFollow_setAcquire(self, acquire)


    def getChannel(self):
        """getChannel(ArActionGroupColorFollow self) -> int"""
        return _AriaPy.ArActionGroupColorFollow_getChannel(self)


    def getAcquire(self):
        """getAcquire(ArActionGroupColorFollow self) -> bool"""
        return _AriaPy.ArActionGroupColorFollow_getAcquire(self)


    def getMovement(self):
        """getMovement(ArActionGroupColorFollow self) -> bool"""
        return _AriaPy.ArActionGroupColorFollow_getMovement(self)


    def getBlob(self):
        """getBlob(ArActionGroupColorFollow self) -> bool"""
        return _AriaPy.ArActionGroupColorFollow_getBlob(self)

ArActionGroupColorFollow_swigregister = _AriaPy.ArActionGroupColorFollow_swigregister
ArActionGroupColorFollow_swigregister(ArActionGroupColorFollow)

class ArActionGroupRatioDrive(ArActionGroup):
    """Proxy of C++ ArActionGroupRatioDrive 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, robot):
        """__init__(ArActionGroupRatioDrive self, ArRobot robot) -> ArActionGroupRatioDrive"""
        this = _AriaPy.new_ArActionGroupRatioDrive(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupRatioDrive
    __del__ = lambda self: None

    def getActionRatioInput(self):
        """getActionRatioInput(ArActionGroupRatioDrive self) -> ArActionRatioInput"""
        return _AriaPy.ArActionGroupRatioDrive_getActionRatioInput(self)


    def addToConfig(self, config, section):
        """addToConfig(ArActionGroupRatioDrive self, ArConfig config, char const * section)"""
        return _AriaPy.ArActionGroupRatioDrive_addToConfig(self, config, section)

ArActionGroupRatioDrive_swigregister = _AriaPy.ArActionGroupRatioDrive_swigregister
ArActionGroupRatioDrive_swigregister(ArActionGroupRatioDrive)

class ArActionGroupRatioDriveUnsafe(ArActionGroup):
    """Proxy of C++ ArActionGroupRatioDriveUnsafe 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, robot):
        """__init__(ArActionGroupRatioDriveUnsafe self, ArRobot robot) -> ArActionGroupRatioDriveUnsafe"""
        this = _AriaPy.new_ArActionGroupRatioDriveUnsafe(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupRatioDriveUnsafe
    __del__ = lambda self: None

    def getActionRatioInput(self):
        """getActionRatioInput(ArActionGroupRatioDriveUnsafe self) -> ArActionRatioInput"""
        return _AriaPy.ArActionGroupRatioDriveUnsafe_getActionRatioInput(self)


    def addToConfig(self, config, section):
        """addToConfig(ArActionGroupRatioDriveUnsafe self, ArConfig config, char const * section)"""
        return _AriaPy.ArActionGroupRatioDriveUnsafe_addToConfig(self, config, section)

ArActionGroupRatioDriveUnsafe_swigregister = _AriaPy.ArActionGroupRatioDriveUnsafe_swigregister
ArActionGroupRatioDriveUnsafe_swigregister(ArActionGroupRatioDriveUnsafe)

class ArActionIRs(ArAction):
    """Proxy of C++ ArActionIRs 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__(ArActionIRs self, char const * name, double backOffSpeed=100, int backOffTime=5000, int turnTime=3000, bool setMaximums=False) -> ArActionIRs
        __init__(ArActionIRs self, char const * name, double backOffSpeed=100, int backOffTime=5000, int turnTime=3000) -> ArActionIRs
        __init__(ArActionIRs self, char const * name, double backOffSpeed=100, int backOffTime=5000) -> ArActionIRs
        __init__(ArActionIRs self, char const * name, double backOffSpeed=100) -> ArActionIRs
        __init__(ArActionIRs self, char const * name) -> ArActionIRs
        __init__(ArActionIRs self) -> ArActionIRs
        """
        this = _AriaPy.new_ArActionIRs(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionIRs
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionIRs self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionIRs_fire(self, currentDesired)


    def setRobot(self, robot):
        """setRobot(ArActionIRs self, ArRobot robot)"""
        return _AriaPy.ArActionIRs_setRobot(self, robot)


    def getDesired(self):
        """getDesired(ArActionIRs self) -> ArActionDesired"""
        return _AriaPy.ArActionIRs_getDesired(self)

ArActionIRs_swigregister = _AriaPy.ArActionIRs_swigregister
ArActionIRs_swigregister(ArActionIRs)

class ArActionInput(ArAction):
    """Proxy of C++ ArActionInput 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__(ArActionInput self, char const * name) -> ArActionInput
        __init__(ArActionInput self) -> ArActionInput
        """
        this = _AriaPy.new_ArActionInput(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionInput
    __del__ = lambda self: None

    def setVel(self, vel):
        """setVel(ArActionInput self, double vel)"""
        return _AriaPy.ArActionInput_setVel(self, vel)


    def deltaHeadingFromCurrent(self, delta):
        """deltaHeadingFromCurrent(ArActionInput self, double delta)"""
        return _AriaPy.ArActionInput_deltaHeadingFromCurrent(self, delta)


    def setRotVel(self, rotVel):
        """setRotVel(ArActionInput self, double rotVel)"""
        return _AriaPy.ArActionInput_setRotVel(self, rotVel)


    def setHeading(self, heading):
        """setHeading(ArActionInput self, double heading)"""
        return _AriaPy.ArActionInput_setHeading(self, heading)


    def clear(self):
        """clear(ArActionInput self)"""
        return _AriaPy.ArActionInput_clear(self)


    def fire(self, currentDesired):
        """fire(ArActionInput self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionInput_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionInput self) -> ArActionDesired"""
        return _AriaPy.ArActionInput_getDesired(self)

ArActionInput_swigregister = _AriaPy.ArActionInput_swigregister
ArActionInput_swigregister(ArActionInput)

class ArActionJoydrive(ArAction):
    """Proxy of C++ ArActionJoydrive 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__(ArActionJoydrive self, char const * name, double transVelMax=400, double turnAmountMax=15, bool stopIfNoButtonPressed=True, bool useOSCalForJoystick=True) -> ArActionJoydrive
        __init__(ArActionJoydrive self, char const * name, double transVelMax=400, double turnAmountMax=15, bool stopIfNoButtonPressed=True) -> ArActionJoydrive
        __init__(ArActionJoydrive self, char const * name, double transVelMax=400, double turnAmountMax=15) -> ArActionJoydrive
        __init__(ArActionJoydrive self, char const * name, double transVelMax=400) -> ArActionJoydrive
        __init__(ArActionJoydrive self, char const * name) -> ArActionJoydrive
        __init__(ArActionJoydrive self) -> ArActionJoydrive
        """
        this = _AriaPy.new_ArActionJoydrive(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionJoydrive
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionJoydrive self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionJoydrive_fire(self, currentDesired)


    def joystickInited(self):
        """joystickInited(ArActionJoydrive self) -> bool"""
        return _AriaPy.ArActionJoydrive_joystickInited(self)


    def setSpeeds(self, transVelMax, turnAmountMax):
        """setSpeeds(ArActionJoydrive self, double transVelMax, double turnAmountMax)"""
        return _AriaPy.ArActionJoydrive_setSpeeds(self, transVelMax, turnAmountMax)


    def setStopIfNoButtonPressed(self, stopIfNoButtonPressed):
        """setStopIfNoButtonPressed(ArActionJoydrive self, bool stopIfNoButtonPressed)"""
        return _AriaPy.ArActionJoydrive_setStopIfNoButtonPressed(self, stopIfNoButtonPressed)


    def getStopIfNoButtonPressed(self):
        """getStopIfNoButtonPressed(ArActionJoydrive self) -> bool"""
        return _AriaPy.ArActionJoydrive_getStopIfNoButtonPressed(self)


    def setThrottleParams(self, lowSpeed, highSpeed):
        """setThrottleParams(ArActionJoydrive self, double lowSpeed, double highSpeed)"""
        return _AriaPy.ArActionJoydrive_setThrottleParams(self, lowSpeed, highSpeed)


    def setUseOSCal(self, useOSCal):
        """setUseOSCal(ArActionJoydrive self, bool useOSCal)"""
        return _AriaPy.ArActionJoydrive_setUseOSCal(self, useOSCal)


    def getUseOSCal(self):
        """getUseOSCal(ArActionJoydrive self) -> bool"""
        return _AriaPy.ArActionJoydrive_getUseOSCal(self)


    def getJoyHandler(self):
        """getJoyHandler(ArActionJoydrive self) -> ArJoyHandler"""
        return _AriaPy.ArActionJoydrive_getJoyHandler(self)


    def getDesired(self):
        """getDesired(ArActionJoydrive self) -> ArActionDesired"""
        return _AriaPy.ArActionJoydrive_getDesired(self)

ArActionJoydrive_swigregister = _AriaPy.ArActionJoydrive_swigregister
ArActionJoydrive_swigregister(ArActionJoydrive)

class ArActionKeydrive(ArAction):
    """Proxy of C++ ArActionKeydrive 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__(ArActionKeydrive self, char const * name, double transVelMax=400, double turnAmountMax=24, double velIncrement=25, double turnIncrement=8) -> ArActionKeydrive
        __init__(ArActionKeydrive self, char const * name, double transVelMax=400, double turnAmountMax=24, double velIncrement=25) -> ArActionKeydrive
        __init__(ArActionKeydrive self, char const * name, double transVelMax=400, double turnAmountMax=24) -> ArActionKeydrive
        __init__(ArActionKeydrive self, char const * name, double transVelMax=400) -> ArActionKeydrive
        __init__(ArActionKeydrive self, char const * name) -> ArActionKeydrive
        __init__(ArActionKeydrive self) -> ArActionKeydrive
        """
        this = _AriaPy.new_ArActionKeydrive(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionKeydrive
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionKeydrive self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionKeydrive_fire(self, currentDesired)


    def setSpeeds(self, transVelMax, turnAmountMax):
        """setSpeeds(ArActionKeydrive self, double transVelMax, double turnAmountMax)"""
        return _AriaPy.ArActionKeydrive_setSpeeds(self, transVelMax, turnAmountMax)


    def setIncrements(self, velIncrement, turnIncrement):
        """setIncrements(ArActionKeydrive self, double velIncrement, double turnIncrement)"""
        return _AriaPy.ArActionKeydrive_setIncrements(self, velIncrement, turnIncrement)


    def getDesired(self):
        """getDesired(ArActionKeydrive self) -> ArActionDesired"""
        return _AriaPy.ArActionKeydrive_getDesired(self)


    def setRobot(self, robot):
        """setRobot(ArActionKeydrive self, ArRobot robot)"""
        return _AriaPy.ArActionKeydrive_setRobot(self, robot)


    def activate(self):
        """activate(ArActionKeydrive self)"""
        return _AriaPy.ArActionKeydrive_activate(self)


    def deactivate(self):
        """deactivate(ArActionKeydrive self)"""
        return _AriaPy.ArActionKeydrive_deactivate(self)


    def takeKeys(self):
        """takeKeys(ArActionKeydrive self)"""
        return _AriaPy.ArActionKeydrive_takeKeys(self)


    def giveUpKeys(self):
        """giveUpKeys(ArActionKeydrive self)"""
        return _AriaPy.ArActionKeydrive_giveUpKeys(self)


    def up(self):
        """up(ArActionKeydrive self)"""
        return _AriaPy.ArActionKeydrive_up(self)


    def down(self):
        """down(ArActionKeydrive self)"""
        return _AriaPy.ArActionKeydrive_down(self)


    def left(self):
        """left(ArActionKeydrive self)"""
        return _AriaPy.ArActionKeydrive_left(self)


    def right(self):
        """right(ArActionKeydrive self)"""
        return _AriaPy.ArActionKeydrive_right(self)


    def space(self):
        """space(ArActionKeydrive self)"""
        return _AriaPy.ArActionKeydrive_space(self)

ArActionKeydrive_swigregister = _AriaPy.ArActionKeydrive_swigregister
ArActionKeydrive_swigregister(ArActionKeydrive)

class ArActionLimiterBackwards(ArAction):
    """Proxy of C++ ArActionLimiterBackwards 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__(ArActionLimiterBackwards self, char const * name, double stopDistance=-250, double slowDistance=-600, double maxBackwardsSpeed=-250, double widthRatio=1.5, bool avoidLocationDependentObstacles=True) -> ArActionLimiterBackwards
        __init__(ArActionLimiterBackwards self, char const * name, double stopDistance=-250, double slowDistance=-600, double maxBackwardsSpeed=-250, double widthRatio=1.5) -> ArActionLimiterBackwards
        __init__(ArActionLimiterBackwards self, char const * name, double stopDistance=-250, double slowDistance=-600, double maxBackwardsSpeed=-250) -> ArActionLimiterBackwards
        __init__(ArActionLimiterBackwards self, char const * name, double stopDistance=-250, double slowDistance=-600) -> ArActionLimiterBackwards
        __init__(ArActionLimiterBackwards self, char const * name, double stopDistance=-250) -> ArActionLimiterBackwards
        __init__(ArActionLimiterBackwards self, char const * name) -> ArActionLimiterBackwards
        __init__(ArActionLimiterBackwards self) -> ArActionLimiterBackwards
        """
        this = _AriaPy.new_ArActionLimiterBackwards(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionLimiterBackwards
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionLimiterBackwards self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionLimiterBackwards_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionLimiterBackwards self) -> ArActionDesired"""
        return _AriaPy.ArActionLimiterBackwards_getDesired(self)

ArActionLimiterBackwards_swigregister = _AriaPy.ArActionLimiterBackwards_swigregister
ArActionLimiterBackwards_swigregister(ArActionLimiterBackwards)

class ArActionLimiterForwards(ArAction):
    """Proxy of C++ ArActionLimiterForwards 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__(ArActionLimiterForwards self, char const * name, double stopDistance=250, double slowDistance=1000, double slowSpeed=200, double widthRatio=1) -> ArActionLimiterForwards
        __init__(ArActionLimiterForwards self, char const * name, double stopDistance=250, double slowDistance=1000, double slowSpeed=200) -> ArActionLimiterForwards
        __init__(ArActionLimiterForwards self, char const * name, double stopDistance=250, double slowDistance=1000) -> ArActionLimiterForwards
        __init__(ArActionLimiterForwards self, char const * name, double stopDistance=250) -> ArActionLimiterForwards
        __init__(ArActionLimiterForwards self, char const * name) -> ArActionLimiterForwards
        __init__(ArActionLimiterForwards self) -> ArActionLimiterForwards
        """
        this = _AriaPy.new_ArActionLimiterForwards(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionLimiterForwards
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionLimiterForwards self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionLimiterForwards_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionLimiterForwards self) -> ArActionDesired"""
        return _AriaPy.ArActionLimiterForwards_getDesired(self)


    def setParameters(self, stopDistance=250, slowDistance=1000, slowSpeed=200, widthRatio=1):
        """
        setParameters(ArActionLimiterForwards self, double stopDistance=250, double slowDistance=1000, double slowSpeed=200, double widthRatio=1)
        setParameters(ArActionLimiterForwards self, double stopDistance=250, double slowDistance=1000, double slowSpeed=200)
        setParameters(ArActionLimiterForwards self, double stopDistance=250, double slowDistance=1000)
        setParameters(ArActionLimiterForwards self, double stopDistance=250)
        setParameters(ArActionLimiterForwards self)
        """
        return _AriaPy.ArActionLimiterForwards_setParameters(self, stopDistance, slowDistance, slowSpeed, widthRatio)

ArActionLimiterForwards_swigregister = _AriaPy.ArActionLimiterForwards_swigregister
ArActionLimiterForwards_swigregister(ArActionLimiterForwards)

class ArActionLimiterTableSensor(ArAction):
    """Proxy of C++ ArActionLimiterTableSensor 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__(ArActionLimiterTableSensor self, char const * name) -> ArActionLimiterTableSensor
        __init__(ArActionLimiterTableSensor self) -> ArActionLimiterTableSensor
        """
        this = _AriaPy.new_ArActionLimiterTableSensor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionLimiterTableSensor
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionLimiterTableSensor self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionLimiterTableSensor_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionLimiterTableSensor self) -> ArActionDesired"""
        return _AriaPy.ArActionLimiterTableSensor_getDesired(self)

ArActionLimiterTableSensor_swigregister = _AriaPy.ArActionLimiterTableSensor_swigregister
ArActionLimiterTableSensor_swigregister(ArActionLimiterTableSensor)

class ArActionMovementParameters(ArAction):
    """Proxy of C++ ArActionMovementParameters 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__(ArActionMovementParameters self, char const * name, bool overrideFaster=True, bool addLatVelIfAvailable=True) -> ArActionMovementParameters
        __init__(ArActionMovementParameters self, char const * name, bool overrideFaster=True) -> ArActionMovementParameters
        __init__(ArActionMovementParameters self, char const * name) -> ArActionMovementParameters
        __init__(ArActionMovementParameters self) -> ArActionMovementParameters
        """
        this = _AriaPy.new_ArActionMovementParameters(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionMovementParameters
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionMovementParameters self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionMovementParameters_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionMovementParameters self) -> ArActionDesired"""
        return _AriaPy.ArActionMovementParameters_getDesired(self)


    def isEnabled(self):
        """isEnabled(ArActionMovementParameters self) -> bool"""
        return _AriaPy.ArActionMovementParameters_isEnabled(self)


    def enable(self):
        """enable(ArActionMovementParameters self)"""
        return _AriaPy.ArActionMovementParameters_enable(self)


    def enableOnceFromSector(self, mapObject):
        """enableOnceFromSector(ArActionMovementParameters self, ArMapObject mapObject)"""
        return _AriaPy.ArActionMovementParameters_enableOnceFromSector(self, mapObject)


    def disable(self):
        """disable(ArActionMovementParameters self)"""
        return _AriaPy.ArActionMovementParameters_disable(self)


    def setParameters(self, maxVel=0, maxNegVel=0, transAccel=0, transDecel=0, rotVelMax=0, rotAccel=0, rotDecel=0, latVelMax=0, latAccel=0, latDecel=0):
        """
        setParameters(ArActionMovementParameters self, double maxVel=0, double maxNegVel=0, double transAccel=0, double transDecel=0, double rotVelMax=0, double rotAccel=0, double rotDecel=0, double latVelMax=0, double latAccel=0, double latDecel=0)
        setParameters(ArActionMovementParameters self, double maxVel=0, double maxNegVel=0, double transAccel=0, double transDecel=0, double rotVelMax=0, double rotAccel=0, double rotDecel=0, double latVelMax=0, double latAccel=0)
        setParameters(ArActionMovementParameters self, double maxVel=0, double maxNegVel=0, double transAccel=0, double transDecel=0, double rotVelMax=0, double rotAccel=0, double rotDecel=0, double latVelMax=0)
        setParameters(ArActionMovementParameters self, double maxVel=0, double maxNegVel=0, double transAccel=0, double transDecel=0, double rotVelMax=0, double rotAccel=0, double rotDecel=0)
        setParameters(ArActionMovementParameters self, double maxVel=0, double maxNegVel=0, double transAccel=0, double transDecel=0, double rotVelMax=0, double rotAccel=0)
        setParameters(ArActionMovementParameters self, double maxVel=0, double maxNegVel=0, double transAccel=0, double transDecel=0, double rotVelMax=0)
        setParameters(ArActionMovementParameters self, double maxVel=0, double maxNegVel=0, double transAccel=0, double transDecel=0)
        setParameters(ArActionMovementParameters self, double maxVel=0, double maxNegVel=0, double transAccel=0)
        setParameters(ArActionMovementParameters self, double maxVel=0, double maxNegVel=0)
        setParameters(ArActionMovementParameters self, double maxVel=0)
        setParameters(ArActionMovementParameters self)
        """
        return _AriaPy.ArActionMovementParameters_setParameters(self, maxVel, maxNegVel, transAccel, transDecel, rotVelMax, rotAccel, rotDecel, latVelMax, latAccel, latDecel)


    def addToConfig(self, config, section, prefix=None):
        """
        addToConfig(ArActionMovementParameters self, ArConfig config, char const * section, char const * prefix=None)
        addToConfig(ArActionMovementParameters self, ArConfig config, char const * section)
        """
        return _AriaPy.ArActionMovementParameters_addToConfig(self, config, section, prefix)

ArActionMovementParameters_swigregister = _AriaPy.ArActionMovementParameters_swigregister
ArActionMovementParameters_swigregister(ArActionMovementParameters)

class ArActionRatioInput(ArAction):
    """Proxy of C++ ArActionRatioInput 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__(ArActionRatioInput self, char const * name) -> ArActionRatioInput
        __init__(ArActionRatioInput self) -> ArActionRatioInput
        """
        this = _AriaPy.new_ArActionRatioInput(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionRatioInput
    __del__ = lambda self: None

    def setRatios(self, transRatio, rotRatio, throttleRatio, latRatio=0):
        """
        setRatios(ArActionRatioInput self, double transRatio, double rotRatio, double throttleRatio, double latRatio=0)
        setRatios(ArActionRatioInput self, double transRatio, double rotRatio, double throttleRatio)
        """
        return _AriaPy.ArActionRatioInput_setRatios(self, transRatio, rotRatio, throttleRatio, latRatio)


    def setTransRatio(self, transRatio):
        """setTransRatio(ArActionRatioInput self, double transRatio)"""
        return _AriaPy.ArActionRatioInput_setTransRatio(self, transRatio)


    def setRotRatio(self, rotRatio):
        """setRotRatio(ArActionRatioInput self, double rotRatio)"""
        return _AriaPy.ArActionRatioInput_setRotRatio(self, rotRatio)


    def setLatRatio(self, latRatio):
        """setLatRatio(ArActionRatioInput self, double latRatio)"""
        return _AriaPy.ArActionRatioInput_setLatRatio(self, latRatio)


    def setThrottleRatio(self, throttleRatio):
        """setThrottleRatio(ArActionRatioInput self, double throttleRatio)"""
        return _AriaPy.ArActionRatioInput_setThrottleRatio(self, throttleRatio)


    def getTransRatio(self):
        """getTransRatio(ArActionRatioInput self) -> double"""
        return _AriaPy.ArActionRatioInput_getTransRatio(self)


    def getRotRatio(self):
        """getRotRatio(ArActionRatioInput self) -> double"""
        return _AriaPy.ArActionRatioInput_getRotRatio(self)


    def getThrottleRatio(self):
        """getThrottleRatio(ArActionRatioInput self) -> double"""
        return _AriaPy.ArActionRatioInput_getThrottleRatio(self)


    def addFireCallback(self, priority, functor):
        """addFireCallback(ArActionRatioInput self, int priority, ArFunctor functor)"""
        return _AriaPy.ArActionRatioInput_addFireCallback(self, priority, functor)


    def remFireCallback(self, functor):
        """remFireCallback(ArActionRatioInput self, ArFunctor functor)"""
        return _AriaPy.ArActionRatioInput_remFireCallback(self, functor)


    def addActivateCallback(self, *args):
        """
        addActivateCallback(ArActionRatioInput self, ArFunctor functor, ArListPos::Pos position)
        addActivateCallback(ArActionRatioInput self, ArFunctor functor)
        """
        return _AriaPy.ArActionRatioInput_addActivateCallback(self, *args)


    def remActivateCallback(self, functor):
        """remActivateCallback(ArActionRatioInput self, ArFunctor functor)"""
        return _AriaPy.ArActionRatioInput_remActivateCallback(self, functor)


    def addDeactivateCallback(self, *args):
        """
        addDeactivateCallback(ArActionRatioInput self, ArFunctor functor, ArListPos::Pos position)
        addDeactivateCallback(ArActionRatioInput self, ArFunctor functor)
        """
        return _AriaPy.ArActionRatioInput_addDeactivateCallback(self, *args)


    def remDeactivateCallback(self, functor):
        """remDeactivateCallback(ArActionRatioInput self, ArFunctor functor)"""
        return _AriaPy.ArActionRatioInput_remDeactivateCallback(self, functor)


    def setParameters(self, fullThrottleForwards, fullThrottleBackwards, rotAtFullForwards, rotAtFullBackwards, rotAtStopped, latAtFullForwards=0, latAtFullBackwards=0, latAtStopped=0):
        """
        setParameters(ArActionRatioInput self, double fullThrottleForwards, double fullThrottleBackwards, double rotAtFullForwards, double rotAtFullBackwards, double rotAtStopped, double latAtFullForwards=0, double latAtFullBackwards=0, double latAtStopped=0)
        setParameters(ArActionRatioInput self, double fullThrottleForwards, double fullThrottleBackwards, double rotAtFullForwards, double rotAtFullBackwards, double rotAtStopped, double latAtFullForwards=0, double latAtFullBackwards=0)
        setParameters(ArActionRatioInput self, double fullThrottleForwards, double fullThrottleBackwards, double rotAtFullForwards, double rotAtFullBackwards, double rotAtStopped, double latAtFullForwards=0)
        setParameters(ArActionRatioInput self, double fullThrottleForwards, double fullThrottleBackwards, double rotAtFullForwards, double rotAtFullBackwards, double rotAtStopped)
        """
        return _AriaPy.ArActionRatioInput_setParameters(self, fullThrottleForwards, fullThrottleBackwards, rotAtFullForwards, rotAtFullBackwards, rotAtStopped, latAtFullForwards, latAtFullBackwards, latAtStopped)


    def addToConfig(self, config, section):
        """addToConfig(ArActionRatioInput self, ArConfig config, char const * section)"""
        return _AriaPy.ArActionRatioInput_addToConfig(self, config, section)


    def fire(self, currentDesired):
        """fire(ArActionRatioInput self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionRatioInput_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionRatioInput self) -> ArActionDesired"""
        return _AriaPy.ArActionRatioInput_getDesired(self)


    def activate(self):
        """activate(ArActionRatioInput self)"""
        return _AriaPy.ArActionRatioInput_activate(self)


    def deactivate(self):
        """deactivate(ArActionRatioInput self)"""
        return _AriaPy.ArActionRatioInput_deactivate(self)

ArActionRatioInput_swigregister = _AriaPy.ArActionRatioInput_swigregister
ArActionRatioInput_swigregister(ArActionRatioInput)

class ArActionRobotJoydrive(ArAction):
    """Proxy of C++ ArActionRobotJoydrive 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__(ArActionRobotJoydrive self, char const * name, bool requireDeadmanPushed=True) -> ArActionRobotJoydrive
        __init__(ArActionRobotJoydrive self, char const * name) -> ArActionRobotJoydrive
        __init__(ArActionRobotJoydrive self) -> ArActionRobotJoydrive
        """
        this = _AriaPy.new_ArActionRobotJoydrive(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionRobotJoydrive
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionRobotJoydrive self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionRobotJoydrive_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionRobotJoydrive self) -> ArActionDesired"""
        return _AriaPy.ArActionRobotJoydrive_getDesired(self)


    def setRobot(self, robot):
        """setRobot(ArActionRobotJoydrive self, ArRobot robot)"""
        return _AriaPy.ArActionRobotJoydrive_setRobot(self, robot)

ArActionRobotJoydrive_swigregister = _AriaPy.ArActionRobotJoydrive_swigregister
ArActionRobotJoydrive_swigregister(ArActionRobotJoydrive)

class ArActionStallRecover(ArAction):
    """Proxy of C++ ArActionStallRecover 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__(ArActionStallRecover self, char const * name, double obstacleDistance=225, int cyclesToMove=50, double speed=150, double degreesToTurn=45, bool enabled=True) -> ArActionStallRecover
        __init__(ArActionStallRecover self, char const * name, double obstacleDistance=225, int cyclesToMove=50, double speed=150, double degreesToTurn=45) -> ArActionStallRecover
        __init__(ArActionStallRecover self, char const * name, double obstacleDistance=225, int cyclesToMove=50, double speed=150) -> ArActionStallRecover
        __init__(ArActionStallRecover self, char const * name, double obstacleDistance=225, int cyclesToMove=50) -> ArActionStallRecover
        __init__(ArActionStallRecover self, char const * name, double obstacleDistance=225) -> ArActionStallRecover
        __init__(ArActionStallRecover self, char const * name) -> ArActionStallRecover
        __init__(ArActionStallRecover self) -> ArActionStallRecover
        """
        this = _AriaPy.new_ArActionStallRecover(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionStallRecover
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionStallRecover self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionStallRecover_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionStallRecover self) -> ArActionDesired"""
        return _AriaPy.ArActionStallRecover_getDesired(self)


    def addToConfig(self, *args):
        """
        addToConfig(ArActionStallRecover self, ArConfig config, char const * sectionName, ArPriority::Priority priority)
        addToConfig(ArActionStallRecover self, ArConfig config, char const * sectionName)
        """
        return _AriaPy.ArActionStallRecover_addToConfig(self, *args)


    def activate(self):
        """activate(ArActionStallRecover self)"""
        return _AriaPy.ArActionStallRecover_activate(self)

ArActionStallRecover_swigregister = _AriaPy.ArActionStallRecover_swigregister
ArActionStallRecover_swigregister(ArActionStallRecover)

class ArActionStop(ArAction):
    """Proxy of C++ ArActionStop 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__(ArActionStop self, char const * name) -> ArActionStop
        __init__(ArActionStop self) -> ArActionStop
        """
        this = _AriaPy.new_ArActionStop(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionStop
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionStop self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionStop_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionStop self) -> ArActionDesired"""
        return _AriaPy.ArActionStop_getDesired(self)

ArActionStop_swigregister = _AriaPy.ArActionStop_swigregister
ArActionStop_swigregister(ArActionStop)

class ArActionTriangleDriveTo(ArAction):
    """Proxy of C++ ArActionTriangleDriveTo 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__(ArActionTriangleDriveTo self, char const * name, double finalDistFromVertex=400, double approachDistFromVertex=1000, double speed=200, double closeDist=100, double acquireTurnSpeed=30) -> ArActionTriangleDriveTo
        __init__(ArActionTriangleDriveTo self, char const * name, double finalDistFromVertex=400, double approachDistFromVertex=1000, double speed=200, double closeDist=100) -> ArActionTriangleDriveTo
        __init__(ArActionTriangleDriveTo self, char const * name, double finalDistFromVertex=400, double approachDistFromVertex=1000, double speed=200) -> ArActionTriangleDriveTo
        __init__(ArActionTriangleDriveTo self, char const * name, double finalDistFromVertex=400, double approachDistFromVertex=1000) -> ArActionTriangleDriveTo
        __init__(ArActionTriangleDriveTo self, char const * name, double finalDistFromVertex=400) -> ArActionTriangleDriveTo
        __init__(ArActionTriangleDriveTo self, char const * name) -> ArActionTriangleDriveTo
        __init__(ArActionTriangleDriveTo self) -> ArActionTriangleDriveTo
        """
        this = _AriaPy.new_ArActionTriangleDriveTo(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionTriangleDriveTo
    __del__ = lambda self: None

    def setAcquire(self, acquire=False):
        """
        setAcquire(ArActionTriangleDriveTo self, bool acquire=False)
        setAcquire(ArActionTriangleDriveTo self)
        """
        return _AriaPy.ArActionTriangleDriveTo_setAcquire(self, acquire)


    def getAcquire(self):
        """getAcquire(ArActionTriangleDriveTo self) -> bool"""
        return _AriaPy.ArActionTriangleDriveTo_getAcquire(self)


    def setFinalDistFromVertex(self, dist):
        """setFinalDistFromVertex(ArActionTriangleDriveTo self, double dist)"""
        return _AriaPy.ArActionTriangleDriveTo_setFinalDistFromVertex(self, dist)


    def getFinalDistFromVertex(self):
        """getFinalDistFromVertex(ArActionTriangleDriveTo self) -> double"""
        return _AriaPy.ArActionTriangleDriveTo_getFinalDistFromVertex(self)


    def setTriangleParams(self, line1Length=254, angleBetween=135, line2Length=254):
        """
        setTriangleParams(ArActionTriangleDriveTo self, double line1Length=254, double angleBetween=135, double line2Length=254)
        setTriangleParams(ArActionTriangleDriveTo self, double line1Length=254, double angleBetween=135)
        setTriangleParams(ArActionTriangleDriveTo self, double line1Length=254)
        setTriangleParams(ArActionTriangleDriveTo self)
        """
        return _AriaPy.ArActionTriangleDriveTo_setTriangleParams(self, line1Length, angleBetween, line2Length)


    def setParameters(self, finalDistFromVertex=400, approachDistFromVertex=1000, speed=200, closeDist=100, acquireTurnSpeed=30):
        """
        setParameters(ArActionTriangleDriveTo self, double finalDistFromVertex=400, double approachDistFromVertex=1000, double speed=200, double closeDist=100, double acquireTurnSpeed=30)
        setParameters(ArActionTriangleDriveTo self, double finalDistFromVertex=400, double approachDistFromVertex=1000, double speed=200, double closeDist=100)
        setParameters(ArActionTriangleDriveTo self, double finalDistFromVertex=400, double approachDistFromVertex=1000, double speed=200)
        setParameters(ArActionTriangleDriveTo self, double finalDistFromVertex=400, double approachDistFromVertex=1000)
        setParameters(ArActionTriangleDriveTo self, double finalDistFromVertex=400)
        setParameters(ArActionTriangleDriveTo self)
        """
        return _AriaPy.ArActionTriangleDriveTo_setParameters(self, finalDistFromVertex, approachDistFromVertex, speed, closeDist, acquireTurnSpeed)


    def getAdjustVertex(self):
        """getAdjustVertex(ArActionTriangleDriveTo self) -> bool"""
        return _AriaPy.ArActionTriangleDriveTo_getAdjustVertex(self)


    def setAdjustVertex(self, adjustVertex):
        """setAdjustVertex(ArActionTriangleDriveTo self, bool adjustVertex)"""
        return _AriaPy.ArActionTriangleDriveTo_setAdjustVertex(self, adjustVertex)


    def setVertexOffset(self, localXOffset, localYOffset, thOffset):
        """setVertexOffset(ArActionTriangleDriveTo self, int localXOffset, int localYOffset, double thOffset)"""
        return _AriaPy.ArActionTriangleDriveTo_setVertexOffset(self, localXOffset, localYOffset, thOffset)


    def setUseLegacyVertexOffset(self, useLegacyVertexOffset):
        """setUseLegacyVertexOffset(ArActionTriangleDriveTo self, bool useLegacyVertexOffset)"""
        return _AriaPy.ArActionTriangleDriveTo_setUseLegacyVertexOffset(self, useLegacyVertexOffset)


    def getUseLegacyVertexOffset(self):
        """getUseLegacyVertexOffset(ArActionTriangleDriveTo self) -> bool"""
        return _AriaPy.ArActionTriangleDriveTo_getUseLegacyVertexOffset(self)


    def getGotoVertex(self):
        """getGotoVertex(ArActionTriangleDriveTo self) -> bool"""
        return _AriaPy.ArActionTriangleDriveTo_getGotoVertex(self)


    def setGotoVertex(self, gotoVertex):
        """setGotoVertex(ArActionTriangleDriveTo self, bool gotoVertex)"""
        return _AriaPy.ArActionTriangleDriveTo_setGotoVertex(self, gotoVertex)


    def setIgnoreTriangleDist(self, dist=250, useIgnoreInGotoVertexMode=False):
        """
        setIgnoreTriangleDist(ArActionTriangleDriveTo self, double dist=250, bool useIgnoreInGotoVertexMode=False)
        setIgnoreTriangleDist(ArActionTriangleDriveTo self, double dist=250)
        setIgnoreTriangleDist(ArActionTriangleDriveTo self)
        """
        return _AriaPy.ArActionTriangleDriveTo_setIgnoreTriangleDist(self, dist, useIgnoreInGotoVertexMode)


    def getIgnoreTriangleDist(self):
        """getIgnoreTriangleDist(ArActionTriangleDriveTo self) -> double"""
        return _AriaPy.ArActionTriangleDriveTo_getIgnoreTriangleDist(self)


    def getUseIgnoreInGotoVertexMode(self):
        """getUseIgnoreInGotoVertexMode(ArActionTriangleDriveTo self) -> bool"""
        return _AriaPy.ArActionTriangleDriveTo_getUseIgnoreInGotoVertexMode(self)


    def setVertexUnseenStopMSecs(self, vertexUnseenStopMSecs=4000):
        """
        setVertexUnseenStopMSecs(ArActionTriangleDriveTo self, int vertexUnseenStopMSecs=4000)
        setVertexUnseenStopMSecs(ArActionTriangleDriveTo self)
        """
        return _AriaPy.ArActionTriangleDriveTo_setVertexUnseenStopMSecs(self, vertexUnseenStopMSecs)


    def getVertexUnseenStopMSecs(self):
        """getVertexUnseenStopMSecs(ArActionTriangleDriveTo self) -> int"""
        return _AriaPy.ArActionTriangleDriveTo_getVertexUnseenStopMSecs(self)


    def setMaxDistBetweenLinePoints(self, maxDistBetweenLinePoints=0):
        """
        setMaxDistBetweenLinePoints(ArActionTriangleDriveTo self, int maxDistBetweenLinePoints=0)
        setMaxDistBetweenLinePoints(ArActionTriangleDriveTo self)
        """
        return _AriaPy.ArActionTriangleDriveTo_setMaxDistBetweenLinePoints(self, maxDistBetweenLinePoints)


    def setMaxLateralDist(self, maxLateralDist=0):
        """
        setMaxLateralDist(ArActionTriangleDriveTo self, int maxLateralDist=0)
        setMaxLateralDist(ArActionTriangleDriveTo self)
        """
        return _AriaPy.ArActionTriangleDriveTo_setMaxLateralDist(self, maxLateralDist)


    def setMaxAngleMisalignment(self, maxAngleMisalignment=0):
        """
        setMaxAngleMisalignment(ArActionTriangleDriveTo self, int maxAngleMisalignment=0)
        setMaxAngleMisalignment(ArActionTriangleDriveTo self)
        """
        return _AriaPy.ArActionTriangleDriveTo_setMaxAngleMisalignment(self, maxAngleMisalignment)

    STATE_INACTIVE = _AriaPy.ArActionTriangleDriveTo_STATE_INACTIVE
    STATE_ACQUIRE = _AriaPy.ArActionTriangleDriveTo_STATE_ACQUIRE
    STATE_SEARCHING = _AriaPy.ArActionTriangleDriveTo_STATE_SEARCHING
    STATE_GOTO_APPROACH = _AriaPy.ArActionTriangleDriveTo_STATE_GOTO_APPROACH
    STATE_ALIGN_APPROACH = _AriaPy.ArActionTriangleDriveTo_STATE_ALIGN_APPROACH
    STATE_GOTO_VERTEX = _AriaPy.ArActionTriangleDriveTo_STATE_GOTO_VERTEX
    STATE_GOTO_FINAL = _AriaPy.ArActionTriangleDriveTo_STATE_GOTO_FINAL
    STATE_ALIGN_FINAL = _AriaPy.ArActionTriangleDriveTo_STATE_ALIGN_FINAL
    STATE_SUCCEEDED = _AriaPy.ArActionTriangleDriveTo_STATE_SUCCEEDED
    STATE_FAILED = _AriaPy.ArActionTriangleDriveTo_STATE_FAILED

    def getState(self):
        """getState(ArActionTriangleDriveTo self) -> ArActionTriangleDriveTo::State"""
        return _AriaPy.ArActionTriangleDriveTo_getState(self)


    def getVertexSeen(self):
        """getVertexSeen(ArActionTriangleDriveTo self) -> bool"""
        return _AriaPy.ArActionTriangleDriveTo_getVertexSeen(self)


    def setLineFinder(self, lineFinder):
        """setLineFinder(ArActionTriangleDriveTo self, ArLineFinder lineFinder)"""
        return _AriaPy.ArActionTriangleDriveTo_setLineFinder(self, lineFinder)


    def getLineFinder(self):
        """getLineFinder(ArActionTriangleDriveTo self) -> ArLineFinder"""
        return _AriaPy.ArActionTriangleDriveTo_getLineFinder(self)


    def setLogging(self, *args):
        """
        setLogging(ArActionTriangleDriveTo self, bool logging)
        setLogging(ArActionTriangleDriveTo self) -> bool
        """
        return _AriaPy.ArActionTriangleDriveTo_setLogging(self, *args)


    def activate(self):
        """activate(ArActionTriangleDriveTo self)"""
        return _AriaPy.ArActionTriangleDriveTo_activate(self)


    def deactivate(self):
        """deactivate(ArActionTriangleDriveTo self)"""
        return _AriaPy.ArActionTriangleDriveTo_deactivate(self)


    def setRobot(self, robot):
        """setRobot(ArActionTriangleDriveTo self, ArRobot robot)"""
        return _AriaPy.ArActionTriangleDriveTo_setRobot(self, robot)


    def fire(self, currentDesired):
        """fire(ArActionTriangleDriveTo self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionTriangleDriveTo_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionTriangleDriveTo self) -> ArActionDesired"""
        return _AriaPy.ArActionTriangleDriveTo_getDesired(self)

ArActionTriangleDriveTo_swigregister = _AriaPy.ArActionTriangleDriveTo_swigregister
ArActionTriangleDriveTo_swigregister(ArActionTriangleDriveTo)

class ArActionTurn(ArAction):
    """Proxy of C++ ArActionTurn 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__(ArActionTurn self, char const * name, double speedStartTurn=200, double speedFullTurn=100, double turnAmount=15) -> ArActionTurn
        __init__(ArActionTurn self, char const * name, double speedStartTurn=200, double speedFullTurn=100) -> ArActionTurn
        __init__(ArActionTurn self, char const * name, double speedStartTurn=200) -> ArActionTurn
        __init__(ArActionTurn self, char const * name) -> ArActionTurn
        __init__(ArActionTurn self) -> ArActionTurn
        """
        this = _AriaPy.new_ArActionTurn(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionTurn
    __del__ = lambda self: None

    def fire(self, currentDesired):
        """fire(ArActionTurn self, ArActionDesired currentDesired) -> ArActionDesired"""
        return _AriaPy.ArActionTurn_fire(self, currentDesired)


    def getDesired(self):
        """getDesired(ArActionTurn self) -> ArActionDesired"""
        return _AriaPy.ArActionTurn_getDesired(self)

ArActionTurn_swigregister = _AriaPy.ArActionTurn_swigregister
ArActionTurn_swigregister(ArActionTurn)

class ArAnalogGyro(object):
    """Proxy of C++ ArAnalogGyro 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, robot):
        """__init__(ArAnalogGyro self, ArRobot robot) -> ArAnalogGyro"""
        this = _AriaPy.new_ArAnalogGyro(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArAnalogGyro
    __del__ = lambda self: None

    def isActive(self):
        """isActive(ArAnalogGyro self) -> bool"""
        return _AriaPy.ArAnalogGyro_isActive(self)


    def activate(self):
        """activate(ArAnalogGyro self)"""
        return _AriaPy.ArAnalogGyro_activate(self)


    def deactivate(self):
        """deactivate(ArAnalogGyro self)"""
        return _AriaPy.ArAnalogGyro_deactivate(self)


    def hasGyroOnlyMode(self):
        """hasGyroOnlyMode(ArAnalogGyro self) -> bool"""
        return _AriaPy.ArAnalogGyro_hasGyroOnlyMode(self)


    def isGyroOnlyActive(self):
        """isGyroOnlyActive(ArAnalogGyro self) -> bool"""
        return _AriaPy.ArAnalogGyro_isGyroOnlyActive(self)


    def activateGyroOnly(self):
        """activateGyroOnly(ArAnalogGyro self)"""
        return _AriaPy.ArAnalogGyro_activateGyroOnly(self)


    def hasNoInternalData(self):
        """hasNoInternalData(ArAnalogGyro self) -> bool"""
        return _AriaPy.ArAnalogGyro_hasNoInternalData(self)


    def haveGottenData(self):
        """haveGottenData(ArAnalogGyro self) -> bool"""
        return _AriaPy.ArAnalogGyro_haveGottenData(self)


    def getHeading(self):
        """getHeading(ArAnalogGyro self) -> double"""
        return _AriaPy.ArAnalogGyro_getHeading(self)


    def getTemperature(self):
        """getTemperature(ArAnalogGyro self) -> int"""
        return _AriaPy.ArAnalogGyro_getTemperature(self)


    def setFilterModel(self, gyroSigma, inertialVar, rotVar, transVar):
        """setFilterModel(ArAnalogGyro self, double gyroSigma, double inertialVar, double rotVar, double transVar)"""
        return _AriaPy.ArAnalogGyro_setFilterModel(self, gyroSigma, inertialVar, rotVar, transVar)


    def getPacCount(self):
        """getPacCount(ArAnalogGyro self) -> int"""
        return _AriaPy.ArAnalogGyro_getPacCount(self)


    def getAverage(self):
        """getAverage(ArAnalogGyro self) -> double"""
        return _AriaPy.ArAnalogGyro_getAverage(self)


    def getAverageTaken(self):
        """getAverageTaken(ArAnalogGyro self) -> ArTime"""
        return _AriaPy.ArAnalogGyro_getAverageTaken(self)


    def getScalingFactor(self):
        """getScalingFactor(ArAnalogGyro self) -> double"""
        return _AriaPy.ArAnalogGyro_getScalingFactor(self)


    def setScalingFactor(self, factor):
        """setScalingFactor(ArAnalogGyro self, double factor)"""
        return _AriaPy.ArAnalogGyro_setScalingFactor(self, factor)


    def handleGyroPacket(self, packet):
        """handleGyroPacket(ArAnalogGyro self, ArRobotPacket packet) -> bool"""
        return _AriaPy.ArAnalogGyro_handleGyroPacket(self, packet)


    def encoderCorrect(self, deltaPose):
        """encoderCorrect(ArAnalogGyro self, ArPoseWithTime deltaPose) -> double"""
        return _AriaPy.ArAnalogGyro_encoderCorrect(self, deltaPose)


    def stabilizingCallback(self):
        """stabilizingCallback(ArAnalogGyro self)"""
        return _AriaPy.ArAnalogGyro_stabilizingCallback(self)


    def userTaskCallback(self):
        """userTaskCallback(ArAnalogGyro self)"""
        return _AriaPy.ArAnalogGyro_userTaskCallback(self)


    def setLogAnomalies(self, logAnomalies):
        """setLogAnomalies(ArAnalogGyro self, bool logAnomalies)"""
        return _AriaPy.ArAnalogGyro_setLogAnomalies(self, logAnomalies)

ArAnalogGyro_swigregister = _AriaPy.ArAnalogGyro_swigregister
ArAnalogGyro_swigregister(ArAnalogGyro)

class ArArg(object):
    """Proxy of C++ ArArg class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    INVALID = _AriaPy.ArArg_INVALID
    INT = _AriaPy.ArArg_INT
    DOUBLE = _AriaPy.ArArg_DOUBLE
    STRING = _AriaPy.ArArg_STRING
    BOOL = _AriaPy.ArArg_BOOL
    POSE = _AriaPy.ArArg_POSE
    FUNCTOR = _AriaPy.ArArg_FUNCTOR
    DESCRIPTION_HOLDER = _AriaPy.ArArg_DESCRIPTION_HOLDER
    LAST_TYPE = _AriaPy.ArArg_LAST_TYPE
    TYPE_COUNT = _AriaPy.ArArg_TYPE_COUNT

    def __init__(self, *args):
        """
        __init__(ArArg self) -> ArArg
        __init__(ArArg self, char const * name, int * pointer, char const * description, int minInt, int maxInt) -> ArArg
        __init__(ArArg self, char const * name, int * pointer, char const * description, int minInt) -> ArArg
        __init__(ArArg self, char const * name, int * pointer, char const * description) -> ArArg
        __init__(ArArg self, char const * name, int * pointer) -> ArArg
        __init__(ArArg self, char const * name, double * pointer, char const * description, double minDouble, double maxDouble) -> ArArg
        __init__(ArArg self, char const * name, double * pointer, char const * description, double minDouble) -> ArArg
        __init__(ArArg self, char const * name, double * pointer, char const * description) -> ArArg
        __init__(ArArg self, char const * name, double * pointer) -> ArArg
        __init__(ArArg self, char const * name, bool * pointer, char const * description) -> ArArg
        __init__(ArArg self, char const * name, bool * pointer) -> ArArg
        __init__(ArArg self, char const * name, ArPose pointer, char const * description) -> ArArg
        __init__(ArArg self, char const * name, ArPose pointer) -> ArArg
        __init__(ArArg self, char const * name, char * pointer, char const * description, size_t maxStrLen) -> ArArg
        __init__(ArArg self, char const * name, ArRetFunctor1_Bool_ArgumentBuilderP setFunctor, ArRetFunctor< std::list< ArArgumentBuilder *,std::allocator< ArArgumentBuilder * > > const * > * getFunctor, char const * description) -> ArArg
        __init__(ArArg self, char const * description) -> ArArg
        __init__(ArArg self, ArArg arg) -> ArArg
        """
        this = _AriaPy.new_ArArg(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArArg
    __del__ = lambda self: None

    def getType(self):
        """getType(ArArg self) -> ArArg::Type"""
        return _AriaPy.ArArg_getType(self)


    def getName(self):
        """getName(ArArg self) -> char const *"""
        return _AriaPy.ArArg_getName(self)


    def getDescription(self):
        """getDescription(ArArg self) -> char const *"""
        return _AriaPy.ArArg_getDescription(self)


    def setInt(self, val):
        """setInt(ArArg self, int val) -> bool"""
        return _AriaPy.ArArg_setInt(self, val)


    def setDouble(self, val):
        """setDouble(ArArg self, double val) -> bool"""
        return _AriaPy.ArArg_setDouble(self, val)


    def setBool(self, val):
        """setBool(ArArg self, bool val) -> bool"""
        return _AriaPy.ArArg_setBool(self, val)


    def setPose(self, pose):
        """setPose(ArArg self, ArPose pose) -> bool"""
        return _AriaPy.ArArg_setPose(self, pose)


    def setString(self, str):
        """setString(ArArg self, char const * str) -> bool"""
        return _AriaPy.ArArg_setString(self, str)


    def setArgWithFunctor(self, argument):
        """setArgWithFunctor(ArArg self, ArArgumentBuilder argument) -> bool"""
        return _AriaPy.ArArg_setArgWithFunctor(self, argument)


    def getInt(self):
        """getInt(ArArg self) -> int"""
        return _AriaPy.ArArg_getInt(self)


    def getDouble(self):
        """getDouble(ArArg self) -> double"""
        return _AriaPy.ArArg_getDouble(self)


    def getBool(self):
        """getBool(ArArg self) -> bool"""
        return _AriaPy.ArArg_getBool(self)


    def getPose(self):
        """getPose(ArArg self) -> ArPose"""
        return _AriaPy.ArArg_getPose(self)


    def getString(self):
        """getString(ArArg self) -> char const *"""
        return _AriaPy.ArArg_getString(self)


    def getArgsWithFunctor(self):
        """getArgsWithFunctor(ArArg self) -> ArArgumentBuilderPtrList"""
        return _AriaPy.ArArg_getArgsWithFunctor(self)


    def log(self):
        """log(ArArg self)"""
        return _AriaPy.ArArg_log(self)


    def getMinInt(self):
        """getMinInt(ArArg self) -> int"""
        return _AriaPy.ArArg_getMinInt(self)


    def getMaxInt(self):
        """getMaxInt(ArArg self) -> int"""
        return _AriaPy.ArArg_getMaxInt(self)


    def getMinDouble(self):
        """getMinDouble(ArArg self) -> double"""
        return _AriaPy.ArArg_getMinDouble(self)


    def getMaxDouble(self):
        """getMaxDouble(ArArg self) -> double"""
        return _AriaPy.ArArg_getMaxDouble(self)


    def getConfigPrioritySet(self):
        """getConfigPrioritySet(ArArg self) -> bool"""
        return _AriaPy.ArArg_getConfigPrioritySet(self)


    def getConfigPriority(self):
        """getConfigPriority(ArArg self) -> ArPriority::Priority"""
        return _AriaPy.ArArg_getConfigPriority(self)


    def setConfigPriority(self, priority):
        """setConfigPriority(ArArg self, ArPriority::Priority priority)"""
        return _AriaPy.ArArg_setConfigPriority(self, priority)

ArArg_swigregister = _AriaPy.ArArg_swigregister
ArArg_swigregister(ArArg)

class ArArgumentBuilder(object):
    """Proxy of C++ ArArgumentBuilder 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__(ArArgumentBuilder self, size_t argvLen=512, char extraSpaceChar, bool ignoreNormalSpaces=False, bool isPreCompressQuotes=False) -> ArArgumentBuilder
        __init__(ArArgumentBuilder self, size_t argvLen=512, char extraSpaceChar, bool ignoreNormalSpaces=False) -> ArArgumentBuilder
        __init__(ArArgumentBuilder self, size_t argvLen=512, char extraSpaceChar) -> ArArgumentBuilder
        __init__(ArArgumentBuilder self, size_t argvLen=512) -> ArArgumentBuilder
        __init__(ArArgumentBuilder self) -> ArArgumentBuilder
        __init__(ArArgumentBuilder self, ArArgumentBuilder builder) -> ArArgumentBuilder
        """
        this = _AriaPy.new_ArArgumentBuilder(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArArgumentBuilder
    __del__ = lambda self: None

    def addPlain(self, str, position=-1):
        """
        addPlain(ArArgumentBuilder self, char const * str, int position=-1)
        addPlain(ArArgumentBuilder self, char const * str)
        """
        return _AriaPy.ArArgumentBuilder_addPlain(self, str, position)


    def addPlainAsIs(self, str, position=-1):
        """
        addPlainAsIs(ArArgumentBuilder self, char const * str, int position=-1)
        addPlainAsIs(ArArgumentBuilder self, char const * str)
        """
        return _AriaPy.ArArgumentBuilder_addPlainAsIs(self, str, position)


    def addStrings(self, *args):
        """
        addStrings(ArArgumentBuilder self, char ** argv, int argc, int position=-1)
        addStrings(ArArgumentBuilder self, char ** argv, int argc)
        addStrings(ArArgumentBuilder self, int argc, char ** argv, int position=-1)
        addStrings(ArArgumentBuilder self, int argc, char ** argv)
        """
        return _AriaPy.ArArgumentBuilder_addStrings(self, *args)


    def addStringsAsIs(self, argc, argv, position=-1):
        """
        addStringsAsIs(ArArgumentBuilder self, int argc, char ** argv, int position=-1)
        addStringsAsIs(ArArgumentBuilder self, int argc, char ** argv)
        """
        return _AriaPy.ArArgumentBuilder_addStringsAsIs(self, argc, argv, position)


    def getFullString(self):
        """getFullString(ArArgumentBuilder self) -> char const *"""
        return _AriaPy.ArArgumentBuilder_getFullString(self)


    def setFullString(self, str):
        """setFullString(ArArgumentBuilder self, char const * str)"""
        return _AriaPy.ArArgumentBuilder_setFullString(self, str)


    def getExtraString(self):
        """getExtraString(ArArgumentBuilder self) -> char const *"""
        return _AriaPy.ArArgumentBuilder_getExtraString(self)


    def setExtraString(self, str):
        """setExtraString(ArArgumentBuilder self, char const * str)"""
        return _AriaPy.ArArgumentBuilder_setExtraString(self, str)


    def log(self):
        """log(ArArgumentBuilder self)"""
        return _AriaPy.ArArgumentBuilder_log(self)


    def getArgc(self):
        """getArgc(ArArgumentBuilder self) -> size_t"""
        return _AriaPy.ArArgumentBuilder_getArgc(self)


    def getArgv(self):
        """getArgv(ArArgumentBuilder self) -> char **"""
        return _AriaPy.ArArgumentBuilder_getArgv(self)


    def getArg(self, whichArg):
        """getArg(ArArgumentBuilder self, size_t whichArg) -> char const *"""
        return _AriaPy.ArArgumentBuilder_getArg(self, whichArg)


    def isArgBool(self, whichArg):
        """isArgBool(ArArgumentBuilder self, size_t whichArg) -> bool"""
        return _AriaPy.ArArgumentBuilder_isArgBool(self, whichArg)


    def getArgBool(self, whichArg, ok=None):
        """
        getArgBool(ArArgumentBuilder self, size_t whichArg, bool * ok=None) -> bool
        getArgBool(ArArgumentBuilder self, size_t whichArg) -> bool
        """
        return _AriaPy.ArArgumentBuilder_getArgBool(self, whichArg, ok)


    def isArgInt(self, whichArg, forceHex=False):
        """
        isArgInt(ArArgumentBuilder self, size_t whichArg, bool forceHex=False) -> bool
        isArgInt(ArArgumentBuilder self, size_t whichArg) -> bool
        """
        return _AriaPy.ArArgumentBuilder_isArgInt(self, whichArg, forceHex)


    def getArgInt(self, whichArg, ok=None, forceHex=False):
        """
        getArgInt(ArArgumentBuilder self, size_t whichArg, bool * ok=None, bool forceHex=False) -> int
        getArgInt(ArArgumentBuilder self, size_t whichArg, bool * ok=None) -> int
        getArgInt(ArArgumentBuilder self, size_t whichArg) -> int
        """
        return _AriaPy.ArArgumentBuilder_getArgInt(self, whichArg, ok, forceHex)


    def isArgLongLongInt(self, whichArg):
        """isArgLongLongInt(ArArgumentBuilder self, size_t whichArg) -> bool"""
        return _AriaPy.ArArgumentBuilder_isArgLongLongInt(self, whichArg)


    def getArgLongLongInt(self, whichArg, ok=None):
        """
        getArgLongLongInt(ArArgumentBuilder self, size_t whichArg, bool * ok=None) -> int
        getArgLongLongInt(ArArgumentBuilder self, size_t whichArg) -> int
        """
        return _AriaPy.ArArgumentBuilder_getArgLongLongInt(self, whichArg, ok)


    def isArgDouble(self, whichArg):
        """isArgDouble(ArArgumentBuilder self, size_t whichArg) -> bool"""
        return _AriaPy.ArArgumentBuilder_isArgDouble(self, whichArg)


    def getArgDouble(self, whichArg, ok=None):
        """
        getArgDouble(ArArgumentBuilder self, size_t whichArg, bool * ok=None) -> double
        getArgDouble(ArArgumentBuilder self, size_t whichArg) -> double
        """
        return _AriaPy.ArArgumentBuilder_getArgDouble(self, whichArg, ok)


    def removeArg(self, which, isRebuildFullString=False):
        """
        removeArg(ArArgumentBuilder self, size_t which, bool isRebuildFullString=False)
        removeArg(ArArgumentBuilder self, size_t which)
        """
        return _AriaPy.ArArgumentBuilder_removeArg(self, which, isRebuildFullString)


    def compressQuoted(self, stripQuotationMarks=False):
        """
        compressQuoted(ArArgumentBuilder self, bool stripQuotationMarks=False)
        compressQuoted(ArArgumentBuilder self)
        """
        return _AriaPy.ArArgumentBuilder_compressQuoted(self, stripQuotationMarks)


    def setQuiet(self, isQuiet):
        """setQuiet(ArArgumentBuilder self, bool isQuiet)"""
        return _AriaPy.ArArgumentBuilder_setQuiet(self, isQuiet)

ArArgumentBuilder_swigregister = _AriaPy.ArArgumentBuilder_swigregister
ArArgumentBuilder_swigregister(ArArgumentBuilder)

class ArArgumentBuilderCompareOp(object):
    """Proxy of C++ ArArgumentBuilderCompareOp class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __call__(self, arg1, arg2):
        """__call__(ArArgumentBuilderCompareOp self, ArArgumentBuilder arg1, ArArgumentBuilder arg2) -> bool"""
        return _AriaPy.ArArgumentBuilderCompareOp___call__(self, arg1, arg2)


    def __init__(self):
        """__init__(ArArgumentBuilderCompareOp self) -> ArArgumentBuilderCompareOp"""
        this = _AriaPy.new_ArArgumentBuilderCompareOp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArArgumentBuilderCompareOp
    __del__ = lambda self: None
ArArgumentBuilderCompareOp_swigregister = _AriaPy.ArArgumentBuilderCompareOp_swigregister
ArArgumentBuilderCompareOp_swigregister(ArArgumentBuilderCompareOp)

class ArArgumentParser(object):
    """Proxy of C++ ArArgumentParser 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__(ArArgumentParser self, int * argc) -> ArArgumentParser
        __init__(ArArgumentParser self, ArArgumentBuilder builder) -> ArArgumentParser
        """
        this = _AriaPy.new_ArArgumentParser(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArArgumentParser
    __del__ = lambda self: None

    def setWasReallySetOnlyTrue(self, wasReallySetOnlyTrue):
        """setWasReallySetOnlyTrue(ArArgumentParser self, bool wasReallySetOnlyTrue)"""
        return _AriaPy.ArArgumentParser_setWasReallySetOnlyTrue(self, wasReallySetOnlyTrue)


    def getWasReallySetOnlyTrue(self):
        """getWasReallySetOnlyTrue(ArArgumentParser self) -> bool"""
        return _AriaPy.ArArgumentParser_getWasReallySetOnlyTrue(self)


    def checkArgument(self, argument):
        """checkArgument(ArArgumentParser self, char const * argument) -> bool"""
        return _AriaPy.ArArgumentParser_checkArgument(self, argument)


    def checkParameterArgument(self, argument, returnFirst=False):
        """
        checkParameterArgument(ArArgumentParser self, char const * argument, bool returnFirst=False) -> char
        checkParameterArgument(ArArgumentParser self, char const * argument) -> char *
        """
        return _AriaPy.ArArgumentParser_checkParameterArgument(self, argument, returnFirst)


    def checkParameterArgumentString(self, argument, dest, wasReallySet=None, returnFirst=False):
        """
        checkParameterArgumentString(ArArgumentParser self, char const * argument, char const ** dest, bool * wasReallySet=None, bool returnFirst=False) -> bool
        checkParameterArgumentString(ArArgumentParser self, char const * argument, char const ** dest, bool * wasReallySet=None) -> bool
        checkParameterArgumentString(ArArgumentParser self, char const * argument, char const ** dest) -> bool
        """
        return _AriaPy.ArArgumentParser_checkParameterArgumentString(self, argument, dest, wasReallySet, returnFirst)


    def checkParameterArgumentInteger(self, argument, dest, wasReallySet=None, returnFirst=False):
        """
        checkParameterArgumentInteger(ArArgumentParser self, char const * argument, int * dest, bool * wasReallySet=None, bool returnFirst=False) -> bool
        checkParameterArgumentInteger(ArArgumentParser self, char const * argument, int * dest, bool * wasReallySet=None) -> bool
        checkParameterArgumentInteger(ArArgumentParser self, char const * argument, int * dest) -> bool
        """
        return _AriaPy.ArArgumentParser_checkParameterArgumentInteger(self, argument, dest, wasReallySet, returnFirst)


    def checkParameterArgumentBool(self, argument, dest, wasReallySet=None, returnFirst=False):
        """
        checkParameterArgumentBool(ArArgumentParser self, char const * argument, bool * dest, bool * wasReallySet=None, bool returnFirst=False) -> bool
        checkParameterArgumentBool(ArArgumentParser self, char const * argument, bool * dest, bool * wasReallySet=None) -> bool
        checkParameterArgumentBool(ArArgumentParser self, char const * argument, bool * dest) -> bool
        """
        return _AriaPy.ArArgumentParser_checkParameterArgumentBool(self, argument, dest, wasReallySet, returnFirst)


    def checkParameterArgumentFloat(self, argument, dest, wasReallySet=None, returnFirst=False):
        """
        checkParameterArgumentFloat(ArArgumentParser self, char const * argument, float * dest, bool * wasReallySet=None, bool returnFirst=False) -> bool
        checkParameterArgumentFloat(ArArgumentParser self, char const * argument, float * dest, bool * wasReallySet=None) -> bool
        checkParameterArgumentFloat(ArArgumentParser self, char const * argument, float * dest) -> bool
        """
        return _AriaPy.ArArgumentParser_checkParameterArgumentFloat(self, argument, dest, wasReallySet, returnFirst)


    def checkParameterArgumentDouble(self, argument, dest, wasReallySet=None, returnFirst=False):
        """
        checkParameterArgumentDouble(ArArgumentParser self, char const * argument, double * dest, bool * wasReallySet=None, bool returnFirst=False) -> bool
        checkParameterArgumentDouble(ArArgumentParser self, char const * argument, double * dest, bool * wasReallySet=None) -> bool
        checkParameterArgumentDouble(ArArgumentParser self, char const * argument, double * dest) -> bool
        """
        return _AriaPy.ArArgumentParser_checkParameterArgumentDouble(self, argument, dest, wasReallySet, returnFirst)


    def addDefaultArgument(self, argument, position=-1):
        """
        addDefaultArgument(ArArgumentParser self, char const * argument, int position=-1)
        addDefaultArgument(ArArgumentParser self, char const * argument)
        """
        return _AriaPy.ArArgumentParser_addDefaultArgument(self, argument, position)


    def addDefaultArgumentAsIs(self, argument, position=-1):
        """
        addDefaultArgumentAsIs(ArArgumentParser self, char const * argument, int position=-1)
        addDefaultArgumentAsIs(ArArgumentParser self, char const * argument)
        """
        return _AriaPy.ArArgumentParser_addDefaultArgumentAsIs(self, argument, position)


    def loadDefaultArguments(self, positon=1):
        """
        loadDefaultArguments(ArArgumentParser self, int positon=1)
        loadDefaultArguments(ArArgumentParser self)
        """
        return _AriaPy.ArArgumentParser_loadDefaultArguments(self, positon)


    def checkHelpAndWarnUnparsed(self, numArgsOkay=0):
        """
        checkHelpAndWarnUnparsed(ArArgumentParser self, unsigned int numArgsOkay=0) -> bool
        checkHelpAndWarnUnparsed(ArArgumentParser self) -> bool
        """
        return _AriaPy.ArArgumentParser_checkHelpAndWarnUnparsed(self, numArgsOkay)


    def getArgc(self):
        """getArgc(ArArgumentParser self) -> size_t"""
        return _AriaPy.ArArgumentParser_getArgc(self)


    def getArgv(self):
        """getArgv(ArArgumentParser self) -> char **"""
        return _AriaPy.ArArgumentParser_getArgv(self)


    def getArgumentBuilder(self):
        """getArgumentBuilder(ArArgumentParser self) -> ArArgumentBuilder"""
        return _AriaPy.ArArgumentParser_getArgumentBuilder(self)


    def getArg(self, whichArg):
        """getArg(ArArgumentParser self, size_t whichArg) -> char const *"""
        return _AriaPy.ArArgumentParser_getArg(self, whichArg)


    def log(self):
        """log(ArArgumentParser self)"""
        return _AriaPy.ArArgumentParser_log(self)


    def getStartingArguments(self):
        """getStartingArguments(ArArgumentParser self) -> char const *"""
        return _AriaPy.ArArgumentParser_getStartingArguments(self)


    def removeArg(self, which):
        """removeArg(ArArgumentParser self, size_t which)"""
        return _AriaPy.ArArgumentParser_removeArg(self, which)


    def addDefaultArgumentFile(file):
        """addDefaultArgumentFile(char const * file)"""
        return _AriaPy.ArArgumentParser_addDefaultArgumentFile(file)

    addDefaultArgumentFile = staticmethod(addDefaultArgumentFile)

    def addDefaultArgumentEnv(env):
        """addDefaultArgumentEnv(char const * env)"""
        return _AriaPy.ArArgumentParser_addDefaultArgumentEnv(env)

    addDefaultArgumentEnv = staticmethod(addDefaultArgumentEnv)

    def logDefaultArgumentLocations():
        """logDefaultArgumentLocations()"""
        return _AriaPy.ArArgumentParser_logDefaultArgumentLocations()

    logDefaultArgumentLocations = staticmethod(logDefaultArgumentLocations)
ArArgumentParser_swigregister = _AriaPy.ArArgumentParser_swigregister
ArArgumentParser_swigregister(ArArgumentParser)

def ArArgumentParser_addDefaultArgumentFile(file):
    """ArArgumentParser_addDefaultArgumentFile(char const * file)"""
    return _AriaPy.ArArgumentParser_addDefaultArgumentFile(file)

def ArArgumentParser_addDefaultArgumentEnv(env):
    """ArArgumentParser_addDefaultArgumentEnv(char const * env)"""
    return _AriaPy.ArArgumentParser_addDefaultArgumentEnv(env)

def ArArgumentParser_logDefaultArgumentLocations():
    """ArArgumentParser_logDefaultArgumentLocations()"""
    return _AriaPy.ArArgumentParser_logDefaultArgumentLocations()

class ArBumpers(ArRangeDevice):
    """Proxy of C++ ArBumpers 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__(ArBumpers self, size_t currentBufferSize=30, size_t cumulativeBufferSize=30, char const * name, int maxSecondsToKeepCurrent=15, double angleRange=135) -> ArBumpers
        __init__(ArBumpers self, size_t currentBufferSize=30, size_t cumulativeBufferSize=30, char const * name, int maxSecondsToKeepCurrent=15) -> ArBumpers
        __init__(ArBumpers self, size_t currentBufferSize=30, size_t cumulativeBufferSize=30, char const * name) -> ArBumpers
        __init__(ArBumpers self, size_t currentBufferSize=30, size_t cumulativeBufferSize=30) -> ArBumpers
        __init__(ArBumpers self, size_t currentBufferSize=30) -> ArBumpers
        __init__(ArBumpers self) -> ArBumpers
        """
        this = _AriaPy.new_ArBumpers(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArBumpers
    __del__ = lambda self: None

    def setRobot(self, robot):
        """setRobot(ArBumpers self, ArRobot robot)"""
        return _AriaPy.ArBumpers_setRobot(self, robot)


    def processReadings(self):
        """processReadings(ArBumpers self)"""
        return _AriaPy.ArBumpers_processReadings(self)


    def addBumpToBuffer(self, bumpValue, whichBumper):
        """addBumpToBuffer(ArBumpers self, int bumpValue, int whichBumper)"""
        return _AriaPy.ArBumpers_addBumpToBuffer(self, bumpValue, whichBumper)

ArBumpers_swigregister = _AriaPy.ArBumpers_swigregister
ArBumpers_swigregister(ArBumpers)

class ArCameraCollection(object):
    """Proxy of C++ ArCameraCollection 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):
        """__init__(ArCameraCollection self) -> ArCameraCollection"""
        this = _AriaPy.new_ArCameraCollection()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArCameraCollection
    __del__ = lambda self: None

    def addCamera(self, cameraName, cameraType, displayName, displayType):
        """addCamera(ArCameraCollection self, char const * cameraName, char const * cameraType, char const * displayName, char const * displayType) -> bool"""
        return _AriaPy.ArCameraCollection_addCamera(self, cameraName, cameraType, displayName, displayType)


    def removeCamera(self, cameraName):
        """removeCamera(ArCameraCollection self, char const * cameraName) -> bool"""
        return _AriaPy.ArCameraCollection_removeCamera(self, cameraName)


    def addCameraCommand(self, cameraName, command, cameraCommandName, requestInterval=-1):
        """
        addCameraCommand(ArCameraCollection self, char const * cameraName, char const * command, char const * cameraCommandName, int requestInterval=-1) -> bool
        addCameraCommand(ArCameraCollection self, char const * cameraName, char const * command, char const * cameraCommandName) -> bool
        """
        return _AriaPy.ArCameraCollection_addCameraCommand(self, cameraName, command, cameraCommandName, requestInterval)


    def removeCameraCommand(self, cameraName, command):
        """removeCameraCommand(ArCameraCollection self, char const * cameraName, char const * command) -> bool"""
        return _AriaPy.ArCameraCollection_removeCameraCommand(self, cameraName, command)


    def addParameter(self, cameraName, source, param):
        """addParameter(ArCameraCollection self, char const * cameraName, ArCameraParameterSource source, ArConfigArg param) -> bool"""
        return _AriaPy.ArCameraCollection_addParameter(self, cameraName, source, param)


    def removeParameter(self, cameraName, paramName):
        """removeParameter(ArCameraCollection self, char const * cameraName, char const * paramName) -> bool"""
        return _AriaPy.ArCameraCollection_removeParameter(self, cameraName, paramName)


    def getCameraNames(self, outList):
        """getCameraNames(ArCameraCollection self, std::list< std::string,std::allocator< std::string > > & outList)"""
        return _AriaPy.ArCameraCollection_getCameraNames(self, outList)


    def getCameraType(self, cameraName):
        """getCameraType(ArCameraCollection self, char const * cameraName) -> char const *"""
        return _AriaPy.ArCameraCollection_getCameraType(self, cameraName)


    def getDisplayName(self, cameraName):
        """getDisplayName(ArCameraCollection self, char const * cameraName) -> char const *"""
        return _AriaPy.ArCameraCollection_getDisplayName(self, cameraName)


    def getDisplayType(self, cameraName):
        """getDisplayType(ArCameraCollection self, char const * cameraName) -> char const *"""
        return _AriaPy.ArCameraCollection_getDisplayType(self, cameraName)


    def getCameraCommands(self, cameraName, outList):
        """getCameraCommands(ArCameraCollection self, char const * cameraName, std::list< std::string,std::allocator< std::string > > & outList)"""
        return _AriaPy.ArCameraCollection_getCameraCommands(self, cameraName, outList)


    def getCommandName(self, cameraName, command):
        """getCommandName(ArCameraCollection self, char const * cameraName, char const * command) -> char const *"""
        return _AriaPy.ArCameraCollection_getCommandName(self, cameraName, command)


    def getRequestInterval(self, cameraName, command):
        """getRequestInterval(ArCameraCollection self, char const * cameraName, char const * command) -> int"""
        return _AriaPy.ArCameraCollection_getRequestInterval(self, cameraName, command)


    def getParameterNames(self, cameraName, outList):
        """getParameterNames(ArCameraCollection self, char const * cameraName, std::list< std::string,std::allocator< std::string > > & outList)"""
        return _AriaPy.ArCameraCollection_getParameterNames(self, cameraName, outList)


    def getParameter(self, cameraName, parameterName, paramOut):
        """getParameter(ArCameraCollection self, char const * cameraName, char const * parameterName, ArConfigArg paramOut) -> bool"""
        return _AriaPy.ArCameraCollection_getParameter(self, cameraName, parameterName, paramOut)


    def setParameter(self, cameraName, param):
        """setParameter(ArCameraCollection self, char const * cameraName, ArConfigArg param) -> bool"""
        return _AriaPy.ArCameraCollection_setParameter(self, cameraName, param)


    def exists(self, *args):
        """
        exists(ArCameraCollection self, char const * cameraName) -> bool
        exists(ArCameraCollection self, char const * cameraName, char const * command) -> bool
        """
        return _AriaPy.ArCameraCollection_exists(self, *args)


    def parameterExists(self, cameraName, paramName):
        """parameterExists(ArCameraCollection self, char const * cameraName, char const * paramName) -> bool"""
        return _AriaPy.ArCameraCollection_parameterExists(self, cameraName, paramName)


    def addModifiedCB(self, *args):
        """
        addModifiedCB(ArCameraCollection self, ArFunctor functor, ArListPos::Pos position) -> bool
        addModifiedCB(ArCameraCollection self, ArFunctor functor) -> bool
        """
        return _AriaPy.ArCameraCollection_addModifiedCB(self, *args)


    def removeModifiedCB(self, functor):
        """removeModifiedCB(ArCameraCollection self, ArFunctor functor) -> bool"""
        return _AriaPy.ArCameraCollection_removeModifiedCB(self, functor)


    def startUpdate(self):
        """startUpdate(ArCameraCollection self)"""
        return _AriaPy.ArCameraCollection_startUpdate(self)


    def endUpdate(self):
        """endUpdate(ArCameraCollection self)"""
        return _AriaPy.ArCameraCollection_endUpdate(self)


    def lock(self):
        """lock(ArCameraCollection self) -> int"""
        return _AriaPy.ArCameraCollection_lock(self)


    def tryLock(self):
        """tryLock(ArCameraCollection self) -> int"""
        return _AriaPy.ArCameraCollection_tryLock(self)


    def unlock(self):
        """unlock(ArCameraCollection self) -> int"""
        return _AriaPy.ArCameraCollection_unlock(self)

ArCameraCollection_swigregister = _AriaPy.ArCameraCollection_swigregister
ArCameraCollection_swigregister(ArCameraCollection)

class ArCameraCollectionItem(object):
    """Proxy of C++ ArCameraCollectionItem 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__ = _AriaPy.delete_ArCameraCollectionItem
    __del__ = lambda self: None

    def getCameraName(self):
        """getCameraName(ArCameraCollectionItem self) -> char const *"""
        return _AriaPy.ArCameraCollectionItem_getCameraName(self)


    def addToCameraCollection(self, collection):
        """addToCameraCollection(ArCameraCollectionItem self, ArCameraCollection collection)"""
        return _AriaPy.ArCameraCollectionItem_addToCameraCollection(self, collection)

ArCameraCollectionItem_swigregister = _AriaPy.ArCameraCollectionItem_swigregister
ArCameraCollectionItem_swigregister(ArCameraCollectionItem)

class ArCameraParameterSource(ArCameraCollectionItem):
    """Proxy of C++ ArCameraParameterSource 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__ = _AriaPy.delete_ArCameraParameterSource
    __del__ = lambda self: None

    def getParameter(self, paramName, paramOut):
        """getParameter(ArCameraParameterSource self, char const * paramName, ArConfigArg paramOut) -> bool"""
        return _AriaPy.ArCameraParameterSource_getParameter(self, paramName, paramOut)


    def setParameter(self, param):
        """setParameter(ArCameraParameterSource self, ArConfigArg param) -> bool"""
        return _AriaPy.ArCameraParameterSource_setParameter(self, param)

ArCameraParameterSource_swigregister = _AriaPy.ArCameraParameterSource_swigregister
ArCameraParameterSource_swigregister(ArCameraParameterSource)

class ArCameraCommands(object):
    """Proxy of C++ ArCameraCommands class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    GET_CAMERA_DATA = _swig_property(_AriaPy.ArCameraCommands_GET_CAMERA_DATA_get, _AriaPy.ArCameraCommands_GET_CAMERA_DATA_set)
    GET_CAMERA_INFO = _swig_property(_AriaPy.ArCameraCommands_GET_CAMERA_INFO_get, _AriaPy.ArCameraCommands_GET_CAMERA_INFO_set)
    GET_PICTURE = _swig_property(_AriaPy.ArCameraCommands_GET_PICTURE_get, _AriaPy.ArCameraCommands_GET_PICTURE_set)
    GET_PICTURE_OPTIM = _swig_property(_AriaPy.ArCameraCommands_GET_PICTURE_OPTIM_get, _AriaPy.ArCameraCommands_GET_PICTURE_OPTIM_set)
    GET_SNAPSHOT = _swig_property(_AriaPy.ArCameraCommands_GET_SNAPSHOT_get, _AriaPy.ArCameraCommands_GET_SNAPSHOT_set)
    GET_DISPLAY = _swig_property(_AriaPy.ArCameraCommands_GET_DISPLAY_get, _AriaPy.ArCameraCommands_GET_DISPLAY_set)
    SET_CAMERA_ABS = _swig_property(_AriaPy.ArCameraCommands_SET_CAMERA_ABS_get, _AriaPy.ArCameraCommands_SET_CAMERA_ABS_set)
    SET_CAMERA_PCT = _swig_property(_AriaPy.ArCameraCommands_SET_CAMERA_PCT_get, _AriaPy.ArCameraCommands_SET_CAMERA_PCT_set)
    SET_CAMERA_REL = _swig_property(_AriaPy.ArCameraCommands_SET_CAMERA_REL_get, _AriaPy.ArCameraCommands_SET_CAMERA_REL_set)
    GET_CAMERA_MODE_LIST = _swig_property(_AriaPy.ArCameraCommands_GET_CAMERA_MODE_LIST_get, _AriaPy.ArCameraCommands_GET_CAMERA_MODE_LIST_set)
    CAMERA_MODE_UPDATED = _swig_property(_AriaPy.ArCameraCommands_CAMERA_MODE_UPDATED_get, _AriaPy.ArCameraCommands_CAMERA_MODE_UPDATED_set)
    SET_CAMERA_MODE = _swig_property(_AriaPy.ArCameraCommands_SET_CAMERA_MODE_get, _AriaPy.ArCameraCommands_SET_CAMERA_MODE_set)
    RESET_CAMERA = _swig_property(_AriaPy.ArCameraCommands_RESET_CAMERA_get, _AriaPy.ArCameraCommands_RESET_CAMERA_set)
    GET_CAMERA_DATA_INT = _swig_property(_AriaPy.ArCameraCommands_GET_CAMERA_DATA_INT_get, _AriaPy.ArCameraCommands_GET_CAMERA_DATA_INT_set)
    GET_CAMERA_INFO_INT = _swig_property(_AriaPy.ArCameraCommands_GET_CAMERA_INFO_INT_get, _AriaPy.ArCameraCommands_GET_CAMERA_INFO_INT_set)
    SET_CAMERA_ABS_INT = _swig_property(_AriaPy.ArCameraCommands_SET_CAMERA_ABS_INT_get, _AriaPy.ArCameraCommands_SET_CAMERA_ABS_INT_set)
    SET_CAMERA_REL_INT = _swig_property(_AriaPy.ArCameraCommands_SET_CAMERA_REL_INT_get, _AriaPy.ArCameraCommands_SET_CAMERA_REL_INT_set)
    SET_CAMERA_PCT_INT = _swig_property(_AriaPy.ArCameraCommands_SET_CAMERA_PCT_INT_get, _AriaPy.ArCameraCommands_SET_CAMERA_PCT_INT_set)
    GET_VIDEO = _swig_property(_AriaPy.ArCameraCommands_GET_VIDEO_get, _AriaPy.ArCameraCommands_GET_VIDEO_set)
    GET_SNAPSHOT_PLAIN = _swig_property(_AriaPy.ArCameraCommands_GET_SNAPSHOT_PLAIN_get, _AriaPy.ArCameraCommands_GET_SNAPSHOT_PLAIN_set)

    def __init__(self):
        """__init__(ArCameraCommands self) -> ArCameraCommands"""
        this = _AriaPy.new_ArCameraCommands()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArCameraCommands
    __del__ = lambda self: None
ArCameraCommands_swigregister = _AriaPy.ArCameraCommands_swigregister
ArCameraCommands_swigregister(ArCameraCommands)

class ArCommands(object):
    """Proxy of C++ ArCommands class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    PULSE = _AriaPy.ArCommands_PULSE
    OPEN = _AriaPy.ArCommands_OPEN
    CLOSE = _AriaPy.ArCommands_CLOSE
    POLLING = _AriaPy.ArCommands_POLLING
    ENABLE = _AriaPy.ArCommands_ENABLE
    SETA = _AriaPy.ArCommands_SETA
    SETV = _AriaPy.ArCommands_SETV
    SETO = _AriaPy.ArCommands_SETO
    MOVE = _AriaPy.ArCommands_MOVE
    ROTATE = _AriaPy.ArCommands_ROTATE
    SETRV = _AriaPy.ArCommands_SETRV
    VEL = _AriaPy.ArCommands_VEL
    HEAD = _AriaPy.ArCommands_HEAD
    DHEAD = _AriaPy.ArCommands_DHEAD
    SAY = _AriaPy.ArCommands_SAY
    JOYINFO = _AriaPy.ArCommands_JOYINFO
    CONFIG = _AriaPy.ArCommands_CONFIG
    ENCODER = _AriaPy.ArCommands_ENCODER
    SETRVDIR = _AriaPy.ArCommands_SETRVDIR
    RVEL = _AriaPy.ArCommands_RVEL
    DCHEAD = _AriaPy.ArCommands_DCHEAD
    SETRA = _AriaPy.ArCommands_SETRA
    SONAR = _AriaPy.ArCommands_SONAR
    STOP = _AriaPy.ArCommands_STOP
    DIGOUT = _AriaPy.ArCommands_DIGOUT
    VEL2 = _AriaPy.ArCommands_VEL2
    GRIPPER = _AriaPy.ArCommands_GRIPPER
    ADSEL = _AriaPy.ArCommands_ADSEL
    GRIPPERVAL = _AriaPy.ArCommands_GRIPPERVAL
    GRIPPERPACREQUEST = _AriaPy.ArCommands_GRIPPERPACREQUEST
    IOREQUEST = _AriaPy.ArCommands_IOREQUEST
    PTUPOS = _AriaPy.ArCommands_PTUPOS
    TTY2 = _AriaPy.ArCommands_TTY2
    GETAUX = _AriaPy.ArCommands_GETAUX
    BUMPSTALL = _AriaPy.ArCommands_BUMPSTALL
    TCM2 = _AriaPy.ArCommands_TCM2
    JOYDRIVE = _AriaPy.ArCommands_JOYDRIVE
    MOVINGBLINK = _AriaPy.ArCommands_MOVINGBLINK
    HOSTBAUD = _AriaPy.ArCommands_HOSTBAUD
    AUX1BAUD = _AriaPy.ArCommands_AUX1BAUD
    AUX2BAUD = _AriaPy.ArCommands_AUX2BAUD
    ESTOP = _AriaPy.ArCommands_ESTOP
    ESTALL = _AriaPy.ArCommands_ESTALL
    GYRO = _AriaPy.ArCommands_GYRO
    TTY4 = _AriaPy.ArCommands_TTY4
    GETAUX3 = _AriaPy.ArCommands_GETAUX3
    BATTERYINFO = _AriaPy.ArCommands_BATTERYINFO
    TTY3 = _AriaPy.ArCommands_TTY3
    GETAUX2 = _AriaPy.ArCommands_GETAUX2
    BATTEST = _AriaPy.ArCommands_BATTEST
    LOADPARAM = _AriaPy.ArCommands_LOADPARAM
    OLDSIM_LOADPARAM = _AriaPy.ArCommands_OLDSIM_LOADPARAM
    ENDSIM = _AriaPy.ArCommands_ENDSIM
    OLDSIM_EXIT = _AriaPy.ArCommands_OLDSIM_EXIT
    LOADWORLD = _AriaPy.ArCommands_LOADWORLD
    OLDSIM_LOADWORLD = _AriaPy.ArCommands_OLDSIM_LOADWORLD
    STEP = _AriaPy.ArCommands_STEP
    OLDSIM_STEP = _AriaPy.ArCommands_OLDSIM_STEP
    CALCOMP = _AriaPy.ArCommands_CALCOMP
    SETSIMORIGINTH = _AriaPy.ArCommands_SETSIMORIGINTH
    OLDSIM_SETORIGINTH = _AriaPy.ArCommands_OLDSIM_SETORIGINTH
    RESETSIMTOORIGIN = _AriaPy.ArCommands_RESETSIMTOORIGIN
    OLDSIM_RESETTOORIGIN = _AriaPy.ArCommands_OLDSIM_RESETTOORIGIN
    SOUND = _AriaPy.ArCommands_SOUND
    PLAYLIST = _AriaPy.ArCommands_PLAYLIST
    SOUNDTOG = _AriaPy.ArCommands_SOUNDTOG
    POWER_PC = _AriaPy.ArCommands_POWER_PC
    POWER_LRF = _AriaPy.ArCommands_POWER_LRF
    POWER_5V = _AriaPy.ArCommands_POWER_5V
    POWER_12V = _AriaPy.ArCommands_POWER_12V
    POWER_24V = _AriaPy.ArCommands_POWER_24V
    POWER_AUX_PC = _AriaPy.ArCommands_POWER_AUX_PC
    POWER_TOUCHSCREEN = _AriaPy.ArCommands_POWER_TOUCHSCREEN
    POWER_PTZ = _AriaPy.ArCommands_POWER_PTZ
    POWER_AUDIO = _AriaPy.ArCommands_POWER_AUDIO
    POWER_LRF2 = _AriaPy.ArCommands_POWER_LRF2
    LATVEL = _AriaPy.ArCommands_LATVEL
    LATACCEL = _AriaPy.ArCommands_LATACCEL
    SETLATV = _AriaPy.ArCommands_SETLATV
    SRECORD = _AriaPy.ArCommands_SRECORD
    MARCDEBUG = _AriaPy.ArCommands_MARCDEBUG
    WHEEL_LIGHT = _AriaPy.ArCommands_WHEEL_LIGHT
    ABSOLUTE_MAXES = _AriaPy.ArCommands_ABSOLUTE_MAXES
    SAFETY_STATE_INFO = _AriaPy.ArCommands_SAFETY_STATE_INFO
    SAFETY_SET_STATE = _AriaPy.ArCommands_SAFETY_SET_STATE
    SAFETY_DISABLE_POWER_OFF_TIMER = _AriaPy.ArCommands_SAFETY_DISABLE_POWER_OFF_TIMER
    SIM_SET_POSE = _AriaPy.ArCommands_SIM_SET_POSE
    SIM_RESET = _AriaPy.ArCommands_SIM_RESET
    SIM_LRF_ENABLE = _AriaPy.ArCommands_SIM_LRF_ENABLE
    SIM_LRF_SET_FOV_START = _AriaPy.ArCommands_SIM_LRF_SET_FOV_START
    SIM_LRF_SET_FOV_END = _AriaPy.ArCommands_SIM_LRF_SET_FOV_END
    SIM_LRF_SET_RES = _AriaPy.ArCommands_SIM_LRF_SET_RES
    SIM_CTRL = _AriaPy.ArCommands_SIM_CTRL
    SIM_STAT = _AriaPy.ArCommands_SIM_STAT
    SIM_MESSAGE = _AriaPy.ArCommands_SIM_MESSAGE
    SIM_EXIT = _AriaPy.ArCommands_SIM_EXIT

    def __init__(self):
        """__init__(ArCommands self) -> ArCommands"""
        this = _AriaPy.new_ArCommands()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArCommands
    __del__ = lambda self: None
ArCommands_swigregister = _AriaPy.ArCommands_swigregister
ArCommands_swigregister(ArCommands)

class ArCondition(object):
    """Proxy of C++ ArCondition class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    STATUS_FAILED = _AriaPy.ArCondition_STATUS_FAILED
    STATUS_FAILED_DESTROY = _AriaPy.ArCondition_STATUS_FAILED_DESTROY
    STATUS_FAILED_INIT = _AriaPy.ArCondition_STATUS_FAILED_INIT
    STATUS_WAIT_TIMEDOUT = _AriaPy.ArCondition_STATUS_WAIT_TIMEDOUT
    STATUS_WAIT_INTR = _AriaPy.ArCondition_STATUS_WAIT_INTR
    STATUS_MUTEX_FAILED_INIT = _AriaPy.ArCondition_STATUS_MUTEX_FAILED_INIT
    STATUS_MUTEX_FAILED = _AriaPy.ArCondition_STATUS_MUTEX_FAILED

    def __init__(self):
        """__init__(ArCondition self) -> ArCondition"""
        this = _AriaPy.new_ArCondition()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArCondition
    __del__ = lambda self: None

    def signal(self):
        """signal(ArCondition self) -> int"""
        return _AriaPy.ArCondition_signal(self)


    def broadcast(self):
        """broadcast(ArCondition self) -> int"""
        return _AriaPy.ArCondition_broadcast(self)


    def wait(self):
        """wait(ArCondition self) -> int"""
        return _AriaPy.ArCondition_wait(self)


    def timedWait(self, msecs):
        """timedWait(ArCondition self, unsigned int msecs) -> int"""
        return _AriaPy.ArCondition_timedWait(self, msecs)


    def getError(self, messageNumber):
        """getError(ArCondition self, int messageNumber) -> char const *"""
        return _AriaPy.ArCondition_getError(self, messageNumber)


    def setLogName(self, logName):
        """setLogName(ArCondition self, char const * logName)"""
        return _AriaPy.ArCondition_setLogName(self, logName)


    def getLogName(self):
        """getLogName(ArCondition self) -> char const *"""
        return _AriaPy.ArCondition_getLogName(self)

ArCondition_swigregister = _AriaPy.ArCondition_swigregister
ArCondition_swigregister(ArCondition)

class ArConfig(object):
    """Proxy of C++ ArConfig class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    CATEGORY_ROBOT_INTERFACE = _swig_property(_AriaPy.ArConfig_CATEGORY_ROBOT_INTERFACE_get, _AriaPy.ArConfig_CATEGORY_ROBOT_INTERFACE_set)
    CATEGORY_ROBOT_OPERATION = _swig_property(_AriaPy.ArConfig_CATEGORY_ROBOT_OPERATION_get, _AriaPy.ArConfig_CATEGORY_ROBOT_OPERATION_set)
    CATEGORY_ROBOT_PHYSICAL = _swig_property(_AriaPy.ArConfig_CATEGORY_ROBOT_PHYSICAL_get, _AriaPy.ArConfig_CATEGORY_ROBOT_PHYSICAL_set)
    CATEGORY_FLEET = _swig_property(_AriaPy.ArConfig_CATEGORY_FLEET_get, _AriaPy.ArConfig_CATEGORY_FLEET_set)
    CATEGORY_SECURITY = _swig_property(_AriaPy.ArConfig_CATEGORY_SECURITY_get, _AriaPy.ArConfig_CATEGORY_SECURITY_set)
    CATEGORY_DEBUG = _swig_property(_AriaPy.ArConfig_CATEGORY_DEBUG_get, _AriaPy.ArConfig_CATEGORY_DEBUG_set)
    __swig_destroy__ = _AriaPy.delete_ArConfig
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(ArConfig self, char const * baseDirectory=None, bool noBlanksBetweenParams=False, bool ignoreBounds=False, bool failOnBadSection=False, bool saveUnknown=True) -> ArConfig
        __init__(ArConfig self, char const * baseDirectory=None, bool noBlanksBetweenParams=False, bool ignoreBounds=False, bool failOnBadSection=False) -> ArConfig
        __init__(ArConfig self, char const * baseDirectory=None, bool noBlanksBetweenParams=False, bool ignoreBounds=False) -> ArConfig
        __init__(ArConfig self, char const * baseDirectory=None, bool noBlanksBetweenParams=False) -> ArConfig
        __init__(ArConfig self, char const * baseDirectory=None) -> ArConfig
        __init__(ArConfig self) -> ArConfig
        __init__(ArConfig self, ArConfig config) -> ArConfig
        """
        this = _AriaPy.new_ArConfig(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def copyAndDetach(self, config):
        """copyAndDetach(ArConfig self, ArConfig config)"""
        return _AriaPy.ArConfig_copyAndDetach(self, config)


    def setConfigName(self, configName, robotName=None):
        """
        setConfigName(ArConfig self, char const * configName, char const * robotName=None)
        setConfigName(ArConfig self, char const * configName)
        """
        return _AriaPy.ArConfig_setConfigName(self, configName, robotName)


    def setQuiet(self, isQuiet):
        """setQuiet(ArConfig self, bool isQuiet)"""
        return _AriaPy.ArConfig_setQuiet(self, isQuiet)


    def setTranslator(self, xlatorConfig):
        """setTranslator(ArConfig self, ArConfig xlatorConfig)"""
        return _AriaPy.ArConfig_setTranslator(self, xlatorConfig)


    def getTranslator(self):
        """getTranslator(ArConfig self) -> ArConfig"""
        return _AriaPy.ArConfig_getTranslator(self)


    def parseFile(self, *args):
        """
        parseFile(ArConfig self, char const * fileName, bool continueOnError=False, bool noFileNotFoundMessage=False, char * errorBuffer=None, size_t errorBufferLen=0, std::list< std::string,std::allocator< std::string > > * sectionsToParse=None, ArPriority::Priority highestPriority, ArPriority::Priority lowestPriority, ArConfigArg::RestartLevel * restartLevelNeeded=None) -> bool
        parseFile(ArConfig self, char const * fileName, bool continueOnError=False, bool noFileNotFoundMessage=False, char * errorBuffer=None, size_t errorBufferLen=0, std::list< std::string,std::allocator< std::string > > * sectionsToParse=None, ArPriority::Priority highestPriority, ArPriority::Priority lowestPriority) -> bool
        parseFile(ArConfig self, char const * fileName, bool continueOnError=False, bool noFileNotFoundMessage=False, char * errorBuffer=None, size_t errorBufferLen=0, std::list< std::string,std::allocator< std::string > > * sectionsToParse=None, ArPriority::Priority highestPriority) -> bool
        parseFile(ArConfig self, char const * fileName, bool continueOnError=False, bool noFileNotFoundMessage=False, char * errorBuffer=None, size_t errorBufferLen=0, std::list< std::string,std::allocator< std::string > > * sectionsToParse=None) -> bool
        parseFile(ArConfig self, char const * fileName, bool continueOnError=False, bool noFileNotFoundMessage=False, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseFile(ArConfig self, char const * fileName, bool continueOnError=False, bool noFileNotFoundMessage=False, char * errorBuffer=None) -> bool
        parseFile(ArConfig self, char const * fileName, bool continueOnError=False, bool noFileNotFoundMessage=False) -> bool
        parseFile(ArConfig self, char const * fileName, bool continueOnError=False) -> bool
        parseFile(ArConfig self, char const * fileName) -> bool
        """
        return _AriaPy.ArConfig_parseFile(self, *args)


    def writeFile(self, *args):
        """
        writeFile(ArConfig self, char const * fileName, bool append=False, std::set< std::string,std::less< std::string >,std::allocator< std::string > > * alreadyWritten=None, bool writeExtras=False, std::list< std::string,std::allocator< std::string > > * sectionsToWrite=None, ArPriority::Priority highestPriority, ArPriority::Priority lowestPriority) -> bool
        writeFile(ArConfig self, char const * fileName, bool append=False, std::set< std::string,std::less< std::string >,std::allocator< std::string > > * alreadyWritten=None, bool writeExtras=False, std::list< std::string,std::allocator< std::string > > * sectionsToWrite=None, ArPriority::Priority highestPriority) -> bool
        writeFile(ArConfig self, char const * fileName, bool append=False, std::set< std::string,std::less< std::string >,std::allocator< std::string > > * alreadyWritten=None, bool writeExtras=False, std::list< std::string,std::allocator< std::string > > * sectionsToWrite=None) -> bool
        writeFile(ArConfig self, char const * fileName, bool append=False, std::set< std::string,std::less< std::string >,std::allocator< std::string > > * alreadyWritten=None, bool writeExtras=False) -> bool
        writeFile(ArConfig self, char const * fileName, bool append=False, std::set< std::string,std::less< std::string >,std::allocator< std::string > > * alreadyWritten=None) -> bool
        writeFile(ArConfig self, char const * fileName, bool append=False) -> bool
        writeFile(ArConfig self, char const * fileName) -> bool
        """
        return _AriaPy.ArConfig_writeFile(self, *args)


    def parseResourceFile(self, *args):
        """
        parseResourceFile(ArConfig self, char const * fileName, bool continueOnError=True, char * errorBuffer=None, size_t errorBufferLen=0, std::list< std::string,std::allocator< std::string > > * sectionsToParse=None) -> bool
        parseResourceFile(ArConfig self, char const * fileName, bool continueOnError=True, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseResourceFile(ArConfig self, char const * fileName, bool continueOnError=True, char * errorBuffer=None) -> bool
        parseResourceFile(ArConfig self, char const * fileName, bool continueOnError=True) -> bool
        parseResourceFile(ArConfig self, char const * fileName) -> bool
        parseResourceFile(ArConfig self, ArArgumentBuilder builder)
        """
        return _AriaPy.ArConfig_parseResourceFile(self, *args)


    def writeResourceFile(self, *args):
        """
        writeResourceFile(ArConfig self, char const * fileName, bool append=False, std::set< std::string,std::less< std::string >,std::allocator< std::string > > * alreadyWritten=None, std::list< std::string,std::allocator< std::string > > * sectionsToWrite=None) -> bool
        writeResourceFile(ArConfig self, char const * fileName, bool append=False, std::set< std::string,std::less< std::string >,std::allocator< std::string > > * alreadyWritten=None) -> bool
        writeResourceFile(ArConfig self, char const * fileName, bool append=False) -> bool
        writeResourceFile(ArConfig self, char const * fileName) -> bool
        writeResourceFile(ArConfig self, ArArgumentBuilder builder)
        """
        return _AriaPy.ArConfig_writeResourceFile(self, *args)


    def addSection(self, categoryName, sectionName, sectionDescription):
        """addSection(ArConfig self, char const * categoryName, char const * sectionName, char const * sectionDescription) -> bool"""
        return _AriaPy.ArConfig_addSection(self, categoryName, sectionName, sectionDescription)


    def addParam(self, *args):
        """
        addParam(ArConfig self, ArConfigArg arg, char const * sectionName, ArPriority::Priority priority, char const * displayHint=None, ArConfigArg::RestartLevel restart) -> bool
        addParam(ArConfig self, ArConfigArg arg, char const * sectionName, ArPriority::Priority priority, char const * displayHint=None) -> bool
        addParam(ArConfig self, ArConfigArg arg, char const * sectionName, ArPriority::Priority priority) -> bool
        addParam(ArConfig self, ArConfigArg arg, char const * sectionName) -> bool
        addParam(ArConfig self, ArConfigArg arg) -> bool
        """
        return _AriaPy.ArConfig_addParam(self, *args)


    def addComment(self, *args):
        """
        addComment(ArConfig self, char const * comment, char const * sectionName, ArPriority::Priority priority) -> bool
        addComment(ArConfig self, char const * comment, char const * sectionName) -> bool
        addComment(ArConfig self, char const * comment) -> bool
        """
        return _AriaPy.ArConfig_addComment(self, *args)


    def addParamAsIs(self, *args):
        """
        addParamAsIs(ArConfig self, ArConfigArg arg, char const * sectionName) -> bool
        addParamAsIs(ArConfig self, ArConfigArg arg) -> bool
        """
        return _AriaPy.ArConfig_addParamAsIs(self, *args)


    def setSectionComment(self, sectionName, comment):
        """setSectionComment(ArConfig self, char const * sectionName, char const * comment)"""
        return _AriaPy.ArConfig_setSectionComment(self, sectionName, comment)


    def useArgumentParser(self, parser):
        """useArgumentParser(ArConfig self, ArArgumentParser parser)"""
        return _AriaPy.ArConfig_useArgumentParser(self, parser)


    def processFile(self):
        """processFile(ArConfig self) -> bool"""
        return _AriaPy.ArConfig_processFile(self)


    def addProcessFileCB(self, *args):
        """
        addProcessFileCB(ArConfig self, ArRetFunctor_Bool functor, int priority=0)
        addProcessFileCB(ArConfig self, ArRetFunctor_Bool functor)
        addProcessFileCB(ArConfig self, ArRetFunctor2< bool,char *,size_t > * functor, int priority=0)
        addProcessFileCB(ArConfig self, ArRetFunctor2< bool,char *,size_t > * functor)
        """
        return _AriaPy.ArConfig_addProcessFileCB(self, *args)


    def addProcessFileWithErrorCB(self, functor, priority=0):
        """
        addProcessFileWithErrorCB(ArConfig self, ArRetFunctor2< bool,char *,size_t > * functor, int priority=0)
        addProcessFileWithErrorCB(ArConfig self, ArRetFunctor2< bool,char *,size_t > * functor)
        """
        return _AriaPy.ArConfig_addProcessFileWithErrorCB(self, functor, priority)


    def remProcessFileCB(self, *args):
        """
        remProcessFileCB(ArConfig self, ArRetFunctor_Bool functor)
        remProcessFileCB(ArConfig self, ArRetFunctor2< bool,char *,size_t > * functor)
        """
        return _AriaPy.ArConfig_remProcessFileCB(self, *args)


    def callProcessFileCallBacks(self, continueOnError, errorBuffer=None, errorBufferLen=0):
        """
        callProcessFileCallBacks(ArConfig self, bool continueOnError, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        callProcessFileCallBacks(ArConfig self, bool continueOnError, char * errorBuffer=None) -> bool
        callProcessFileCallBacks(ArConfig self, bool continueOnError) -> bool
        """
        return _AriaPy.ArConfig_callProcessFileCallBacks(self, continueOnError, errorBuffer, errorBufferLen)


    def parseArgument(self, arg, errorBuffer=None, errorBufferLen=0):
        """
        parseArgument(ArConfig self, ArArgumentBuilder arg, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseArgument(ArConfig self, ArArgumentBuilder arg, char * errorBuffer=None) -> bool
        parseArgument(ArConfig self, ArArgumentBuilder arg) -> bool
        """
        return _AriaPy.ArConfig_parseArgument(self, arg, errorBuffer, errorBufferLen)


    def parseVersion(self, arg, errorBuffer=None, errorBufferLen=0):
        """
        parseVersion(ArConfig self, ArArgumentBuilder arg, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseVersion(ArConfig self, ArArgumentBuilder arg, char * errorBuffer=None) -> bool
        parseVersion(ArConfig self, ArArgumentBuilder arg) -> bool
        """
        return _AriaPy.ArConfig_parseVersion(self, arg, errorBuffer, errorBufferLen)


    def parseSection(self, arg, errorBuffer=None, errorBufferLen=0):
        """
        parseSection(ArConfig self, ArArgumentBuilder arg, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseSection(ArConfig self, ArArgumentBuilder arg, char * errorBuffer=None) -> bool
        parseSection(ArConfig self, ArArgumentBuilder arg) -> bool
        """
        return _AriaPy.ArConfig_parseSection(self, arg, errorBuffer, errorBufferLen)


    def parseListBegin(self, arg, errorBuffer, errorBufferLen):
        """parseListBegin(ArConfig self, ArArgumentBuilder arg, char * errorBuffer, size_t errorBufferLen) -> bool"""
        return _AriaPy.ArConfig_parseListBegin(self, arg, errorBuffer, errorBufferLen)


    def parseListEnd(self, arg, errorBuffer, errorBufferLen):
        """parseListEnd(ArConfig self, ArArgumentBuilder arg, char * errorBuffer, size_t errorBufferLen) -> bool"""
        return _AriaPy.ArConfig_parseListEnd(self, arg, errorBuffer, errorBufferLen)


    def parseUnknown(self, arg, errorBuffer=None, errorBufferLen=0):
        """
        parseUnknown(ArConfig self, ArArgumentBuilder arg, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseUnknown(ArConfig self, ArArgumentBuilder arg, char * errorBuffer=None) -> bool
        parseUnknown(ArConfig self, ArArgumentBuilder arg) -> bool
        """
        return _AriaPy.ArConfig_parseUnknown(self, arg, errorBuffer, errorBufferLen)


    def getRestartLevelNeeded(self):
        """getRestartLevelNeeded(ArConfig self) -> ArConfigArg::RestartLevel"""
        return _AriaPy.ArConfig_getRestartLevelNeeded(self)


    def resetRestartLevelNeeded(self):
        """resetRestartLevelNeeded(ArConfig self)"""
        return _AriaPy.ArConfig_resetRestartLevelNeeded(self)


    def getBaseDirectory(self):
        """getBaseDirectory(ArConfig self) -> char const *"""
        return _AriaPy.ArConfig_getBaseDirectory(self)


    def setBaseDirectory(self, baseDirectory):
        """setBaseDirectory(ArConfig self, char const * baseDirectory)"""
        return _AriaPy.ArConfig_setBaseDirectory(self, baseDirectory)


    def getFileName(self):
        """getFileName(ArConfig self) -> char const *"""
        return _AriaPy.ArConfig_getFileName(self)


    def setNoBlanksBetweenParams(self, noBlanksBetweenParams):
        """setNoBlanksBetweenParams(ArConfig self, bool noBlanksBetweenParams)"""
        return _AriaPy.ArConfig_setNoBlanksBetweenParams(self, noBlanksBetweenParams)


    def getNoBlanksBetweenParams(self):
        """getNoBlanksBetweenParams(ArConfig self) -> bool"""
        return _AriaPy.ArConfig_getNoBlanksBetweenParams(self)


    def parseArgumentParser(self, parser, continueOnError=False, errorBuffer=None, errorBufferLen=0):
        """
        parseArgumentParser(ArConfig self, ArArgumentParser parser, bool continueOnError=False, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseArgumentParser(ArConfig self, ArArgumentParser parser, bool continueOnError=False, char * errorBuffer=None) -> bool
        parseArgumentParser(ArConfig self, ArArgumentParser parser, bool continueOnError=False) -> bool
        parseArgumentParser(ArConfig self, ArArgumentParser parser) -> bool
        """
        return _AriaPy.ArConfig_parseArgumentParser(self, parser, continueOnError, errorBuffer, errorBufferLen)


    def getCategoryNames(self):
        """getCategoryNames(ArConfig self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArConfig_getCategoryNames(self)


    def getSectionNamesInCategory(self, categoryName):
        """getSectionNamesInCategory(ArConfig self, char const * categoryName) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArConfig_getSectionNamesInCategory(self, categoryName)


    def getSectionNames(self):
        """getSectionNames(ArConfig self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArConfig_getSectionNames(self)


    def getSections(self):
        """getSections(ArConfig self) -> std::list< ArConfigSection *,std::allocator< ArConfigSection * > > *"""
        return _AriaPy.ArConfig_getSections(self)


    def findSection(self, sectionName):
        """findSection(ArConfig self, char const * sectionName) -> ArConfigSection"""
        return _AriaPy.ArConfig_findSection(self, sectionName)


    def setProcessFileCallbacksLogLevel(self, level):
        """setProcessFileCallbacksLogLevel(ArConfig self, ArLog::LogLevel level)"""
        return _AriaPy.ArConfig_setProcessFileCallbacksLogLevel(self, level)


    def getProcessFileCallbacksLogLevel(self):
        """getProcessFileCallbacksLogLevel(ArConfig self) -> ArLog::LogLevel"""
        return _AriaPy.ArConfig_getProcessFileCallbacksLogLevel(self)


    def setSaveUnknown(self, saveUnknown):
        """setSaveUnknown(ArConfig self, bool saveUnknown)"""
        return _AriaPy.ArConfig_setSaveUnknown(self, saveUnknown)


    def getSaveUnknown(self):
        """getSaveUnknown(ArConfig self) -> bool"""
        return _AriaPy.ArConfig_getSaveUnknown(self)


    def clearSections(self):
        """clearSections(ArConfig self)"""
        return _AriaPy.ArConfig_clearSections(self)


    def clearAll(self):
        """clearAll(ArConfig self)"""
        return _AriaPy.ArConfig_clearAll(self)


    def addSectionFlags(self, sectionName, flags):
        """addSectionFlags(ArConfig self, char const * sectionName, char const * flags) -> bool"""
        return _AriaPy.ArConfig_addSectionFlags(self, sectionName, flags)


    def remSectionFlag(self, sectionName, flag):
        """remSectionFlag(ArConfig self, char const * sectionName, char const * flag) -> bool"""
        return _AriaPy.ArConfig_remSectionFlag(self, sectionName, flag)


    def clearAllValueSet(self):
        """clearAllValueSet(ArConfig self)"""
        return _AriaPy.ArConfig_clearAllValueSet(self)


    def removeAllUnsetValues(self):
        """removeAllUnsetValues(ArConfig self)"""
        return _AriaPy.ArConfig_removeAllUnsetValues(self)


    def removeAllUnsetSections(self):
        """removeAllUnsetSections(ArConfig self)"""
        return _AriaPy.ArConfig_removeAllUnsetSections(self)


    def log(self, *args):
        """
        log(ArConfig self, bool isSummary=True, std::list< std::string,std::allocator< std::string > > * sectionNameList=None, char const * logPrefix)
        log(ArConfig self, bool isSummary=True, std::list< std::string,std::allocator< std::string > > * sectionNameList=None)
        log(ArConfig self, bool isSummary=True)
        log(ArConfig self)
        """
        return _AriaPy.ArConfig_log(self, *args)


    def setPermissions(self, allowFactory=True, rememberUnknowns=True):
        """
        setPermissions(ArConfig self, bool allowFactory=True, bool rememberUnknowns=True)
        setPermissions(ArConfig self, bool allowFactory=True)
        setPermissions(ArConfig self)
        """
        return _AriaPy.ArConfig_setPermissions(self, allowFactory, rememberUnknowns)


    def addSectionNotToParse(self, section):
        """addSectionNotToParse(ArConfig self, char const * section)"""
        return _AriaPy.ArConfig_addSectionNotToParse(self, section)


    def remSectionNotToParse(self, section):
        """remSectionNotToParse(ArConfig self, char const * section)"""
        return _AriaPy.ArConfig_remSectionNotToParse(self, section)

ArConfig_swigregister = _AriaPy.ArConfig_swigregister
ArConfig_swigregister(ArConfig)

class ArConfigSection(object):
    """Proxy of C++ ArConfigSection class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArConfigSection
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(ArConfigSection self, char const * name=None, char const * comment=None, bool isQuiet=False, char const * categoryName=None) -> ArConfigSection
        __init__(ArConfigSection self, char const * name=None, char const * comment=None, bool isQuiet=False) -> ArConfigSection
        __init__(ArConfigSection self, char const * name=None, char const * comment=None) -> ArConfigSection
        __init__(ArConfigSection self, char const * name=None) -> ArConfigSection
        __init__(ArConfigSection self) -> ArConfigSection
        __init__(ArConfigSection self, ArConfigSection section) -> ArConfigSection
        """
        this = _AriaPy.new_ArConfigSection(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def copyAndDetach(self, section):
        """copyAndDetach(ArConfigSection self, ArConfigSection section)"""
        return _AriaPy.ArConfigSection_copyAndDetach(self, section)


    def getName(self):
        """getName(ArConfigSection self) -> char const *"""
        return _AriaPy.ArConfigSection_getName(self)


    def getComment(self):
        """getComment(ArConfigSection self) -> char const *"""
        return _AriaPy.ArConfigSection_getComment(self)


    def getCategoryName(self):
        """getCategoryName(ArConfigSection self) -> char const *"""
        return _AriaPy.ArConfigSection_getCategoryName(self)


    def getFlags(self):
        """getFlags(ArConfigSection self) -> char const *"""
        return _AriaPy.ArConfigSection_getFlags(self)


    def hasFlag(self, flag):
        """hasFlag(ArConfigSection self, char const * flag) -> bool"""
        return _AriaPy.ArConfigSection_hasFlag(self, flag)


    def getParams(self):
        """getParams(ArConfigSection self) -> std::list< ArConfigArg,std::allocator< ArConfigArg > > *"""
        return _AriaPy.ArConfigSection_getParams(self)


    def setName(self, name):
        """setName(ArConfigSection self, char const * name)"""
        return _AriaPy.ArConfigSection_setName(self, name)


    def setComment(self, comment):
        """setComment(ArConfigSection self, char const * comment)"""
        return _AriaPy.ArConfigSection_setComment(self, comment)


    def addFlags(self, flags, isQuiet=False):
        """
        addFlags(ArConfigSection self, char const * flags, bool isQuiet=False) -> bool
        addFlags(ArConfigSection self, char const * flags) -> bool
        """
        return _AriaPy.ArConfigSection_addFlags(self, flags, isQuiet)


    def remFlag(self, dataFlag):
        """remFlag(ArConfigSection self, char const * dataFlag) -> bool"""
        return _AriaPy.ArConfigSection_remFlag(self, dataFlag)


    def findParam(self, *args):
        """
        findParam(ArConfigSection self, char const * paramName, bool isAllowStringHolders=False) -> ArConfigArg
        findParam(ArConfigSection self, char const * paramName) -> ArConfigArg
        findParam(ArConfigSection self, std::list< std::string,std::allocator< std::string > > const & paramNamePath, bool isAllowHolders=False) -> ArConfigArg
        findParam(ArConfigSection self, std::list< std::string,std::allocator< std::string > > const & paramNamePath) -> ArConfigArg
        findParam(ArConfigSection self, char const ** paramNamePath, int pathLength, bool isAllowHolders=False) -> ArConfigArg
        findParam(ArConfigSection self, char const ** paramNamePath, int pathLength) -> ArConfigArg
        """
        return _AriaPy.ArConfigSection_findParam(self, *args)


    def containsParamsOfPriority(self, highestPriority, lowestPriority):
        """containsParamsOfPriority(ArConfigSection self, ArPriority::Priority highestPriority, ArPriority::Priority lowestPriority) -> bool"""
        return _AriaPy.ArConfigSection_containsParamsOfPriority(self, highestPriority, lowestPriority)


    def remStringHolder(self, paramName):
        """remStringHolder(ArConfigSection self, char const * paramName) -> bool"""
        return _AriaPy.ArConfigSection_remStringHolder(self, paramName)


    def setQuiet(self, isQuiet):
        """setQuiet(ArConfigSection self, bool isQuiet)"""
        return _AriaPy.ArConfigSection_setQuiet(self, isQuiet)

ArConfigSection_swigregister = _AriaPy.ArConfigSection_swigregister
ArConfigSection_swigregister(ArConfigSection)

class ArConfigArg(object):
    """Proxy of C++ ArConfigArg class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    INVALID = _AriaPy.ArConfigArg_INVALID
    INT = _AriaPy.ArConfigArg_INT
    DOUBLE = _AriaPy.ArConfigArg_DOUBLE
    STRING = _AriaPy.ArConfigArg_STRING
    BOOL = _AriaPy.ArConfigArg_BOOL
    FUNCTOR = _AriaPy.ArConfigArg_FUNCTOR
    DESCRIPTION_HOLDER = _AriaPy.ArConfigArg_DESCRIPTION_HOLDER
    STRING_HOLDER = _AriaPy.ArConfigArg_STRING_HOLDER
    SEPARATOR = _AriaPy.ArConfigArg_SEPARATOR
    CPPSTRING = _AriaPy.ArConfigArg_CPPSTRING
    LIST = _AriaPy.ArConfigArg_LIST
    LIST_HOLDER = _AriaPy.ArConfigArg_LIST_HOLDER
    LAST_TYPE = _AriaPy.ArConfigArg_LAST_TYPE
    NO_RESTART = _AriaPy.ArConfigArg_NO_RESTART
    RESTART_CLIENT = _AriaPy.ArConfigArg_RESTART_CLIENT
    RESTART_IO = _AriaPy.ArConfigArg_RESTART_IO
    RESTART_SOFTWARE = _AriaPy.ArConfigArg_RESTART_SOFTWARE
    RESTART_HARDWARE = _AriaPy.ArConfigArg_RESTART_HARDWARE
    LAST_RESTART_LEVEL = _AriaPy.ArConfigArg_LAST_RESTART_LEVEL
    DEFAULT_DOUBLE_PRECISION = _AriaPy.ArConfigArg_DEFAULT_DOUBLE_PRECISION
    TYPE_COUNT = _AriaPy.ArConfigArg_TYPE_COUNT
    RESTART_LEVEL_COUNT = _AriaPy.ArConfigArg_RESTART_LEVEL_COUNT
    LIST_BEGIN_TAG = _swig_property(_AriaPy.ArConfigArg_LIST_BEGIN_TAG_get, _AriaPy.ArConfigArg_LIST_BEGIN_TAG_set)
    LIST_END_TAG = _swig_property(_AriaPy.ArConfigArg_LIST_END_TAG_get, _AriaPy.ArConfigArg_LIST_END_TAG_set)
    NULL_TAG = _swig_property(_AriaPy.ArConfigArg_NULL_TAG_get, _AriaPy.ArConfigArg_NULL_TAG_set)
    NEW_RESOURCE_TAG = _swig_property(_AriaPy.ArConfigArg_NEW_RESOURCE_TAG_get, _AriaPy.ArConfigArg_NEW_RESOURCE_TAG_set)

    def toString(*args):
        """
        toString(ArConfigArg::Type t) -> char const
        toString(ArConfigArg::RestartLevel r) -> char const *
        """
        return _AriaPy.ArConfigArg_toString(*args)

    toString = staticmethod(toString)

    def typeFromString(text):
        """typeFromString(char const * text) -> ArConfigArg::Type"""
        return _AriaPy.ArConfigArg_typeFromString(text)

    typeFromString = staticmethod(typeFromString)

    def restartLevelFromString(text):
        """restartLevelFromString(char const * text) -> ArConfigArg::RestartLevel"""
        return _AriaPy.ArConfigArg_restartLevelFromString(text)

    restartLevelFromString = staticmethod(restartLevelFromString)

    def parseResourceSectionName(*args):
        """
        parseResourceSectionName(ArArgumentBuilder arg, char const * logPrefix) -> std::string
        parseResourceSectionName(ArArgumentBuilder arg) -> std::string
        """
        return _AriaPy.ArConfigArg_parseResourceSectionName(*args)

    parseResourceSectionName = staticmethod(parseResourceSectionName)

    def parseResourceArgName(*args):
        """
        parseResourceArgName(ArArgumentBuilder arg, char const * logPrefix) -> std::string
        parseResourceArgName(ArArgumentBuilder arg) -> std::string
        """
        return _AriaPy.ArConfigArg_parseResourceArgName(*args)

    parseResourceArgName = staticmethod(parseResourceArgName)

    def parseResourceType(*args):
        """
        parseResourceType(ArArgumentBuilder arg, char const * logPrefix) -> ArConfigArg::Type
        parseResourceType(ArArgumentBuilder arg) -> ArConfigArg::Type
        """
        return _AriaPy.ArConfigArg_parseResourceType(*args)

    parseResourceType = staticmethod(parseResourceType)

    def isResourceTopLevel(*args):
        """
        isResourceTopLevel(ArArgumentBuilder arg, char const * logPrefix) -> bool
        isResourceTopLevel(ArArgumentBuilder arg) -> bool
        """
        return _AriaPy.ArConfigArg_isResourceTopLevel(*args)

    isResourceTopLevel = staticmethod(isResourceTopLevel)

    def parseResourceParentPath(*args):
        """
        parseResourceParentPath(ArArgumentBuilder arg, char separator, char const * logPrefix) -> std::list< std::string,std::allocator< std::string > >
        parseResourceParentPath(ArArgumentBuilder arg, char separator) -> std::list< std::string,std::allocator< std::string > >
        parseResourceParentPath(ArArgumentBuilder arg) -> std::list< std::string,std::allocator< std::string > >
        """
        return _AriaPy.ArConfigArg_parseResourceParentPath(*args)

    parseResourceParentPath = staticmethod(parseResourceParentPath)

    def parseResourceDescription(*args):
        """
        parseResourceDescription(ArArgumentBuilder arg, char const * logPrefix) -> std::string
        parseResourceDescription(ArArgumentBuilder arg) -> std::string
        """
        return _AriaPy.ArConfigArg_parseResourceDescription(*args)

    parseResourceDescription = staticmethod(parseResourceDescription)

    def parseResourceExtra(*args):
        """
        parseResourceExtra(ArArgumentBuilder arg, char const * logPrefix) -> std::string
        parseResourceExtra(ArArgumentBuilder arg) -> std::string
        """
        return _AriaPy.ArConfigArg_parseResourceExtra(*args)

    parseResourceExtra = staticmethod(parseResourceExtra)
    __swig_destroy__ = _AriaPy.delete_ArConfigArg
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(ArConfigArg self) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, int * pointer, char const * description, int minInt) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, int * pointer, char const * description) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, int * pointer) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, short * pointer, char const * description, int minInt) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, short * pointer, char const * description) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, short * pointer) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, unsigned short * pointer, char const * description, int minInt=0) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, unsigned short * pointer, char const * description) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, unsigned short * pointer) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, unsigned char * pointer, char const * description, int minInt=0) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, unsigned char * pointer, char const * description) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, unsigned char * pointer) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, double * pointer, char const * description, double minDouble, double maxDouble, int precision) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, double * pointer, char const * description, double minDouble) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, double * pointer, char const * description) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, double * pointer) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, bool * pointer) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, char * str, char const * description, size_t maxStrLen) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, char const * str, char const * description) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, std::string * str, char const * description) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, int val, char const * description, int minInt, int maxInt) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, int val, char const * description, int minInt) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, int val, char const * description) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, int val) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, double val, char const * description, double minDouble, double maxDouble, int precision) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, double val, char const * description, double minDouble, double maxDouble) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, double val, char const * description, double minDouble) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, double val, char const * description) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, double val) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, bool val, char const * description) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, bool val) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, ArRetFunctor1_Bool_ArgumentBuilderP setFunctor, ArRetFunctor< std::list< ArArgumentBuilder *,std::allocator< ArArgumentBuilder * > > const * > * getFunctor, char const * description) -> ArConfigArg
        __init__(ArConfigArg self, char const * str, ArConfigArg::Type type) -> ArConfigArg
        __init__(ArConfigArg self, char const * str) -> ArConfigArg
        __init__(ArConfigArg self, char const * name, char const * str) -> ArConfigArg
        __init__(ArConfigArg self, ArConfigArg::Type type, char const * name, char const * description) -> ArConfigArg
        __init__(ArConfigArg self, ArConfigArg::Type type) -> ArConfigArg
        __init__(ArConfigArg self, char const * argName, ArConfigArg arg) -> ArConfigArg
        __init__(ArConfigArg self, ArConfigArg arg) -> ArConfigArg
        """
        this = _AriaPy.new_ArConfigArg(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def copyAndDetach(self, arg):
        """copyAndDetach(ArConfigArg self, ArConfigArg arg)"""
        return _AriaPy.ArConfigArg_copyAndDetach(self, arg)


    def copyTranslation(self, arg):
        """copyTranslation(ArConfigArg self, ArConfigArg arg) -> bool"""
        return _AriaPy.ArConfigArg_copyTranslation(self, arg)


    def getType(self):
        """getType(ArConfigArg self) -> ArConfigArg::Type"""
        return _AriaPy.ArConfigArg_getType(self)


    def getName(self):
        """getName(ArConfigArg self) -> char const *"""
        return _AriaPy.ArConfigArg_getName(self)


    def getDescription(self):
        """getDescription(ArConfigArg self) -> char const *"""
        return _AriaPy.ArConfigArg_getDescription(self)


    def setDescription(self, description):
        """setDescription(ArConfigArg self, char const * description)"""
        return _AriaPy.ArConfigArg_setDescription(self, description)


    def setExtraExplanation(self, extraExplanation):
        """setExtraExplanation(ArConfigArg self, char const * extraExplanation)"""
        return _AriaPy.ArConfigArg_setExtraExplanation(self, extraExplanation)


    def getExtraExplanation(self):
        """getExtraExplanation(ArConfigArg self) -> char const *"""
        return _AriaPy.ArConfigArg_getExtraExplanation(self)


    def setInt(self, val, errorBuffer=None, errorBufferLen=0, doNotSet=False):
        """
        setInt(ArConfigArg self, int val, char * errorBuffer=None, size_t errorBufferLen=0, bool doNotSet=False) -> bool
        setInt(ArConfigArg self, int val, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        setInt(ArConfigArg self, int val, char * errorBuffer=None) -> bool
        setInt(ArConfigArg self, int val) -> bool
        """
        return _AriaPy.ArConfigArg_setInt(self, val, errorBuffer, errorBufferLen, doNotSet)


    def setDouble(self, val, errorBuffer=None, errorBufferLen=0, doNotSet=False):
        """
        setDouble(ArConfigArg self, double val, char * errorBuffer=None, size_t errorBufferLen=0, bool doNotSet=False) -> bool
        setDouble(ArConfigArg self, double val, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        setDouble(ArConfigArg self, double val, char * errorBuffer=None) -> bool
        setDouble(ArConfigArg self, double val) -> bool
        """
        return _AriaPy.ArConfigArg_setDouble(self, val, errorBuffer, errorBufferLen, doNotSet)


    def setBool(self, val, errorBuffer=None, errorBufferLen=0, doNotSet=False):
        """
        setBool(ArConfigArg self, bool val, char * errorBuffer=None, size_t errorBufferLen=0, bool doNotSet=False) -> bool
        setBool(ArConfigArg self, bool val, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        setBool(ArConfigArg self, bool val, char * errorBuffer=None) -> bool
        setBool(ArConfigArg self, bool val) -> bool
        """
        return _AriaPy.ArConfigArg_setBool(self, val, errorBuffer, errorBufferLen, doNotSet)


    def setString(self, str, errorBuffer=None, errorBufferLen=0, doNotSet=False):
        """
        setString(ArConfigArg self, char const * str, char * errorBuffer=None, size_t errorBufferLen=0, bool doNotSet=False) -> bool
        setString(ArConfigArg self, char const * str, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        setString(ArConfigArg self, char const * str, char * errorBuffer=None) -> bool
        setString(ArConfigArg self, char const * str) -> bool
        """
        return _AriaPy.ArConfigArg_setString(self, str, errorBuffer, errorBufferLen, doNotSet)


    def setCppString(self, str, errorBuffer=None, errorBufferLen=0, doNotSet=False):
        """
        setCppString(ArConfigArg self, std::string const & str, char * errorBuffer=None, size_t errorBufferLen=0, bool doNotSet=False) -> bool
        setCppString(ArConfigArg self, std::string const & str, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        setCppString(ArConfigArg self, std::string const & str, char * errorBuffer=None) -> bool
        setCppString(ArConfigArg self, std::string const & str) -> bool
        """
        return _AriaPy.ArConfigArg_setCppString(self, str, errorBuffer, errorBufferLen, doNotSet)


    def setArgWithFunctor(self, argument, errorBuffer=None, errorBufferLen=0, doNotSet=False):
        """
        setArgWithFunctor(ArConfigArg self, ArArgumentBuilder argument, char * errorBuffer=None, size_t errorBufferLen=0, bool doNotSet=False) -> bool
        setArgWithFunctor(ArConfigArg self, ArArgumentBuilder argument, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        setArgWithFunctor(ArConfigArg self, ArArgumentBuilder argument, char * errorBuffer=None) -> bool
        setArgWithFunctor(ArConfigArg self, ArArgumentBuilder argument) -> bool
        """
        return _AriaPy.ArConfigArg_setArgWithFunctor(self, argument, errorBuffer, errorBufferLen, doNotSet)


    def getInt(self, ok=None):
        """
        getInt(ArConfigArg self, bool * ok=None) -> int
        getInt(ArConfigArg self) -> int
        """
        return _AriaPy.ArConfigArg_getInt(self, ok)


    def getMinInt(self, ok=None):
        """
        getMinInt(ArConfigArg self, bool * ok=None) -> int
        getMinInt(ArConfigArg self) -> int
        """
        return _AriaPy.ArConfigArg_getMinInt(self, ok)


    def getMaxInt(self, ok=None):
        """
        getMaxInt(ArConfigArg self, bool * ok=None) -> int
        getMaxInt(ArConfigArg self) -> int
        """
        return _AriaPy.ArConfigArg_getMaxInt(self, ok)


    def getDouble(self, ok=None):
        """
        getDouble(ArConfigArg self, bool * ok=None) -> double
        getDouble(ArConfigArg self) -> double
        """
        return _AriaPy.ArConfigArg_getDouble(self, ok)


    def getMinDouble(self, ok=None):
        """
        getMinDouble(ArConfigArg self, bool * ok=None) -> double
        getMinDouble(ArConfigArg self) -> double
        """
        return _AriaPy.ArConfigArg_getMinDouble(self, ok)


    def getMaxDouble(self, ok=None):
        """
        getMaxDouble(ArConfigArg self, bool * ok=None) -> double
        getMaxDouble(ArConfigArg self) -> double
        """
        return _AriaPy.ArConfigArg_getMaxDouble(self, ok)


    def getDoublePrecision(self, ok=None):
        """
        getDoublePrecision(ArConfigArg self, bool * ok=None) -> int
        getDoublePrecision(ArConfigArg self) -> int
        """
        return _AriaPy.ArConfigArg_getDoublePrecision(self, ok)


    def getBool(self, ok=None):
        """
        getBool(ArConfigArg self, bool * ok=None) -> bool
        getBool(ArConfigArg self) -> bool
        """
        return _AriaPy.ArConfigArg_getBool(self, ok)


    def getString(self, ok=None):
        """
        getString(ArConfigArg self, bool * ok=None) -> char const
        getString(ArConfigArg self) -> char const *
        """
        return _AriaPy.ArConfigArg_getString(self, ok)


    def getArgsWithFunctor(self, ok=None):
        """
        getArgsWithFunctor(ArConfigArg self, bool * ok=None) -> ArArgumentBuilderPtrList
        getArgsWithFunctor(ArConfigArg self) -> ArArgumentBuilderPtrList
        """
        return _AriaPy.ArConfigArg_getArgsWithFunctor(self, ok)


    def getCppString(self, ok=None):
        """
        getCppString(ArConfigArg self, bool * ok=None) -> std::string
        getCppString(ArConfigArg self) -> std::string
        """
        return _AriaPy.ArConfigArg_getCppString(self, ok)


    def getCppStringPtr(self, ok=None):
        """
        getCppStringPtr(ArConfigArg self, bool * ok=None) -> std::string const
        getCppStringPtr(ArConfigArg self) -> std::string const *
        """
        return _AriaPy.ArConfigArg_getCppStringPtr(self, ok)


    def addArg(self, arg):
        """addArg(ArConfigArg self, ArConfigArg arg) -> bool"""
        return _AriaPy.ArConfigArg_addArg(self, arg)


    def hasArgs(self):
        """hasArgs(ArConfigArg self) -> bool"""
        return _AriaPy.ArConfigArg_hasArgs(self)


    def getArgCount(self):
        """getArgCount(ArConfigArg self) -> size_t"""
        return _AriaPy.ArConfigArg_getArgCount(self)


    def getArgs(self, ok=None):
        """
        getArgs(ArConfigArg self, bool * ok=None) -> std::list< ArConfigArg,std::allocator< ArConfigArg > >
        getArgs(ArConfigArg self) -> std::list< ArConfigArg,std::allocator< ArConfigArg > >
        """
        return _AriaPy.ArConfigArg_getArgs(self, ok)


    def getArg(self, *args):
        """
        getArg(ArConfigArg self, size_t index) -> ArConfigArg
        getArg(ArConfigArg self, size_t index) -> ArConfigArg
        """
        return _AriaPy.ArConfigArg_getArg(self, *args)


    def findArg(self, *args):
        """
        findArg(ArConfigArg self, char const * childParamName) -> ArConfigArg
        findArg(ArConfigArg self, char const * childParamName) -> ArConfigArg
        """
        return _AriaPy.ArConfigArg_findArg(self, *args)


    def getConfigPriority(self):
        """getConfigPriority(ArConfigArg self) -> ArPriority::Priority"""
        return _AriaPy.ArConfigArg_getConfigPriority(self)


    def setConfigPriority(self, priority):
        """setConfigPriority(ArConfigArg self, ArPriority::Priority priority)"""
        return _AriaPy.ArConfigArg_setConfigPriority(self, priority)


    def getDisplayHint(self):
        """getDisplayHint(ArConfigArg self) -> char const *"""
        return _AriaPy.ArConfigArg_getDisplayHint(self)


    def setDisplayHint(self, hintText):
        """setDisplayHint(ArConfigArg self, char const * hintText)"""
        return _AriaPy.ArConfigArg_setDisplayHint(self, hintText)


    def getRestartLevel(self):
        """getRestartLevel(ArConfigArg self) -> ArConfigArg::RestartLevel"""
        return _AriaPy.ArConfigArg_getRestartLevel(self)


    def setRestartLevel(self, level):
        """setRestartLevel(ArConfigArg self, ArConfigArg::RestartLevel level)"""
        return _AriaPy.ArConfigArg_setRestartLevel(self, level)


    def getSupressChanges(self):
        """getSupressChanges(ArConfigArg self) -> bool"""
        return _AriaPy.ArConfigArg_getSupressChanges(self)


    def setSupressChanges(self, supressChanges):
        """setSupressChanges(ArConfigArg self, bool supressChanges)"""
        return _AriaPy.ArConfigArg_setSupressChanges(self, supressChanges)


    def getParentArg(self):
        """getParentArg(ArConfigArg self) -> ArConfigArg"""
        return _AriaPy.ArConfigArg_getParentArg(self)


    def getParentPathName(self, *args):
        """
        getParentPathName(ArConfigArg self, char separator) -> std::string
        getParentPathName(ArConfigArg self) -> std::string
        """
        return _AriaPy.ArConfigArg_getParentPathName(self, *args)


    def splitParentPathName(*args):
        """
        splitParentPathName(char const * parentPathName, char separator) -> std::list< std::string,std::allocator< std::string > >
        splitParentPathName(char const * parentPathName) -> std::list< std::string,std::allocator< std::string > >
        """
        return _AriaPy.ArConfigArg_splitParentPathName(*args)

    splitParentPathName = staticmethod(splitParentPathName)

    def replaceSpacesInName(self):
        """replaceSpacesInName(ArConfigArg self)"""
        return _AriaPy.ArConfigArg_replaceSpacesInName(self)


    def hasMinBound(self):
        """hasMinBound(ArConfigArg self) -> bool"""
        return _AriaPy.ArConfigArg_hasMinBound(self)


    def hasMaxBound(self):
        """hasMaxBound(ArConfigArg self) -> bool"""
        return _AriaPy.ArConfigArg_hasMaxBound(self)


    def setIgnoreBounds(self, ignoreBounds=False):
        """
        setIgnoreBounds(ArConfigArg self, bool ignoreBounds=False)
        setIgnoreBounds(ArConfigArg self)
        """
        return _AriaPy.ArConfigArg_setIgnoreBounds(self, ignoreBounds)


    def hasExternalDataReference(self):
        """hasExternalDataReference(ArConfigArg self) -> bool"""
        return _AriaPy.ArConfigArg_hasExternalDataReference(self)


    def addToFileParser(self, *args):
        """
        addToFileParser(ArConfigArg self, ArFileParser parser, ArRetFunctor3C< bool,ArConfig,ArArgumentBuilder *,char *,size_t > * parserCB, char const * logPrefix, bool isQuiet=False) -> bool
        addToFileParser(ArConfigArg self, ArFileParser parser, ArRetFunctor3C< bool,ArConfig,ArArgumentBuilder *,char *,size_t > * parserCB, char const * logPrefix) -> bool
        addToFileParser(ArConfigArg self, ArFileParser parser, ArRetFunctor3C< bool,ArConfig,ArArgumentBuilder *,char *,size_t > * parserCB) -> bool
        """
        return _AriaPy.ArConfigArg_addToFileParser(self, *args)


    def parseArgument(self, *args):
        """
        parseArgument(ArConfigArg self, ArArgumentBuilder arg, char * errorBuffer, size_t errorBufferLen, char const * logPrefix, bool isQuiet=False, bool * changed=None) -> bool
        parseArgument(ArConfigArg self, ArArgumentBuilder arg, char * errorBuffer, size_t errorBufferLen, char const * logPrefix, bool isQuiet=False) -> bool
        parseArgument(ArConfigArg self, ArArgumentBuilder arg, char * errorBuffer, size_t errorBufferLen, char const * logPrefix) -> bool
        parseArgument(ArConfigArg self, ArArgumentBuilder arg, char * errorBuffer, size_t errorBufferLen) -> bool
        """
        return _AriaPy.ArConfigArg_parseArgument(self, *args)


    def writeArguments(self, *args):
        """
        writeArguments(ArConfigArg self, FILE * file, char * lineBuf, int lineBufSize, int startCommentColumn, bool isWriteExtra=False, char const * logPrefix, int indentLevel=0) -> bool
        writeArguments(ArConfigArg self, FILE * file, char * lineBuf, int lineBufSize, int startCommentColumn, bool isWriteExtra=False, char const * logPrefix) -> bool
        writeArguments(ArConfigArg self, FILE * file, char * lineBuf, int lineBufSize, int startCommentColumn, bool isWriteExtra=False) -> bool
        writeArguments(ArConfigArg self, FILE * file, char * lineBuf, int lineBufSize, int startCommentColumn) -> bool
        """
        return _AriaPy.ArConfigArg_writeArguments(self, *args)


    def writeName(self, lineBuf, lineBufSize, indentLevel):
        """writeName(ArConfigArg self, char * lineBuf, int lineBufSize, int indentLevel) -> bool"""
        return _AriaPy.ArConfigArg_writeName(self, lineBuf, lineBufSize, indentLevel)


    def writeBounds(self, *args):
        """
        writeBounds(ArConfigArg self, char * line, size_t lineLen, char const * logPrefix) -> bool
        writeBounds(ArConfigArg self, char * line, size_t lineLen) -> bool
        """
        return _AriaPy.ArConfigArg_writeBounds(self, *args)


    def log(self, *args):
        """
        log(ArConfigArg self, bool verbose=False, int indentCount=1, char const * logPrefix)
        log(ArConfigArg self, bool verbose=False, int indentCount=1)
        log(ArConfigArg self, bool verbose=False)
        log(ArConfigArg self)
        """
        return _AriaPy.ArConfigArg_log(self, *args)


    def isValueEqual(self, other):
        """isValueEqual(ArConfigArg self, ArConfigArg other) -> bool"""
        return _AriaPy.ArConfigArg_isValueEqual(self, other)


    def setValue(self, source, isVerifyArgNames=False):
        """
        setValue(ArConfigArg self, ArConfigArg source, bool isVerifyArgNames=False) -> bool
        setValue(ArConfigArg self, ArConfigArg source) -> bool
        """
        return _AriaPy.ArConfigArg_setValue(self, source, isVerifyArgNames)


    def isValueSet(self):
        """isValueSet(ArConfigArg self) -> bool"""
        return _AriaPy.ArConfigArg_isValueSet(self)


    def clearValueSet(self):
        """clearValueSet(ArConfigArg self)"""
        return _AriaPy.ArConfigArg_clearValueSet(self)


    def setValueSet(self):
        """setValueSet(ArConfigArg self)"""
        return _AriaPy.ArConfigArg_setValueSet(self)


    def isTranslated(self):
        """isTranslated(ArConfigArg self) -> bool"""
        return _AriaPy.ArConfigArg_isTranslated(self)


    def setTranslated(self, b):
        """setTranslated(ArConfigArg self, bool b)"""
        return _AriaPy.ArConfigArg_setTranslated(self, b)

    RESOURCE_INDEX_OF_SECTION_NAME = _AriaPy.ArConfigArg_RESOURCE_INDEX_OF_SECTION_NAME
    RESOURCE_INDEX_OF_ARG_NAME = _AriaPy.ArConfigArg_RESOURCE_INDEX_OF_ARG_NAME
    RESOURCE_INDEX_OF_TYPE = _AriaPy.ArConfigArg_RESOURCE_INDEX_OF_TYPE
    RESOURCE_INDEX_OF_PRIORITY = _AriaPy.ArConfigArg_RESOURCE_INDEX_OF_PRIORITY
    RESOURCE_INDEX_OF_RESTART_LEVEL = _AriaPy.ArConfigArg_RESOURCE_INDEX_OF_RESTART_LEVEL
    RESOURCE_INDEX_OF_PARENT_PATH = _AriaPy.ArConfigArg_RESOURCE_INDEX_OF_PARENT_PATH
    RESOURCE_INDEX_OF_DESCRIPTION = _AriaPy.ArConfigArg_RESOURCE_INDEX_OF_DESCRIPTION
    RESOURCE_INDEX_OF_EXTRA = _AriaPy.ArConfigArg_RESOURCE_INDEX_OF_EXTRA
    RESOURCE_INDEX_OF_DISPLAY = _AriaPy.ArConfigArg_RESOURCE_INDEX_OF_DISPLAY
    RESOURCE_INDEX_OF_NEW = _AriaPy.ArConfigArg_RESOURCE_INDEX_OF_NEW
    MAX_RESOURCE_ARG_TEXT_LENGTH = _AriaPy.ArConfigArg_MAX_RESOURCE_ARG_TEXT_LENGTH

    def parseResource(self, *args):
        """
        parseResource(ArConfigArg self, ArArgumentBuilder arg, char * errorBuffer, size_t errorBufferLen, char const * logPrefix, bool isQuiet=False) -> bool
        parseResource(ArConfigArg self, ArArgumentBuilder arg, char * errorBuffer, size_t errorBufferLen, char const * logPrefix) -> bool
        parseResource(ArConfigArg self, ArArgumentBuilder arg, char * errorBuffer, size_t errorBufferLen) -> bool
        """
        return _AriaPy.ArConfigArg_parseResource(self, *args)


    def parseResourceArgText(argText, bufOut, bufLen):
        """parseResourceArgText(char const * argText, char * bufOut, size_t bufLen) -> bool"""
        return _AriaPy.ArConfigArg_parseResourceArgText(argText, bufOut, bufLen)

    parseResourceArgText = staticmethod(parseResourceArgText)

    def writeResource(self, *args):
        """
        writeResource(ArConfigArg self, FILE * file, char * lineBuf, int lineBufSize, char separatorChar, char const * sectionName, char const * logPrefix) -> bool
        writeResource(ArConfigArg self, FILE * file, char * lineBuf, int lineBufSize, char separatorChar, char const * sectionName) -> bool
        """
        return _AriaPy.ArConfigArg_writeResource(self, *args)


    def writeResourceHeader(*args):
        """
        writeResourceHeader(FILE * file, char * lineBuf, int lineBufSize, char separatorChar, char const * sectionTitle, char const * logPrefix) -> int
        writeResourceHeader(FILE * file, char * lineBuf, int lineBufSize, char separatorChar, char const * sectionTitle) -> int
        """
        return _AriaPy.ArConfigArg_writeResourceHeader(*args)

    writeResourceHeader = staticmethod(writeResourceHeader)

    def writeResourceSectionHeader(*args):
        """
        writeResourceSectionHeader(FILE * file, char * lineBuf, int lineBufSize, char separatorChar, char const * sectionName, char const * sectionDesc, char const * sectionExtra, char const * sectionDisplayName, bool isTranslated, char const * logPrefix) -> int
        writeResourceSectionHeader(FILE * file, char * lineBuf, int lineBufSize, char separatorChar, char const * sectionName, char const * sectionDesc, char const * sectionExtra, char const * sectionDisplayName, bool isTranslated) -> int
        """
        return _AriaPy.ArConfigArg_writeResourceSectionHeader(*args)

    writeResourceSectionHeader = staticmethod(writeResourceSectionHeader)
ArConfigArg_swigregister = _AriaPy.ArConfigArg_swigregister
ArConfigArg_swigregister(ArConfigArg)

def ArConfigArg_toString(*args):
    """
    toString(ArConfigArg::Type t) -> char const
    ArConfigArg_toString(ArConfigArg::RestartLevel r) -> char const *
    """
    return _AriaPy.ArConfigArg_toString(*args)

def ArConfigArg_typeFromString(text):
    """ArConfigArg_typeFromString(char const * text) -> ArConfigArg::Type"""
    return _AriaPy.ArConfigArg_typeFromString(text)

def ArConfigArg_restartLevelFromString(text):
    """ArConfigArg_restartLevelFromString(char const * text) -> ArConfigArg::RestartLevel"""
    return _AriaPy.ArConfigArg_restartLevelFromString(text)

def ArConfigArg_parseResourceSectionName(*args):
    """
    parseResourceSectionName(ArArgumentBuilder arg, char const * logPrefix) -> std::string
    ArConfigArg_parseResourceSectionName(ArArgumentBuilder arg) -> std::string
    """
    return _AriaPy.ArConfigArg_parseResourceSectionName(*args)

def ArConfigArg_parseResourceArgName(*args):
    """
    parseResourceArgName(ArArgumentBuilder arg, char const * logPrefix) -> std::string
    ArConfigArg_parseResourceArgName(ArArgumentBuilder arg) -> std::string
    """
    return _AriaPy.ArConfigArg_parseResourceArgName(*args)

def ArConfigArg_parseResourceType(*args):
    """
    parseResourceType(ArArgumentBuilder arg, char const * logPrefix) -> ArConfigArg::Type
    ArConfigArg_parseResourceType(ArArgumentBuilder arg) -> ArConfigArg::Type
    """
    return _AriaPy.ArConfigArg_parseResourceType(*args)

def ArConfigArg_isResourceTopLevel(*args):
    """
    isResourceTopLevel(ArArgumentBuilder arg, char const * logPrefix) -> bool
    ArConfigArg_isResourceTopLevel(ArArgumentBuilder arg) -> bool
    """
    return _AriaPy.ArConfigArg_isResourceTopLevel(*args)

def ArConfigArg_parseResourceParentPath(*args):
    """
    parseResourceParentPath(ArArgumentBuilder arg, char separator, char const * logPrefix) -> std::list< std::string,std::allocator< std::string > >
    parseResourceParentPath(ArArgumentBuilder arg, char separator) -> std::list< std::string,std::allocator< std::string > >
    ArConfigArg_parseResourceParentPath(ArArgumentBuilder arg) -> std::list< std::string,std::allocator< std::string > >
    """
    return _AriaPy.ArConfigArg_parseResourceParentPath(*args)

def ArConfigArg_parseResourceDescription(*args):
    """
    parseResourceDescription(ArArgumentBuilder arg, char const * logPrefix) -> std::string
    ArConfigArg_parseResourceDescription(ArArgumentBuilder arg) -> std::string
    """
    return _AriaPy.ArConfigArg_parseResourceDescription(*args)

def ArConfigArg_parseResourceExtra(*args):
    """
    parseResourceExtra(ArArgumentBuilder arg, char const * logPrefix) -> std::string
    ArConfigArg_parseResourceExtra(ArArgumentBuilder arg) -> std::string
    """
    return _AriaPy.ArConfigArg_parseResourceExtra(*args)

def ArConfigArg_splitParentPathName(*args):
    """
    splitParentPathName(char const * parentPathName, char separator) -> std::list< std::string,std::allocator< std::string > >
    ArConfigArg_splitParentPathName(char const * parentPathName) -> std::list< std::string,std::allocator< std::string > >
    """
    return _AriaPy.ArConfigArg_splitParentPathName(*args)

def ArConfigArg_parseResourceArgText(argText, bufOut, bufLen):
    """ArConfigArg_parseResourceArgText(char const * argText, char * bufOut, size_t bufLen) -> bool"""
    return _AriaPy.ArConfigArg_parseResourceArgText(argText, bufOut, bufLen)

def ArConfigArg_writeResourceHeader(*args):
    """
    writeResourceHeader(FILE * file, char * lineBuf, int lineBufSize, char separatorChar, char const * sectionTitle, char const * logPrefix) -> int
    ArConfigArg_writeResourceHeader(FILE * file, char * lineBuf, int lineBufSize, char separatorChar, char const * sectionTitle) -> int
    """
    return _AriaPy.ArConfigArg_writeResourceHeader(*args)

def ArConfigArg_writeResourceSectionHeader(*args):
    """
    writeResourceSectionHeader(FILE * file, char * lineBuf, int lineBufSize, char separatorChar, char const * sectionName, char const * sectionDesc, char const * sectionExtra, char const * sectionDisplayName, bool isTranslated, char const * logPrefix) -> int
    ArConfigArg_writeResourceSectionHeader(FILE * file, char * lineBuf, int lineBufSize, char separatorChar, char const * sectionName, char const * sectionDesc, char const * sectionExtra, char const * sectionDisplayName, bool isTranslated) -> int
    """
    return _AriaPy.ArConfigArg_writeResourceSectionHeader(*args)

class ArConfigGroup(object):
    """Proxy of C++ ArConfigGroup 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, baseDirectory=None):
        """
        __init__(ArConfigGroup self, char const * baseDirectory=None) -> ArConfigGroup
        __init__(ArConfigGroup self) -> ArConfigGroup
        """
        this = _AriaPy.new_ArConfigGroup(baseDirectory)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArConfigGroup
    __del__ = lambda self: None

    def addConfig(self, config):
        """addConfig(ArConfigGroup self, ArConfig config)"""
        return _AriaPy.ArConfigGroup_addConfig(self, config)


    def remConfig(self, config):
        """remConfig(ArConfigGroup self, ArConfig config)"""
        return _AriaPy.ArConfigGroup_remConfig(self, config)


    def parseFile(self, fileName, continueOnError=False):
        """
        parseFile(ArConfigGroup self, char const * fileName, bool continueOnError=False) -> bool
        parseFile(ArConfigGroup self, char const * fileName) -> bool
        """
        return _AriaPy.ArConfigGroup_parseFile(self, fileName, continueOnError)


    def reloadFile(self, continueOnError=True):
        """
        reloadFile(ArConfigGroup self, bool continueOnError=True) -> bool
        reloadFile(ArConfigGroup self) -> bool
        """
        return _AriaPy.ArConfigGroup_reloadFile(self, continueOnError)


    def writeFile(self, fileName):
        """writeFile(ArConfigGroup self, char const * fileName) -> bool"""
        return _AriaPy.ArConfigGroup_writeFile(self, fileName)


    def setBaseDirectory(self, baseDirectory):
        """setBaseDirectory(ArConfigGroup self, char const * baseDirectory)"""
        return _AriaPy.ArConfigGroup_setBaseDirectory(self, baseDirectory)


    def getBaseDirectory(self):
        """getBaseDirectory(ArConfigGroup self) -> char const *"""
        return _AriaPy.ArConfigGroup_getBaseDirectory(self)

ArConfigGroup_swigregister = _AriaPy.ArConfigGroup_swigregister
ArConfigGroup_swigregister(ArConfigGroup)

class ArDataLogger(object):
    """Proxy of C++ ArDataLogger 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, robot, fileName=None):
        """
        __init__(ArDataLogger self, ArRobot robot, char const * fileName=None) -> ArDataLogger
        __init__(ArDataLogger self, ArRobot robot) -> ArDataLogger
        """
        this = _AriaPy.new_ArDataLogger(robot, fileName)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArDataLogger
    __del__ = lambda self: None

    def addToConfig(self, config):
        """addToConfig(ArDataLogger self, ArConfig config)"""
        return _AriaPy.ArDataLogger_addToConfig(self, config)


    def addString(self, name, maxLen, functor):
        """addString(ArDataLogger self, char const * name, ArTypes::UByte2 maxLen, ArFunctor2< char *,ArTypes::UByte2 > * functor)"""
        return _AriaPy.ArDataLogger_addString(self, name, maxLen, functor)


    def getAddStringFunctor(self):
        """getAddStringFunctor(ArDataLogger self) -> ArFunctor3< char const *,ArTypes::UByte2,ArFunctor2< char *,ArTypes::UByte2 > * > *"""
        return _AriaPy.ArDataLogger_getAddStringFunctor(self)

ArDataLogger_swigregister = _AriaPy.ArDataLogger_swigregister
ArDataLogger_swigregister(ArDataLogger)

class ArDPPTUCommands(object):
    """Proxy of C++ ArDPPTUCommands class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    DELIM = _AriaPy.ArDPPTUCommands_DELIM
    INIT = _AriaPy.ArDPPTUCommands_INIT
    ACCEL = _AriaPy.ArDPPTUCommands_ACCEL
    BASE = _AriaPy.ArDPPTUCommands_BASE
    CONTROL = _AriaPy.ArDPPTUCommands_CONTROL
    DISABLE = _AriaPy.ArDPPTUCommands_DISABLE
    ENABLE = _AriaPy.ArDPPTUCommands_ENABLE
    FACTORY = _AriaPy.ArDPPTUCommands_FACTORY
    HALT = _AriaPy.ArDPPTUCommands_HALT
    IMMED = _AriaPy.ArDPPTUCommands_IMMED
    LIMIT = _AriaPy.ArDPPTUCommands_LIMIT
    MONITOR = _AriaPy.ArDPPTUCommands_MONITOR
    OFFSET = _AriaPy.ArDPPTUCommands_OFFSET
    PAN = _AriaPy.ArDPPTUCommands_PAN
    RESET = _AriaPy.ArDPPTUCommands_RESET
    SPEED = _AriaPy.ArDPPTUCommands_SPEED
    TILT = _AriaPy.ArDPPTUCommands_TILT
    UPPER = _AriaPy.ArDPPTUCommands_UPPER
    VELOCITY = _AriaPy.ArDPPTUCommands_VELOCITY

    def __init__(self):
        """__init__(ArDPPTUCommands self) -> ArDPPTUCommands"""
        this = _AriaPy.new_ArDPPTUCommands()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArDPPTUCommands
    __del__ = lambda self: None
ArDPPTUCommands_swigregister = _AriaPy.ArDPPTUCommands_swigregister
ArDPPTUCommands_swigregister(ArDPPTUCommands)

class ArDPPTUPacket(ArBasePacket):
    """Proxy of C++ ArDPPTUPacket 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, bufferSize=30):
        """
        __init__(ArDPPTUPacket self, ArTypes::UByte2 bufferSize=30) -> ArDPPTUPacket
        __init__(ArDPPTUPacket self) -> ArDPPTUPacket
        """
        this = _AriaPy.new_ArDPPTUPacket(bufferSize)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArDPPTUPacket
    __del__ = lambda self: None

    def byte2ToBuf(self, val):
        """byte2ToBuf(ArDPPTUPacket self, int val)"""
        return _AriaPy.ArDPPTUPacket_byte2ToBuf(self, val)


    def finalizePacket(self):
        """finalizePacket(ArDPPTUPacket self)"""
        return _AriaPy.ArDPPTUPacket_finalizePacket(self)

ArDPPTUPacket_swigregister = _AriaPy.ArDPPTUPacket_swigregister
ArDPPTUPacket_swigregister(ArDPPTUPacket)

class ArDPPTU(ArPTZ):
    """Proxy of C++ ArDPPTU class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    PANTILT_DEFAULT = _AriaPy.ArDPPTU_PANTILT_DEFAULT
    PANTILT_PTUD47 = _AriaPy.ArDPPTU_PANTILT_PTUD47
    PANTILT_PTUD46 = _AriaPy.ArDPPTU_PANTILT_PTUD46
    PAN = _AriaPy.ArDPPTU_PAN
    TILT = _AriaPy.ArDPPTU_TILT

    def __init__(self, *args):
        """
        __init__(ArDPPTU self, ArRobot robot, ArDPPTU::DeviceType deviceType, int deviceIndex=-1) -> ArDPPTU
        __init__(ArDPPTU self, ArRobot robot, ArDPPTU::DeviceType deviceType) -> ArDPPTU
        __init__(ArDPPTU self, ArRobot robot) -> ArDPPTU
        """
        this = _AriaPy.new_ArDPPTU(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArDPPTU
    __del__ = lambda self: None

    def init(self):
        """init(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_init(self)


    def getTypeName(self):
        """getTypeName(ArDPPTU self) -> char const *"""
        return _AriaPy.ArDPPTU_getTypeName(self)


    def canZoom(self):
        """canZoom(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_canZoom(self)


    def canGetRealPanTilt(self):
        """canGetRealPanTilt(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_canGetRealPanTilt(self)


    def blank(self):
        """blank(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_blank(self)


    def resetCalib(self):
        """resetCalib(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_resetCalib(self)


    def disableReset(self):
        """disableReset(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_disableReset(self)


    def resetTilt(self):
        """resetTilt(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_resetTilt(self)


    def resetPan(self):
        """resetPan(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_resetPan(self)


    def resetAll(self):
        """resetAll(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_resetAll(self)


    def enMon(self):
        """enMon(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_enMon(self)


    def disMon(self):
        """disMon(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_disMon(self)


    def saveSet(self):
        """saveSet(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_saveSet(self)


    def restoreSet(self):
        """restoreSet(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_restoreSet(self)


    def factorySet(self):
        """factorySet(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_factorySet(self)


    def awaitExec(self):
        """awaitExec(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_awaitExec(self)


    def haltAll(self):
        """haltAll(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_haltAll(self)


    def haltPan(self):
        """haltPan(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_haltPan(self)


    def haltTilt(self):
        """haltTilt(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_haltTilt(self)


    def initMon(self, deg1, deg2, deg3, deg4):
        """initMon(ArDPPTU self, double deg1, double deg2, double deg3, double deg4) -> bool"""
        return _AriaPy.ArDPPTU_initMon(self, deg1, deg2, deg3, deg4)


    def limitEnforce(self, val):
        """limitEnforce(ArDPPTU self, bool val) -> bool"""
        return _AriaPy.ArDPPTU_limitEnforce(self, val)


    def immedExec(self):
        """immedExec(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_immedExec(self)


    def slaveExec(self):
        """slaveExec(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_slaveExec(self)


    def getMaxPanSlew(self):
        """getMaxPanSlew(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getMaxPanSlew(self)


    def getMinPanSlew(self):
        """getMinPanSlew(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getMinPanSlew(self)


    def getMaxTiltSlew(self):
        """getMaxTiltSlew(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getMaxTiltSlew(self)


    def getMinTiltSlew(self):
        """getMinTiltSlew(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getMinTiltSlew(self)


    def getMaxPanAccel(self):
        """getMaxPanAccel(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getMaxPanAccel(self)


    def getMinPanAccel(self):
        """getMinPanAccel(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getMinPanAccel(self)


    def getMaxTiltAccel(self):
        """getMaxTiltAccel(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getMaxTiltAccel(self)


    def getMinTiltAccel(self):
        """getMinTiltAccel(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getMinTiltAccel(self)

    OFF = _AriaPy.ArDPPTU_OFF
    LOW = _AriaPy.ArDPPTU_LOW
    NORMAL = _AriaPy.ArDPPTU_NORMAL
    HIGH = _AriaPy.ArDPPTU_HIGH

    def setMovePower(self, axis, mode):
        """setMovePower(ArDPPTU self, ArDPPTU::Axis axis, ArDPPTU::PowerMode mode) -> bool"""
        return _AriaPy.ArDPPTU_setMovePower(self, axis, mode)


    def setHoldPower(self, axis, mode):
        """setHoldPower(ArDPPTU self, ArDPPTU::Axis axis, ArDPPTU::PowerMode mode) -> bool"""
        return _AriaPy.ArDPPTU_setHoldPower(self, axis, mode)


    def offStatPower(self):
        """offStatPower(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_offStatPower(self)


    def regStatPower(self):
        """regStatPower(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_regStatPower(self)


    def lowStatPower(self):
        """lowStatPower(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_lowStatPower(self)


    def highMotPower(self):
        """highMotPower(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_highMotPower(self)


    def regMotPower(self):
        """regMotPower(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_regMotPower(self)


    def lowMotPower(self):
        """lowMotPower(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_lowMotPower(self)


    def panAccel(self, deg):
        """panAccel(ArDPPTU self, double deg) -> bool"""
        return _AriaPy.ArDPPTU_panAccel(self, deg)


    def tiltAccel(self, deg):
        """tiltAccel(ArDPPTU self, double deg) -> bool"""
        return _AriaPy.ArDPPTU_tiltAccel(self, deg)


    def basePanSlew(self, deg):
        """basePanSlew(ArDPPTU self, double deg) -> bool"""
        return _AriaPy.ArDPPTU_basePanSlew(self, deg)


    def baseTiltSlew(self, deg):
        """baseTiltSlew(ArDPPTU self, double deg) -> bool"""
        return _AriaPy.ArDPPTU_baseTiltSlew(self, deg)


    def upperPanSlew(self, deg):
        """upperPanSlew(ArDPPTU self, double deg) -> bool"""
        return _AriaPy.ArDPPTU_upperPanSlew(self, deg)


    def lowerPanSlew(self, deg):
        """lowerPanSlew(ArDPPTU self, double deg) -> bool"""
        return _AriaPy.ArDPPTU_lowerPanSlew(self, deg)


    def upperTiltSlew(self, deg):
        """upperTiltSlew(ArDPPTU self, double deg) -> bool"""
        return _AriaPy.ArDPPTU_upperTiltSlew(self, deg)


    def lowerTiltSlew(self, deg):
        """lowerTiltSlew(ArDPPTU self, double deg) -> bool"""
        return _AriaPy.ArDPPTU_lowerTiltSlew(self, deg)


    def indepMove(self):
        """indepMove(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_indepMove(self)


    def velMove(self):
        """velMove(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_velMove(self)


    def panSlew(self, deg):
        """panSlew(ArDPPTU self, double deg) -> bool"""
        return _AriaPy.ArDPPTU_panSlew(self, deg)


    def tiltSlew(self, deg):
        """tiltSlew(ArDPPTU self, double deg) -> bool"""
        return _AriaPy.ArDPPTU_tiltSlew(self, deg)


    def canPanTiltSlew(self):
        """canPanTiltSlew(ArDPPTU self) -> bool"""
        return _AriaPy.ArDPPTU_canPanTiltSlew(self)


    def panSlewRel(self, deg):
        """panSlewRel(ArDPPTU self, double deg) -> bool"""
        return _AriaPy.ArDPPTU_panSlewRel(self, deg)


    def tiltSlewRel(self, deg):
        """tiltSlewRel(ArDPPTU self, double deg) -> bool"""
        return _AriaPy.ArDPPTU_tiltSlewRel(self, deg)


    def getLastPanRequest(self):
        """getLastPanRequest(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getLastPanRequest(self)


    def getLastTiltRequest(self):
        """getLastTiltRequest(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getLastTiltRequest(self)


    def getPanSlew(self):
        """getPanSlew(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getPanSlew(self)


    def getTiltSlew(self):
        """getTiltSlew(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getTiltSlew(self)


    def getBasePanSlew(self):
        """getBasePanSlew(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getBasePanSlew(self)


    def getBaseTiltSlew(self):
        """getBaseTiltSlew(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getBaseTiltSlew(self)


    def getPanAccel(self):
        """getPanAccel(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getPanAccel(self)


    def getTiltAccel(self):
        """getTiltAccel(ArDPPTU self) -> double"""
        return _AriaPy.ArDPPTU_getTiltAccel(self)


    def query(self):
        """query(ArDPPTU self)"""
        return _AriaPy.ArDPPTU_query(self)

ArDPPTU_swigregister = _AriaPy.ArDPPTU_swigregister
ArDPPTU_swigregister(ArDPPTU)

class ArDeviceConnection(object):
    """Proxy of C++ ArDeviceConnection 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__ = _AriaPy.delete_ArDeviceConnection
    __del__ = lambda self: None

    def read(self, data, size, msWait=0):
        """
        read(ArDeviceConnection self, char const * data, unsigned int size, unsigned int msWait=0) -> int
        read(ArDeviceConnection self, char const * data, unsigned int size) -> int
        """
        return _AriaPy.ArDeviceConnection_read(self, data, size, msWait)


    def writePacket(self, packet):
        """writePacket(ArDeviceConnection self, ArBasePacket packet) -> int"""
        return _AriaPy.ArDeviceConnection_writePacket(self, packet)


    def write(self, data, size):
        """write(ArDeviceConnection self, char const * data, unsigned int size) -> int"""
        return _AriaPy.ArDeviceConnection_write(self, data, size)


    def getStatus(self):
        """getStatus(ArDeviceConnection self) -> int"""
        return _AriaPy.ArDeviceConnection_getStatus(self)


    def getStatusMessage(self, messageNumber):
        """getStatusMessage(ArDeviceConnection self, int messageNumber) -> char const *"""
        return _AriaPy.ArDeviceConnection_getStatusMessage(self, messageNumber)


    def openSimple(self):
        """openSimple(ArDeviceConnection self) -> bool"""
        return _AriaPy.ArDeviceConnection_openSimple(self)


    def close(self):
        """close(ArDeviceConnection self) -> bool"""
        return _AriaPy.ArDeviceConnection_close(self)


    def getOpenMessage(self, messageNumber):
        """getOpenMessage(ArDeviceConnection self, int messageNumber) -> char const *"""
        return _AriaPy.ArDeviceConnection_getOpenMessage(self, messageNumber)

    STATUS_NEVER_OPENED = _AriaPy.ArDeviceConnection_STATUS_NEVER_OPENED
    STATUS_OPEN = _AriaPy.ArDeviceConnection_STATUS_OPEN
    STATUS_OPEN_FAILED = _AriaPy.ArDeviceConnection_STATUS_OPEN_FAILED
    STATUS_CLOSED_NORMALLY = _AriaPy.ArDeviceConnection_STATUS_CLOSED_NORMALLY
    STATUS_CLOSED_ERROR = _AriaPy.ArDeviceConnection_STATUS_CLOSED_ERROR

    def getTimeRead(self, index):
        """getTimeRead(ArDeviceConnection self, int index) -> ArTime"""
        return _AriaPy.ArDeviceConnection_getTimeRead(self, index)


    def isTimeStamping(self):
        """isTimeStamping(ArDeviceConnection self) -> bool"""
        return _AriaPy.ArDeviceConnection_isTimeStamping(self)


    def getPortName(self):
        """getPortName(ArDeviceConnection self) -> char const *"""
        return _AriaPy.ArDeviceConnection_getPortName(self)


    def getPortType(self):
        """getPortType(ArDeviceConnection self) -> char const *"""
        return _AriaPy.ArDeviceConnection_getPortType(self)


    def setDeviceName(self, deviceName):
        """setDeviceName(ArDeviceConnection self, char const * deviceName)"""
        return _AriaPy.ArDeviceConnection_setDeviceName(self, deviceName)


    def getDeviceName(self):
        """getDeviceName(ArDeviceConnection self) -> char const *"""
        return _AriaPy.ArDeviceConnection_getDeviceName(self)


    def debugStartPacket(self):
        """debugStartPacket(ArDeviceConnection self)"""
        return _AriaPy.ArDeviceConnection_debugStartPacket(self)


    def debugBytesRead(self, bytesRead):
        """debugBytesRead(ArDeviceConnection self, int bytesRead)"""
        return _AriaPy.ArDeviceConnection_debugBytesRead(self, bytesRead)


    def debugEndPacket(self, goodPacket, type=0):
        """
        debugEndPacket(ArDeviceConnection self, bool goodPacket, int type=0)
        debugEndPacket(ArDeviceConnection self, bool goodPacket)
        """
        return _AriaPy.ArDeviceConnection_debugEndPacket(self, goodPacket, type)


    def debugShouldLog(shouldLog):
        """debugShouldLog(bool shouldLog) -> bool"""
        return _AriaPy.ArDeviceConnection_debugShouldLog(shouldLog)

    debugShouldLog = staticmethod(debugShouldLog)
ArDeviceConnection_swigregister = _AriaPy.ArDeviceConnection_swigregister
ArDeviceConnection_swigregister(ArDeviceConnection)

def ArDeviceConnection_debugShouldLog(shouldLog):
    """ArDeviceConnection_debugShouldLog(bool shouldLog) -> bool"""
    return _AriaPy.ArDeviceConnection_debugShouldLog(shouldLog)

class ArColor(object):
    """Proxy of C++ ArColor 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__(ArColor self, unsigned char red, unsigned char green, unsigned char blue) -> ArColor
        __init__(ArColor self) -> ArColor
        __init__(ArColor self, ArTypes::Byte4 rgbValue) -> ArColor
        """
        this = _AriaPy.new_ArColor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArColor
    __del__ = lambda self: None

    def getRed(self):
        """getRed(ArColor self) -> unsigned char"""
        return _AriaPy.ArColor_getRed(self)


    def getGreen(self):
        """getGreen(ArColor self) -> unsigned char"""
        return _AriaPy.ArColor_getGreen(self)


    def getBlue(self):
        """getBlue(ArColor self) -> unsigned char"""
        return _AriaPy.ArColor_getBlue(self)


    def colorToByte4(self):
        """colorToByte4(ArColor self) -> ArTypes::Byte4"""
        return _AriaPy.ArColor_colorToByte4(self)

ArColor_swigregister = _AriaPy.ArColor_swigregister
ArColor_swigregister(ArColor)

class ArDrawingData(object):
    """Proxy of C++ ArDrawingData class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    DEFAULT_REFRESH_TIME = _AriaPy.ArDrawingData_DEFAULT_REFRESH_TIME

    def __init__(self, *args):
        """
        __init__(ArDrawingData self, char const * shape, ArColor primaryColor, int size, int layer, unsigned int defaultRefreshTime, char const * visibility) -> ArDrawingData
        __init__(ArDrawingData self, char const * shape, ArColor primaryColor, int size, int layer, unsigned int defaultRefreshTime) -> ArDrawingData
        __init__(ArDrawingData self, char const * shape, ArColor primaryColor, int size, int layer) -> ArDrawingData
        __init__(ArDrawingData self, char const * shape, ArColor primaryColor, int size, int layer, unsigned int defaultRefreshTime, ArColor secondaryColor, char const * visibility) -> ArDrawingData
        __init__(ArDrawingData self, char const * shape, ArColor primaryColor, int size, int layer, unsigned int defaultRefreshTime, ArColor secondaryColor) -> ArDrawingData
        """
        this = _AriaPy.new_ArDrawingData(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArDrawingData
    __del__ = lambda self: None

    def getShape(self):
        """getShape(ArDrawingData self) -> char const *"""
        return _AriaPy.ArDrawingData_getShape(self)


    def getPrimaryColor(self):
        """getPrimaryColor(ArDrawingData self) -> ArColor"""
        return _AriaPy.ArDrawingData_getPrimaryColor(self)


    def getSize(self):
        """getSize(ArDrawingData self) -> int"""
        return _AriaPy.ArDrawingData_getSize(self)


    def getLayer(self):
        """getLayer(ArDrawingData self) -> int"""
        return _AriaPy.ArDrawingData_getLayer(self)


    def getDefaultRefreshTime(self):
        """getDefaultRefreshTime(ArDrawingData self) -> unsigned int"""
        return _AriaPy.ArDrawingData_getDefaultRefreshTime(self)


    def getSecondaryColor(self):
        """getSecondaryColor(ArDrawingData self) -> ArColor"""
        return _AriaPy.ArDrawingData_getSecondaryColor(self)


    def getVisibility(self):
        """getVisibility(ArDrawingData self) -> char const *"""
        return _AriaPy.ArDrawingData_getVisibility(self)


    def setShape(self, shape):
        """setShape(ArDrawingData self, char const * shape)"""
        return _AriaPy.ArDrawingData_setShape(self, shape)


    def setPrimaryColor(self, color):
        """setPrimaryColor(ArDrawingData self, ArColor color)"""
        return _AriaPy.ArDrawingData_setPrimaryColor(self, color)


    def setSize(self, size):
        """setSize(ArDrawingData self, int size)"""
        return _AriaPy.ArDrawingData_setSize(self, size)


    def setLayer(self, layer):
        """setLayer(ArDrawingData self, int layer)"""
        return _AriaPy.ArDrawingData_setLayer(self, layer)


    def setDefaultRefreshTime(self, refreshTime):
        """setDefaultRefreshTime(ArDrawingData self, unsigned int refreshTime)"""
        return _AriaPy.ArDrawingData_setDefaultRefreshTime(self, refreshTime)


    def setSecondaryColor(self, color):
        """setSecondaryColor(ArDrawingData self, ArColor color)"""
        return _AriaPy.ArDrawingData_setSecondaryColor(self, color)


    def setVisibility(self, visibility):
        """setVisibility(ArDrawingData self, char const * visibility)"""
        return _AriaPy.ArDrawingData_setVisibility(self, visibility)

ArDrawingData_swigregister = _AriaPy.ArDrawingData_swigregister
ArDrawingData_swigregister(ArDrawingData)

class ArFileParser(object):
    """Proxy of C++ ArFileParser 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__(ArFileParser self, char const * baseDirectory, bool isPreCompressQuotes=False) -> ArFileParser
        __init__(ArFileParser self, char const * baseDirectory) -> ArFileParser
        __init__(ArFileParser self) -> ArFileParser
        """
        this = _AriaPy.new_ArFileParser(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArFileParser
    __del__ = lambda self: None

    def addHandler(self, keyword, functor):
        """addHandler(ArFileParser self, char const * keyword, ArRetFunctor1_Bool_ArgumentBuilderP functor) -> bool"""
        return _AriaPy.ArFileParser_addHandler(self, keyword, functor)


    def addHandlerWithError(self, keyword, functor):
        """addHandlerWithError(ArFileParser self, char const * keyword, ArRetFunctor3< bool,ArArgumentBuilder *,char *,size_t > * functor) -> bool"""
        return _AriaPy.ArFileParser_addHandlerWithError(self, keyword, functor)


    def remHandler(self, *args):
        """
        remHandler(ArFileParser self, char const * keyword, bool logIfCannotFind=True) -> bool
        remHandler(ArFileParser self, char const * keyword) -> bool
        remHandler(ArFileParser self, ArRetFunctor1_Bool_ArgumentBuilderP functor) -> bool
        remHandler(ArFileParser self, ArRetFunctor3< bool,ArArgumentBuilder *,char *,size_t > * functor) -> bool
        """
        return _AriaPy.ArFileParser_remHandler(self, *args)


    def setPreParseFunctor(self, functor):
        """setPreParseFunctor(ArFileParser self, ArFunctor1_CString functor)"""
        return _AriaPy.ArFileParser_setPreParseFunctor(self, functor)


    def parseFile(self, *args):
        """
        parseFile(ArFileParser self, char const * fileName, bool continueOnErrors=True, bool noFileNotFoundMessage=False, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseFile(ArFileParser self, char const * fileName, bool continueOnErrors=True, bool noFileNotFoundMessage=False, char * errorBuffer=None) -> bool
        parseFile(ArFileParser self, char const * fileName, bool continueOnErrors=True, bool noFileNotFoundMessage=False) -> bool
        parseFile(ArFileParser self, char const * fileName, bool continueOnErrors=True) -> bool
        parseFile(ArFileParser self, char const * fileName) -> bool
        parseFile(ArFileParser self, FILE * file, char * buffer, int bufferLength, bool continueOnErrors=True, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseFile(ArFileParser self, FILE * file, char * buffer, int bufferLength, bool continueOnErrors=True, char * errorBuffer=None) -> bool
        parseFile(ArFileParser self, FILE * file, char * buffer, int bufferLength, bool continueOnErrors=True) -> bool
        parseFile(ArFileParser self, FILE * file, char * buffer, int bufferLength) -> bool
        """
        return _AriaPy.ArFileParser_parseFile(self, *args)


    def cancelParsing(self):
        """cancelParsing(ArFileParser self)"""
        return _AriaPy.ArFileParser_cancelParsing(self)


    def getBaseDirectory(self):
        """getBaseDirectory(ArFileParser self) -> char const *"""
        return _AriaPy.ArFileParser_getBaseDirectory(self)


    def setBaseDirectory(self, baseDirectory):
        """setBaseDirectory(ArFileParser self, char const * baseDirectory)"""
        return _AriaPy.ArFileParser_setBaseDirectory(self, baseDirectory)


    def setCommentDelimiters(self, delimiters):
        """setCommentDelimiters(ArFileParser self, std::list< std::string,std::allocator< std::string > > const & delimiters)"""
        return _AriaPy.ArFileParser_setCommentDelimiters(self, delimiters)


    def clearCommentDelimiters(self):
        """clearCommentDelimiters(ArFileParser self)"""
        return _AriaPy.ArFileParser_clearCommentDelimiters(self)


    def parseLine(self, line, errorBuffer=None, errorBufferLen=0):
        """
        parseLine(ArFileParser self, char * line, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseLine(ArFileParser self, char * line, char * errorBuffer=None) -> bool
        parseLine(ArFileParser self, char * line) -> bool
        """
        return _AriaPy.ArFileParser_parseLine(self, line, errorBuffer, errorBufferLen)


    def resetCounters(self):
        """resetCounters(ArFileParser self)"""
        return _AriaPy.ArFileParser_resetCounters(self)


    def setMaxNumArguments(self, maxNumArguments=512):
        """
        setMaxNumArguments(ArFileParser self, size_t maxNumArguments=512)
        setMaxNumArguments(ArFileParser self)
        """
        return _AriaPy.ArFileParser_setMaxNumArguments(self, maxNumArguments)


    def setQuiet(self, isQuiet):
        """setQuiet(ArFileParser self, bool isQuiet)"""
        return _AriaPy.ArFileParser_setQuiet(self, isQuiet)

ArFileParser_swigregister = _AriaPy.ArFileParser_swigregister
ArFileParser_swigregister(ArFileParser)

class ArForbiddenRangeDevice(ArRangeDevice):
    """Proxy of C++ ArForbiddenRangeDevice 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__(ArForbiddenRangeDevice self, ArMapInterface armap, double distanceIncrement=100, unsigned int maxRange=4000, char const * name) -> ArForbiddenRangeDevice
        __init__(ArForbiddenRangeDevice self, ArMapInterface armap, double distanceIncrement=100, unsigned int maxRange=4000) -> ArForbiddenRangeDevice
        __init__(ArForbiddenRangeDevice self, ArMapInterface armap, double distanceIncrement=100) -> ArForbiddenRangeDevice
        __init__(ArForbiddenRangeDevice self, ArMapInterface armap) -> ArForbiddenRangeDevice
        """
        this = _AriaPy.new_ArForbiddenRangeDevice(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArForbiddenRangeDevice
    __del__ = lambda self: None

    def processMap(self):
        """processMap(ArForbiddenRangeDevice self)"""
        return _AriaPy.ArForbiddenRangeDevice_processMap(self)


    def processReadings(self):
        """processReadings(ArForbiddenRangeDevice self)"""
        return _AriaPy.ArForbiddenRangeDevice_processReadings(self)


    def setRobot(self, robot):
        """setRobot(ArForbiddenRangeDevice self, ArRobot robot)"""
        return _AriaPy.ArForbiddenRangeDevice_setRobot(self, robot)


    def enable(self):
        """enable(ArForbiddenRangeDevice self)"""
        return _AriaPy.ArForbiddenRangeDevice_enable(self)


    def disable(self):
        """disable(ArForbiddenRangeDevice self)"""
        return _AriaPy.ArForbiddenRangeDevice_disable(self)


    def isEnabled(self):
        """isEnabled(ArForbiddenRangeDevice self) -> bool"""
        return _AriaPy.ArForbiddenRangeDevice_isEnabled(self)


    def getEnableCB(self):
        """getEnableCB(ArForbiddenRangeDevice self) -> ArFunctor"""
        return _AriaPy.ArForbiddenRangeDevice_getEnableCB(self)


    def getDisableCB(self):
        """getDisableCB(ArForbiddenRangeDevice self) -> ArFunctor"""
        return _AriaPy.ArForbiddenRangeDevice_getDisableCB(self)

ArForbiddenRangeDevice_swigregister = _AriaPy.ArForbiddenRangeDevice_swigregister
ArForbiddenRangeDevice_swigregister(ArForbiddenRangeDevice)

class ArFunctorASyncTask(ArASyncTask):
    """Proxy of C++ ArFunctorASyncTask 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, functor):
        """__init__(ArFunctorASyncTask self, ArRetFunctor1_VoidP_VoidP functor) -> ArFunctorASyncTask"""
        this = _AriaPy.new_ArFunctorASyncTask(functor)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArFunctorASyncTask
    __del__ = lambda self: None

    def runThread(self, arg):
        """runThread(ArFunctorASyncTask self, void * arg) -> void *"""
        return _AriaPy.ArFunctorASyncTask_runThread(self, arg)

ArFunctorASyncTask_swigregister = _AriaPy.ArFunctorASyncTask_swigregister
ArFunctorASyncTask_swigregister(ArFunctorASyncTask)

class ArGPS(object):
    """Proxy of C++ ArGPS 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):
        """__init__(ArGPS self) -> ArGPS"""
        this = _AriaPy.new_ArGPS()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArGPS
    __del__ = lambda self: None

    def setDeviceConnection(self, deviceConn):
        """setDeviceConnection(ArGPS self, ArDeviceConnection deviceConn)"""
        return _AriaPy.ArGPS_setDeviceConnection(self, deviceConn)


    def getDeviceConnection(self):
        """getDeviceConnection(ArGPS self) -> ArDeviceConnection"""
        return _AriaPy.ArGPS_getDeviceConnection(self)


    def connect(self, connectTimeout=20000):
        """
        connect(ArGPS self, unsigned long connectTimeout=20000) -> bool
        connect(ArGPS self) -> bool
        """
        return _AriaPy.ArGPS_connect(self, connectTimeout)


    def blockingConnect(self, connectTimeout=20000):
        """
        blockingConnect(ArGPS self, unsigned long connectTimeout=20000) -> bool
        blockingConnect(ArGPS self) -> bool
        """
        return _AriaPy.ArGPS_blockingConnect(self, connectTimeout)

    ReadFinished = _AriaPy.ArGPS_ReadFinished
    ReadError = _AriaPy.ArGPS_ReadError
    ReadData = _AriaPy.ArGPS_ReadData
    ReadUpdated = _AriaPy.ArGPS_ReadUpdated
    ReadFlags = _swig_property(_AriaPy.ArGPS_ReadFlags_get, _AriaPy.ArGPS_ReadFlags_set)

    def read(self, maxTime=0):
        """
        read(ArGPS self, unsigned long maxTime=0) -> int
        read(ArGPS self) -> int
        """
        return _AriaPy.ArGPS_read(self, maxTime)


    def readWithLock(self, maxTime):
        """readWithLock(ArGPS self, unsigned int maxTime) -> int"""
        return _AriaPy.ArGPS_readWithLock(self, maxTime)


    def lock(self):
        """lock(ArGPS self)"""
        return _AriaPy.ArGPS_lock(self)


    def unlock(self):
        """unlock(ArGPS self)"""
        return _AriaPy.ArGPS_unlock(self)


    def setIgnoreChecksum(self, ignore):
        """setIgnoreChecksum(ArGPS self, bool ignore)"""
        return _AriaPy.ArGPS_setIgnoreChecksum(self, ignore)


    def logData(self):
        """logData(ArGPS self)"""
        return _AriaPy.ArGPS_logData(self)


    def printData(self, labels=True):
        """
        printData(ArGPS self, bool labels=True)
        printData(ArGPS self)
        """
        return _AriaPy.ArGPS_printData(self, labels)


    def printDataLabelsHeader(self):
        """printDataLabelsHeader(ArGPS self)"""
        return _AriaPy.ArGPS_printDataLabelsHeader(self)

    NoFix = _AriaPy.ArGPS_NoFix
    BadFix = _AriaPy.ArGPS_BadFix
    GPSFix = _AriaPy.ArGPS_GPSFix
    DGPSFix = _AriaPy.ArGPS_DGPSFix
    PPSFix = _AriaPy.ArGPS_PPSFix
    RTKinFix = _AriaPy.ArGPS_RTKinFix
    FloatRTKinFix = _AriaPy.ArGPS_FloatRTKinFix
    DeadReckFix = _AriaPy.ArGPS_DeadReckFix
    ManualFix = _AriaPy.ArGPS_ManualFix
    SimulatedFix = _AriaPy.ArGPS_SimulatedFix
    UnknownFixType = _AriaPy.ArGPS_UnknownFixType
    OmnistarConverging = _AriaPy.ArGPS_OmnistarConverging
    OmnistarConverged = _AriaPy.ArGPS_OmnistarConverged

    def getCurrentDataRef(self):
        """getCurrentDataRef(ArGPS self) -> ArGPS::Data const &"""
        return _AriaPy.ArGPS_getCurrentDataRef(self)


    def getFixType(self):
        """getFixType(ArGPS self) -> ArGPS::FixType"""
        return _AriaPy.ArGPS_getFixType(self)


    def getFixTypeName(*args):
        """
        getFixTypeName() -> char const
        getFixTypeName(ArGPS::FixType type) -> char const *
        """
        return _AriaPy.ArGPS_getFixTypeName(*args)

    getFixTypeName = staticmethod(getFixTypeName)

    def havePosition(self):
        """havePosition(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_havePosition(self)


    def haveLatitude(self):
        """haveLatitude(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveLatitude(self)


    def haveLongitude(self):
        """haveLongitude(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveLongitude(self)


    def getLatitude(self):
        """getLatitude(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getLatitude(self)


    def getLongitude(self):
        """getLongitude(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getLongitude(self)


    def getTimeReceivedPosition(self):
        """getTimeReceivedPosition(ArGPS self) -> ArTime"""
        return _AriaPy.ArGPS_getTimeReceivedPosition(self)


    def haveSpeed(self):
        """haveSpeed(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveSpeed(self)


    def getSpeed(self):
        """getSpeed(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getSpeed(self)


    def getGPSPositionTimestamp(self):
        """getGPSPositionTimestamp(ArGPS self) -> ArTime"""
        return _AriaPy.ArGPS_getGPSPositionTimestamp(self)


    def getNumSatellitesTracked(self):
        """getNumSatellitesTracked(ArGPS self) -> int"""
        return _AriaPy.ArGPS_getNumSatellitesTracked(self)


    def haveDGPSStation(self):
        """haveDGPSStation(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveDGPSStation(self)


    def getDGPSStationID(self):
        """getDGPSStationID(ArGPS self) -> unsigned short"""
        return _AriaPy.ArGPS_getDGPSStationID(self)


    def haveGarminPositionError(self):
        """haveGarminPositionError(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveGarminPositionError(self)


    def getGarminPositionError(self):
        """getGarminPositionError(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getGarminPositionError(self)


    def haveGarminVerticalPositionError(self):
        """haveGarminVerticalPositionError(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveGarminVerticalPositionError(self)


    def getGarminVerticalPositionError(self):
        """getGarminVerticalPositionError(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getGarminVerticalPositionError(self)


    def haveCompassHeadingMag(self):
        """haveCompassHeadingMag(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveCompassHeadingMag(self)


    def haveCompassHeadingTrue(self):
        """haveCompassHeadingTrue(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveCompassHeadingTrue(self)


    def getCompassHeadingMag(self):
        """getCompassHeadingMag(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getCompassHeadingMag(self)


    def getCompassHeadingTrue(self):
        """getCompassHeadingTrue(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getCompassHeadingTrue(self)


    def setCompassHeadingMag(self, val):
        """setCompassHeadingMag(ArGPS self, double val)"""
        return _AriaPy.ArGPS_setCompassHeadingMag(self, val)


    def setCompassHeadingTrue(self, val):
        """setCompassHeadingTrue(ArGPS self, double val)"""
        return _AriaPy.ArGPS_setCompassHeadingTrue(self, val)


    def setCompassHeadingMagWithLock(self, val):
        """setCompassHeadingMagWithLock(ArGPS self, double val)"""
        return _AriaPy.ArGPS_setCompassHeadingMagWithLock(self, val)


    def setCompassHeadingTrueWithLock(self, val):
        """setCompassHeadingTrueWithLock(ArGPS self, double val)"""
        return _AriaPy.ArGPS_setCompassHeadingTrueWithLock(self, val)


    def haveAltitude(self):
        """haveAltitude(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveAltitude(self)


    def getAltitude(self):
        """getAltitude(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getAltitude(self)


    def haveAltimeter(self):
        """haveAltimeter(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveAltimeter(self)


    def getAltimeter(self):
        """getAltimeter(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getAltimeter(self)


    def haveHDOP(self):
        """haveHDOP(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveHDOP(self)


    def getHDOP(self):
        """getHDOP(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getHDOP(self)


    def haveVDOP(self):
        """haveVDOP(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveVDOP(self)


    def getVDOP(self):
        """getVDOP(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getVDOP(self)


    def havePDOP(self):
        """havePDOP(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_havePDOP(self)


    def getPDOP(self):
        """getPDOP(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getPDOP(self)


    def haveSNR(self):
        """haveSNR(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveSNR(self)


    def getMeanSNR(self):
        """getMeanSNR(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getMeanSNR(self)


    def haveBeaconInfo(self):
        """haveBeaconInfo(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveBeaconInfo(self)


    def getBeaconSignalStrength(self):
        """getBeaconSignalStrength(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getBeaconSignalStrength(self)


    def getBeaconSNR(self):
        """getBeaconSNR(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getBeaconSNR(self)


    def getBeaconFreq(self):
        """getBeaconFreq(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getBeaconFreq(self)


    def getBecaonBPS(self):
        """getBecaonBPS(ArGPS self) -> unsigned short"""
        return _AriaPy.ArGPS_getBecaonBPS(self)


    def getBeaconChannel(self):
        """getBeaconChannel(ArGPS self) -> unsigned short"""
        return _AriaPy.ArGPS_getBeaconChannel(self)


    def haveErrorEllipse(self):
        """haveErrorEllipse(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveErrorEllipse(self)


    def getErrorEllipse(self):
        """getErrorEllipse(ArGPS self) -> ArPose"""
        return _AriaPy.ArGPS_getErrorEllipse(self)


    def haveLatLonError(self):
        """haveLatLonError(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveLatLonError(self)


    def getLatLonError(self):
        """getLatLonError(ArGPS self) -> ArPose"""
        return _AriaPy.ArGPS_getLatLonError(self)


    def getLatitudeError(self):
        """getLatitudeError(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getLatitudeError(self)


    def getLongitudeError(self):
        """getLongitudeError(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getLongitudeError(self)


    def haveAltitudeError(self):
        """haveAltitudeError(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveAltitudeError(self)


    def getAltitudeError(self):
        """getAltitudeError(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getAltitudeError(self)


    def haveInputsRMS(self):
        """haveInputsRMS(ArGPS self) -> bool"""
        return _AriaPy.ArGPS_haveInputsRMS(self)


    def getInputsRMS(self):
        """getInputsRMS(ArGPS self) -> double"""
        return _AriaPy.ArGPS_getInputsRMS(self)


    def addNMEAHandler(self, message, handler):
        """addNMEAHandler(ArGPS self, char const * message, ArNMEAParser::Handler * handler)"""
        return _AriaPy.ArGPS_addNMEAHandler(self, message, handler)


    def removeNMEAHandler(self, message):
        """removeNMEAHandler(ArGPS self, char const * message)"""
        return _AriaPy.ArGPS_removeNMEAHandler(self, message)


    def replaceNMEAHandler(self, message, handler):
        """replaceNMEAHandler(ArGPS self, char const * message, ArNMEAParser::Handler * handler)"""
        return _AriaPy.ArGPS_replaceNMEAHandler(self, message, handler)

ArGPS_swigregister = _AriaPy.ArGPS_swigregister
ArGPS_swigregister(ArGPS)

def ArGPS_getFixTypeName(*args):
    """
    getFixTypeName() -> char const
    ArGPS_getFixTypeName(ArGPS::FixType type) -> char const *
    """
    return _AriaPy.ArGPS_getFixTypeName(*args)

class ArSimulatedGPS(ArGPS):
    """Proxy of C++ ArSimulatedGPS 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, robot=None):
        """
        __init__(ArSimulatedGPS self, ArRobot robot=None) -> ArSimulatedGPS
        __init__(ArSimulatedGPS self) -> ArSimulatedGPS
        """
        this = _AriaPy.new_ArSimulatedGPS(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSimulatedGPS
    __del__ = lambda self: None

    def clearDummyPosition(self):
        """clearDummyPosition(ArSimulatedGPS self)"""
        return _AriaPy.ArSimulatedGPS_clearDummyPosition(self)


    def clearPosition(self):
        """clearPosition(ArSimulatedGPS self)"""
        return _AriaPy.ArSimulatedGPS_clearPosition(self)


    def setDummyPosition(self, *args):
        """
        setDummyPosition(ArSimulatedGPS self, double latitude, double longitude)
        setDummyPosition(ArSimulatedGPS self, double latitude, double longitude, double altitude)
        setDummyPosition(ArSimulatedGPS self, ArArgumentBuilder args)
        """
        return _AriaPy.ArSimulatedGPS_setDummyPosition(self, *args)


    def setDummyPositionFromArgs(self, args):
        """setDummyPositionFromArgs(ArSimulatedGPS self, ArArgumentBuilder args)"""
        return _AriaPy.ArSimulatedGPS_setDummyPositionFromArgs(self, args)


    def connect(self, connectTimeout=10000):
        """
        connect(ArSimulatedGPS self, unsigned long connectTimeout=10000) -> bool
        connect(ArSimulatedGPS self) -> bool
        """
        return _AriaPy.ArSimulatedGPS_connect(self, connectTimeout)


    def initDevice(self):
        """initDevice(ArSimulatedGPS self) -> bool"""
        return _AriaPy.ArSimulatedGPS_initDevice(self)


    def read(self, maxTime=0):
        """
        read(ArSimulatedGPS self, unsigned long maxTime=0) -> int
        read(ArSimulatedGPS self) -> int
        """
        return _AriaPy.ArSimulatedGPS_read(self, maxTime)

ArSimulatedGPS_swigregister = _AriaPy.ArSimulatedGPS_swigregister
ArSimulatedGPS_swigregister(ArSimulatedGPS)

class ArGPSConnector(object):
    """Proxy of C++ ArGPSConnector 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, argParser):
        """__init__(ArGPSConnector self, ArArgumentParser argParser) -> ArGPSConnector"""
        this = _AriaPy.new_ArGPSConnector(argParser)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArGPSConnector
    __del__ = lambda self: None

    def parseArgs(self):
        """parseArgs(ArGPSConnector self) -> bool"""
        return _AriaPy.ArGPSConnector_parseArgs(self)


    def createGPS(self, robot=None):
        """
        createGPS(ArGPSConnector self, ArRobot robot=None) -> ArGPS
        createGPS(ArGPSConnector self) -> ArGPS
        """
        return _AriaPy.ArGPSConnector_createGPS(self, robot)


    def create(self, robot=None):
        """
        create(ArGPSConnector self, ArRobot robot=None) -> ArGPS
        create(ArGPSConnector self) -> ArGPS
        """
        return _AriaPy.ArGPSConnector_create(self, robot)

    Standard = _AriaPy.ArGPSConnector_Standard
    Novatel = _AriaPy.ArGPSConnector_Novatel
    Trimble = _AriaPy.ArGPSConnector_Trimble
    Invalid = _AriaPy.ArGPSConnector_Invalid
    NovatelSPAN = _AriaPy.ArGPSConnector_NovatelSPAN
    Simulator = _AriaPy.ArGPSConnector_Simulator

    def getGPSType(self):
        """getGPSType(ArGPSConnector self) -> ArGPSConnector::GPSType"""
        return _AriaPy.ArGPSConnector_getGPSType(self)

ArGPSConnector_swigregister = _AriaPy.ArGPSConnector_swigregister
ArGPSConnector_swigregister(ArGPSConnector)

class Ar3DPoint(object):
    """Proxy of C++ Ar3DPoint 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__(Ar3DPoint self) -> Ar3DPoint
        __init__(Ar3DPoint self, double x, double y, double z) -> Ar3DPoint
        """
        this = _AriaPy.new_Ar3DPoint(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_Ar3DPoint
    __del__ = lambda self: None

    def __add__(self, c):
        """__add__(Ar3DPoint self, Ar3DPoint c) -> Ar3DPoint"""
        return _AriaPy.Ar3DPoint___add__(self, c)


    def __sub__(self, c):
        """__sub__(Ar3DPoint self, Ar3DPoint c) -> Ar3DPoint"""
        return _AriaPy.Ar3DPoint___sub__(self, c)


    def __mul__(self, c):
        """__mul__(Ar3DPoint self, double c) -> Ar3DPoint"""
        return _AriaPy.Ar3DPoint___mul__(self, c)


    def dot(self, c):
        """dot(Ar3DPoint self, Ar3DPoint c) -> double"""
        return _AriaPy.Ar3DPoint_dot(self, c)


    def cross(self, c):
        """cross(Ar3DPoint self, Ar3DPoint c) -> Ar3DPoint"""
        return _AriaPy.Ar3DPoint_cross(self, c)


    def printPoint(self, head=None):
        """
        printPoint(Ar3DPoint self, char const * head=None)
        printPoint(Ar3DPoint self)
        """
        return _AriaPy.Ar3DPoint_printPoint(self, head)


    def getX(self):
        """getX(Ar3DPoint self) -> double"""
        return _AriaPy.Ar3DPoint_getX(self)


    def getY(self):
        """getY(Ar3DPoint self) -> double"""
        return _AriaPy.Ar3DPoint_getY(self)


    def getZ(self):
        """getZ(Ar3DPoint self) -> double"""
        return _AriaPy.Ar3DPoint_getZ(self)


    def setX(self, x):
        """setX(Ar3DPoint self, double x)"""
        return _AriaPy.Ar3DPoint_setX(self, x)


    def setY(self, y):
        """setY(Ar3DPoint self, double y)"""
        return _AriaPy.Ar3DPoint_setY(self, y)


    def setZ(self, z):
        """setZ(Ar3DPoint self, double z)"""
        return _AriaPy.Ar3DPoint_setZ(self, z)

Ar3DPoint_swigregister = _AriaPy.Ar3DPoint_swigregister
Ar3DPoint_swigregister(Ar3DPoint)

class ArWGS84(object):
    """Proxy of C++ ArWGS84 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):
        """__init__(ArWGS84 self) -> ArWGS84"""
        this = _AriaPy.new_ArWGS84()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getE():
        """getE() -> double"""
        return _AriaPy.ArWGS84_getE()

    getE = staticmethod(getE)

    def getA():
        """getA() -> double"""
        return _AriaPy.ArWGS84_getA()

    getA = staticmethod(getA)

    def getB():
        """getB() -> double"""
        return _AriaPy.ArWGS84_getB()

    getB = staticmethod(getB)

    def getEP():
        """getEP() -> double"""
        return _AriaPy.ArWGS84_getEP()

    getEP = staticmethod(getEP)

    def get1byf():
        """get1byf() -> double"""
        return _AriaPy.ArWGS84_get1byf()

    get1byf = staticmethod(get1byf)

    def getOmega():
        """getOmega() -> double"""
        return _AriaPy.ArWGS84_getOmega()

    getOmega = staticmethod(getOmega)

    def getGM():
        """getGM() -> double"""
        return _AriaPy.ArWGS84_getGM()

    getGM = staticmethod(getGM)
    __swig_destroy__ = _AriaPy.delete_ArWGS84
    __del__ = lambda self: None
ArWGS84_swigregister = _AriaPy.ArWGS84_swigregister
ArWGS84_swigregister(ArWGS84)

def ArWGS84_getE():
    """ArWGS84_getE() -> double"""
    return _AriaPy.ArWGS84_getE()

def ArWGS84_getA():
    """ArWGS84_getA() -> double"""
    return _AriaPy.ArWGS84_getA()

def ArWGS84_getB():
    """ArWGS84_getB() -> double"""
    return _AriaPy.ArWGS84_getB()

def ArWGS84_getEP():
    """ArWGS84_getEP() -> double"""
    return _AriaPy.ArWGS84_getEP()

def ArWGS84_get1byf():
    """ArWGS84_get1byf() -> double"""
    return _AriaPy.ArWGS84_get1byf()

def ArWGS84_getOmega():
    """ArWGS84_getOmega() -> double"""
    return _AriaPy.ArWGS84_getOmega()

def ArWGS84_getGM():
    """ArWGS84_getGM() -> double"""
    return _AriaPy.ArWGS84_getGM()

class ArECEFCoords(Ar3DPoint):
    """Proxy of C++ ArECEFCoords 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, x, y, z):
        """__init__(ArECEFCoords self, double x, double y, double z) -> ArECEFCoords"""
        this = _AriaPy.new_ArECEFCoords(x, y, z)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def ECEF2LLA(self):
        """ECEF2LLA(ArECEFCoords self) -> ArLLACoords"""
        return _AriaPy.ArECEFCoords_ECEF2LLA(self)


    def ECEF2ENU(self, ref):
        """ECEF2ENU(ArECEFCoords self, ArECEFCoords ref) -> ArENUCoords"""
        return _AriaPy.ArECEFCoords_ECEF2ENU(self, ref)

    __swig_destroy__ = _AriaPy.delete_ArECEFCoords
    __del__ = lambda self: None
ArECEFCoords_swigregister = _AriaPy.ArECEFCoords_swigregister
ArECEFCoords_swigregister(ArECEFCoords)

class ArLLACoords(Ar3DPoint):
    """Proxy of C++ ArLLACoords 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__(ArLLACoords self) -> ArLLACoords
        __init__(ArLLACoords self, double x, double y, double z) -> ArLLACoords
        """
        this = _AriaPy.new_ArLLACoords(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def LLA2ECEF(self):
        """LLA2ECEF(ArLLACoords self) -> ArECEFCoords"""
        return _AriaPy.ArLLACoords_LLA2ECEF(self)


    def getLatitude(self):
        """getLatitude(ArLLACoords self) -> double"""
        return _AriaPy.ArLLACoords_getLatitude(self)


    def getLongitude(self):
        """getLongitude(ArLLACoords self) -> double"""
        return _AriaPy.ArLLACoords_getLongitude(self)


    def getAltitude(self):
        """getAltitude(ArLLACoords self) -> double"""
        return _AriaPy.ArLLACoords_getAltitude(self)


    def setLatitude(self, l):
        """setLatitude(ArLLACoords self, double l)"""
        return _AriaPy.ArLLACoords_setLatitude(self, l)


    def setLongitude(self, l):
        """setLongitude(ArLLACoords self, double l)"""
        return _AriaPy.ArLLACoords_setLongitude(self, l)


    def setAltitude(self, a):
        """setAltitude(ArLLACoords self, double a)"""
        return _AriaPy.ArLLACoords_setAltitude(self, a)

    __swig_destroy__ = _AriaPy.delete_ArLLACoords
    __del__ = lambda self: None
ArLLACoords_swigregister = _AriaPy.ArLLACoords_swigregister
ArLLACoords_swigregister(ArLLACoords)

class ArENUCoords(Ar3DPoint):
    """Proxy of C++ ArENUCoords 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, x, y, z):
        """__init__(ArENUCoords self, double x, double y, double z) -> ArENUCoords"""
        this = _AriaPy.new_ArENUCoords(x, y, z)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def ENU2ECEF(self, ref):
        """ENU2ECEF(ArENUCoords self, ArLLACoords ref) -> ArECEFCoords"""
        return _AriaPy.ArENUCoords_ENU2ECEF(self, ref)


    def getEast(self):
        """getEast(ArENUCoords self) -> double"""
        return _AriaPy.ArENUCoords_getEast(self)


    def getNorth(self):
        """getNorth(ArENUCoords self) -> double"""
        return _AriaPy.ArENUCoords_getNorth(self)


    def getUp(self):
        """getUp(ArENUCoords self) -> double"""
        return _AriaPy.ArENUCoords_getUp(self)


    def setEast(self, e):
        """setEast(ArENUCoords self, double e)"""
        return _AriaPy.ArENUCoords_setEast(self, e)


    def setNorth(self, n):
        """setNorth(ArENUCoords self, double n)"""
        return _AriaPy.ArENUCoords_setNorth(self, n)


    def setUp(self, u):
        """setUp(ArENUCoords self, double u)"""
        return _AriaPy.ArENUCoords_setUp(self, u)

    __swig_destroy__ = _AriaPy.delete_ArENUCoords
    __del__ = lambda self: None
ArENUCoords_swigregister = _AriaPy.ArENUCoords_swigregister
ArENUCoords_swigregister(ArENUCoords)

class ArMapGPSCoords(ArENUCoords):
    """Proxy of C++ ArMapGPSCoords 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__(ArMapGPSCoords self, ArLLACoords org) -> ArMapGPSCoords
        __init__(ArMapGPSCoords self) -> ArMapGPSCoords
        """
        this = _AriaPy.new_ArMapGPSCoords(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def convertMap2LLACoords(self, ea, no, up, lat, lon, alt):
        """convertMap2LLACoords(ArMapGPSCoords self, double const ea, double const no, double const up, double & lat, double & lon, double & alt) -> bool"""
        return _AriaPy.ArMapGPSCoords_convertMap2LLACoords(self, ea, no, up, lat, lon, alt)


    def convertLLA2MapCoords(self, *args):
        """
        convertLLA2MapCoords(ArMapGPSCoords self, double const lat, double const lon, double const alt, double & ea, double & no, double & up) -> bool
        convertLLA2MapCoords(ArMapGPSCoords self, ArLLACoords lla, double & ea, double & no, double & up) -> bool
        """
        return _AriaPy.ArMapGPSCoords_convertLLA2MapCoords(self, *args)


    def setOrigin(self, org):
        """setOrigin(ArMapGPSCoords self, ArLLACoords org)"""
        return _AriaPy.ArMapGPSCoords_setOrigin(self, org)

    myOriginECEF = _swig_property(_AriaPy.ArMapGPSCoords_myOriginECEF_get, _AriaPy.ArMapGPSCoords_myOriginECEF_set)
    myOriginLLA = _swig_property(_AriaPy.ArMapGPSCoords_myOriginLLA_get, _AriaPy.ArMapGPSCoords_myOriginLLA_set)
    myOriginSet = _swig_property(_AriaPy.ArMapGPSCoords_myOriginSet_get, _AriaPy.ArMapGPSCoords_myOriginSet_set)
    __swig_destroy__ = _AriaPy.delete_ArMapGPSCoords
    __del__ = lambda self: None
ArMapGPSCoords_swigregister = _AriaPy.ArMapGPSCoords_swigregister
ArMapGPSCoords_swigregister(ArMapGPSCoords)

class ArGripperCommands(object):
    """Proxy of C++ ArGripperCommands class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    GRIP_OPEN = _AriaPy.ArGripperCommands_GRIP_OPEN
    GRIP_CLOSE = _AriaPy.ArGripperCommands_GRIP_CLOSE
    GRIP_STOP = _AriaPy.ArGripperCommands_GRIP_STOP
    LIFT_UP = _AriaPy.ArGripperCommands_LIFT_UP
    LIFT_DOWN = _AriaPy.ArGripperCommands_LIFT_DOWN
    LIFT_STOP = _AriaPy.ArGripperCommands_LIFT_STOP
    GRIPPER_STORE = _AriaPy.ArGripperCommands_GRIPPER_STORE
    GRIPPER_DEPLOY = _AriaPy.ArGripperCommands_GRIPPER_DEPLOY
    GRIPPER_HALT = _AriaPy.ArGripperCommands_GRIPPER_HALT
    GRIP_PRESSURE = _AriaPy.ArGripperCommands_GRIP_PRESSURE
    LIFT_CARRY = _AriaPy.ArGripperCommands_LIFT_CARRY

    def __init__(self):
        """__init__(ArGripperCommands self) -> ArGripperCommands"""
        this = _AriaPy.new_ArGripperCommands()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArGripperCommands
    __del__ = lambda self: None
ArGripperCommands_swigregister = _AriaPy.ArGripperCommands_swigregister
ArGripperCommands_swigregister(ArGripperCommands)

class ArGripper(object):
    """Proxy of C++ ArGripper 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__(ArGripper self, ArRobot robot, int gripperType) -> ArGripper
        __init__(ArGripper self, ArRobot robot) -> ArGripper
        """
        this = _AriaPy.new_ArGripper(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArGripper
    __del__ = lambda self: None

    def gripOpen(self):
        """gripOpen(ArGripper self) -> bool"""
        return _AriaPy.ArGripper_gripOpen(self)


    def gripClose(self):
        """gripClose(ArGripper self) -> bool"""
        return _AriaPy.ArGripper_gripClose(self)


    def gripStop(self):
        """gripStop(ArGripper self) -> bool"""
        return _AriaPy.ArGripper_gripStop(self)


    def liftUp(self):
        """liftUp(ArGripper self) -> bool"""
        return _AriaPy.ArGripper_liftUp(self)


    def liftDown(self):
        """liftDown(ArGripper self) -> bool"""
        return _AriaPy.ArGripper_liftDown(self)


    def liftStop(self):
        """liftStop(ArGripper self) -> bool"""
        return _AriaPy.ArGripper_liftStop(self)


    def gripperStore(self):
        """gripperStore(ArGripper self) -> bool"""
        return _AriaPy.ArGripper_gripperStore(self)


    def gripperDeploy(self):
        """gripperDeploy(ArGripper self) -> bool"""
        return _AriaPy.ArGripper_gripperDeploy(self)


    def gripperHalt(self):
        """gripperHalt(ArGripper self) -> bool"""
        return _AriaPy.ArGripper_gripperHalt(self)


    def gripPressure(self, mSecIntervals):
        """gripPressure(ArGripper self, int mSecIntervals) -> bool"""
        return _AriaPy.ArGripper_gripPressure(self, mSecIntervals)


    def liftCarry(self, mSecIntervals):
        """liftCarry(ArGripper self, int mSecIntervals) -> bool"""
        return _AriaPy.ArGripper_liftCarry(self, mSecIntervals)


    def isGripMoving(self):
        """isGripMoving(ArGripper self) -> bool"""
        return _AriaPy.ArGripper_isGripMoving(self)


    def isLiftMoving(self):
        """isLiftMoving(ArGripper self) -> bool"""
        return _AriaPy.ArGripper_isLiftMoving(self)


    def getGripState(self):
        """getGripState(ArGripper self) -> int"""
        return _AriaPy.ArGripper_getGripState(self)


    def getPaddleState(self):
        """getPaddleState(ArGripper self) -> int"""
        return _AriaPy.ArGripper_getPaddleState(self)


    def getBreakBeamState(self):
        """getBreakBeamState(ArGripper self) -> int"""
        return _AriaPy.ArGripper_getBreakBeamState(self)


    def isLiftMaxed(self):
        """isLiftMaxed(ArGripper self) -> bool"""
        return _AriaPy.ArGripper_isLiftMaxed(self)


    def getType(self):
        """getType(ArGripper self) -> int"""
        return _AriaPy.ArGripper_getType(self)


    def setType(self, type):
        """setType(ArGripper self, int type)"""
        return _AriaPy.ArGripper_setType(self, type)


    def getMSecSinceLastPacket(self):
        """getMSecSinceLastPacket(ArGripper self) -> long"""
        return _AriaPy.ArGripper_getMSecSinceLastPacket(self)


    def getGraspTime(self):
        """getGraspTime(ArGripper self) -> int"""
        return _AriaPy.ArGripper_getGraspTime(self)


    def logState(self):
        """logState(ArGripper self)"""
        return _AriaPy.ArGripper_logState(self)


    def packetHandler(self, packet):
        """packetHandler(ArGripper self, ArRobotPacket packet) -> bool"""
        return _AriaPy.ArGripper_packetHandler(self, packet)


    def connectHandler(self):
        """connectHandler(ArGripper self)"""
        return _AriaPy.ArGripper_connectHandler(self)

    QUERYTYPE = _AriaPy.ArGripper_QUERYTYPE
    GENIO = _AriaPy.ArGripper_GENIO
    USERIO = _AriaPy.ArGripper_USERIO
    GRIPPAC = _AriaPy.ArGripper_GRIPPAC
    NOGRIPPER = _AriaPy.ArGripper_NOGRIPPER
ArGripper_swigregister = _AriaPy.ArGripper_swigregister
ArGripper_swigregister(ArGripper)

class ArIRs(ArRangeDevice):
    """Proxy of C++ ArIRs 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__(ArIRs self, size_t currentBufferSize=10, size_t cumulativeBufferSize=10, char const * name, int maxSecondsToKeepCurrent=15) -> ArIRs
        __init__(ArIRs self, size_t currentBufferSize=10, size_t cumulativeBufferSize=10, char const * name) -> ArIRs
        __init__(ArIRs self, size_t currentBufferSize=10, size_t cumulativeBufferSize=10) -> ArIRs
        __init__(ArIRs self, size_t currentBufferSize=10) -> ArIRs
        __init__(ArIRs self) -> ArIRs
        """
        this = _AriaPy.new_ArIRs(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArIRs
    __del__ = lambda self: None

    def setRobot(self, robot):
        """setRobot(ArIRs self, ArRobot robot)"""
        return _AriaPy.ArIRs_setRobot(self, robot)


    def processReadings(self):
        """processReadings(ArIRs self)"""
        return _AriaPy.ArIRs_processReadings(self)

ArIRs_swigregister = _AriaPy.ArIRs_swigregister
ArIRs_swigregister(ArIRs)

class ArInterpolation(object):
    """Proxy of C++ ArInterpolation 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, numberOfReadings=100):
        """
        __init__(ArInterpolation self, size_t numberOfReadings=100) -> ArInterpolation
        __init__(ArInterpolation self) -> ArInterpolation
        """
        this = _AriaPy.new_ArInterpolation(numberOfReadings)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArInterpolation
    __del__ = lambda self: None

    def addReading(self, timeOfReading, position):
        """addReading(ArInterpolation self, ArTime timeOfReading, ArPose position) -> bool"""
        return _AriaPy.ArInterpolation_addReading(self, timeOfReading, position)


    def getPose(self, timeStamp, position, lastData=None):
        """
        getPose(ArInterpolation self, ArTime timeStamp, ArPose position, ArPoseWithTime lastData=None) -> int
        getPose(ArInterpolation self, ArTime timeStamp, ArPose position) -> int
        """
        return _AriaPy.ArInterpolation_getPose(self, timeStamp, position, lastData)


    def setName(self, name):
        """setName(ArInterpolation self, char const * name)"""
        return _AriaPy.ArInterpolation_setName(self, name)


    def getName(self):
        """getName(ArInterpolation self) -> char const *"""
        return _AriaPy.ArInterpolation_getName(self)


    def setAllowedMSForPrediction(self, ms=-1):
        """
        setAllowedMSForPrediction(ArInterpolation self, int ms=-1)
        setAllowedMSForPrediction(ArInterpolation self)
        """
        return _AriaPy.ArInterpolation_setAllowedMSForPrediction(self, ms)


    def getAllowedMSForPrediction(self):
        """getAllowedMSForPrediction(ArInterpolation self) -> int"""
        return _AriaPy.ArInterpolation_getAllowedMSForPrediction(self)


    def setAllowedPercentageForPrediction(self, percentage=5000):
        """
        setAllowedPercentageForPrediction(ArInterpolation self, int percentage=5000)
        setAllowedPercentageForPrediction(ArInterpolation self)
        """
        return _AriaPy.ArInterpolation_setAllowedPercentageForPrediction(self, percentage)


    def getAllowedPercentageForPrediction(self):
        """getAllowedPercentageForPrediction(ArInterpolation self) -> int"""
        return _AriaPy.ArInterpolation_getAllowedPercentageForPrediction(self)


    def setLogPrediction(self, logPrediction=False):
        """
        setLogPrediction(ArInterpolation self, bool logPrediction=False)
        setLogPrediction(ArInterpolation self)
        """
        return _AriaPy.ArInterpolation_setLogPrediction(self, logPrediction)


    def getLogPrediction(self):
        """getLogPrediction(ArInterpolation self) -> bool"""
        return _AriaPy.ArInterpolation_getLogPrediction(self)


    def setNumberOfReadings(self, numberOfReadings):
        """setNumberOfReadings(ArInterpolation self, size_t numberOfReadings)"""
        return _AriaPy.ArInterpolation_setNumberOfReadings(self, numberOfReadings)


    def getNumberOfReadings(self):
        """getNumberOfReadings(ArInterpolation self) -> size_t"""
        return _AriaPy.ArInterpolation_getNumberOfReadings(self)


    def reset(self):
        """reset(ArInterpolation self)"""
        return _AriaPy.ArInterpolation_reset(self)

ArInterpolation_swigregister = _AriaPy.ArInterpolation_swigregister
ArInterpolation_swigregister(ArInterpolation)

class ArIrrfDevice(ArRangeDevice):
    """Proxy of C++ ArIrrfDevice 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__(ArIrrfDevice self, size_t currentBufferSize=91, size_t cumulativeBufferSize=273, char const * name) -> ArIrrfDevice
        __init__(ArIrrfDevice self, size_t currentBufferSize=91, size_t cumulativeBufferSize=273) -> ArIrrfDevice
        __init__(ArIrrfDevice self, size_t currentBufferSize=91) -> ArIrrfDevice
        __init__(ArIrrfDevice self) -> ArIrrfDevice
        """
        this = _AriaPy.new_ArIrrfDevice(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArIrrfDevice
    __del__ = lambda self: None

    def packetHandler(self, packet):
        """packetHandler(ArIrrfDevice self, ArRobotPacket packet) -> bool"""
        return _AriaPy.ArIrrfDevice_packetHandler(self, packet)


    def setCumulativeMaxRange(self, r):
        """setCumulativeMaxRange(ArIrrfDevice self, double r)"""
        return _AriaPy.ArIrrfDevice_setCumulativeMaxRange(self, r)


    def setRobot(self, arg2):
        """setRobot(ArIrrfDevice self, ArRobot arg2)"""
        return _AriaPy.ArIrrfDevice_setRobot(self, arg2)

ArIrrfDevice_swigregister = _AriaPy.ArIrrfDevice_swigregister
ArIrrfDevice_swigregister(ArIrrfDevice)

class ArJoyHandler(object):
    """Proxy of C++ ArJoyHandler 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, useOSCal=True, useOldJoystick=False):
        """
        __init__(ArJoyHandler self, bool useOSCal=True, bool useOldJoystick=False) -> ArJoyHandler
        __init__(ArJoyHandler self, bool useOSCal=True) -> ArJoyHandler
        __init__(ArJoyHandler self) -> ArJoyHandler
        """
        this = _AriaPy.new_ArJoyHandler(useOSCal, useOldJoystick)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArJoyHandler
    __del__ = lambda self: None

    def init(self):
        """init(ArJoyHandler self) -> bool"""
        return _AriaPy.ArJoyHandler_init(self)


    def haveJoystick(self):
        """haveJoystick(ArJoyHandler self) -> bool"""
        return _AriaPy.ArJoyHandler_haveJoystick(self)


    def getDoubles(self):
        """
        getDoubles(ArJoyHandler self)
        getDoubles(ArJoyHandler self)
        """
        return _AriaPy.ArJoyHandler_getDoubles(self)


    def getButton(self, button):
        """getButton(ArJoyHandler self, unsigned int button) -> bool"""
        return _AriaPy.ArJoyHandler_getButton(self, button)


    def haveZAxis(self):
        """haveZAxis(ArJoyHandler self) -> bool"""
        return _AriaPy.ArJoyHandler_haveZAxis(self)


    def setSpeeds(self, x, y, z=0):
        """
        setSpeeds(ArJoyHandler self, int x, int y, int z=0)
        setSpeeds(ArJoyHandler self, int x, int y)
        """
        return _AriaPy.ArJoyHandler_setSpeeds(self, x, y, z)


    def getAdjusted(self):
        """
        getAdjusted(ArJoyHandler self)
        getAdjusted(ArJoyHandler self)
        """
        return _AriaPy.ArJoyHandler_getAdjusted(self)


    def getNumAxes(self):
        """getNumAxes(ArJoyHandler self) -> unsigned int"""
        return _AriaPy.ArJoyHandler_getNumAxes(self)


    def getAxis(self, axis):
        """getAxis(ArJoyHandler self, unsigned int axis) -> double"""
        return _AriaPy.ArJoyHandler_getAxis(self, axis)


    def getNumButtons(self):
        """getNumButtons(ArJoyHandler self) -> unsigned int"""
        return _AriaPy.ArJoyHandler_getNumButtons(self)


    def setUseOSCal(self, useOSCal):
        """setUseOSCal(ArJoyHandler self, bool useOSCal)"""
        return _AriaPy.ArJoyHandler_setUseOSCal(self, useOSCal)


    def getUseOSCal(self):
        """getUseOSCal(ArJoyHandler self) -> bool"""
        return _AriaPy.ArJoyHandler_getUseOSCal(self)


    def startCal(self):
        """startCal(ArJoyHandler self)"""
        return _AriaPy.ArJoyHandler_startCal(self)


    def endCal(self):
        """endCal(ArJoyHandler self)"""
        return _AriaPy.ArJoyHandler_endCal(self)


    def getUnfiltered(self):
        """
        getUnfiltered(ArJoyHandler self)
        getUnfiltered(ArJoyHandler self)
        """
        return _AriaPy.ArJoyHandler_getUnfiltered(self)


    def getStats(self, maxX, minX, maxY, minY, cenX, cenY):
        """getStats(ArJoyHandler self, int * maxX, int * minX, int * maxY, int * minY, int * cenX, int * cenY)"""
        return _AriaPy.ArJoyHandler_getStats(self, maxX, minX, maxY, minY, cenX, cenY)


    def setStats(self, maxX, minX, maxY, minY, cenX, cenY):
        """setStats(ArJoyHandler self, int maxX, int minX, int maxY, int minY, int cenX, int cenY)"""
        return _AriaPy.ArJoyHandler_setStats(self, maxX, minX, maxY, minY, cenX, cenY)


    def getSpeeds(self):
        """getSpeeds(ArJoyHandler self)"""
        return _AriaPy.ArJoyHandler_getSpeeds(self)

ArJoyHandler_swigregister = _AriaPy.ArJoyHandler_swigregister
ArJoyHandler_swigregister(ArJoyHandler)

class ArKeyHandler(object):
    """Proxy of C++ ArKeyHandler 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, blocking=False, addAriaExitCB=True, stream=None, takeKeysInConstructor=True):
        """
        __init__(ArKeyHandler self, bool blocking=False, bool addAriaExitCB=True, FILE * stream=None, bool takeKeysInConstructor=True) -> ArKeyHandler
        __init__(ArKeyHandler self, bool blocking=False, bool addAriaExitCB=True, FILE * stream=None) -> ArKeyHandler
        __init__(ArKeyHandler self, bool blocking=False, bool addAriaExitCB=True) -> ArKeyHandler
        __init__(ArKeyHandler self, bool blocking=False) -> ArKeyHandler
        __init__(ArKeyHandler self) -> ArKeyHandler
        """
        this = _AriaPy.new_ArKeyHandler(blocking, addAriaExitCB, stream, takeKeysInConstructor)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArKeyHandler
    __del__ = lambda self: None
    UP = _AriaPy.ArKeyHandler_UP
    DOWN = _AriaPy.ArKeyHandler_DOWN
    LEFT = _AriaPy.ArKeyHandler_LEFT
    RIGHT = _AriaPy.ArKeyHandler_RIGHT
    ESCAPE = _AriaPy.ArKeyHandler_ESCAPE
    SPACE = _AriaPy.ArKeyHandler_SPACE
    TAB = _AriaPy.ArKeyHandler_TAB
    ENTER = _AriaPy.ArKeyHandler_ENTER
    BACKSPACE = _AriaPy.ArKeyHandler_BACKSPACE
    _StartFKeys = _AriaPy.ArKeyHandler__StartFKeys
    F1 = _AriaPy.ArKeyHandler_F1
    F2 = _AriaPy.ArKeyHandler_F2
    F3 = _AriaPy.ArKeyHandler_F3
    F4 = _AriaPy.ArKeyHandler_F4
    F5 = _AriaPy.ArKeyHandler_F5
    F6 = _AriaPy.ArKeyHandler_F6
    F7 = _AriaPy.ArKeyHandler_F7
    F8 = _AriaPy.ArKeyHandler_F8
    F9 = _AriaPy.ArKeyHandler_F9
    F10 = _AriaPy.ArKeyHandler_F10
    F11 = _AriaPy.ArKeyHandler_F11
    F12 = _AriaPy.ArKeyHandler_F12
    _EndFKeys = _AriaPy.ArKeyHandler__EndFKeys
    PAGEUP = _AriaPy.ArKeyHandler_PAGEUP
    PAGEDOWN = _AriaPy.ArKeyHandler_PAGEDOWN
    HOME = _AriaPy.ArKeyHandler_HOME
    END = _AriaPy.ArKeyHandler_END
    INSERT = _AriaPy.ArKeyHandler_INSERT
    DEL = _AriaPy.ArKeyHandler_DEL

    def addKeyHandler(self, keyToHandle, functor):
        """addKeyHandler(ArKeyHandler self, int keyToHandle, ArFunctor functor) -> bool"""
        return _AriaPy.ArKeyHandler_addKeyHandler(self, keyToHandle, functor)


    def remKeyHandler(self, *args):
        """
        remKeyHandler(ArKeyHandler self, int keyToHandler) -> bool
        remKeyHandler(ArKeyHandler self, ArFunctor functor) -> bool
        """
        return _AriaPy.ArKeyHandler_remKeyHandler(self, *args)


    def takeKeys(self, blocking=False):
        """
        takeKeys(ArKeyHandler self, bool blocking=False)
        takeKeys(ArKeyHandler self)
        """
        return _AriaPy.ArKeyHandler_takeKeys(self, blocking)


    def restore(self):
        """restore(ArKeyHandler self)"""
        return _AriaPy.ArKeyHandler_restore(self)


    def checkKeys(self):
        """checkKeys(ArKeyHandler self)"""
        return _AriaPy.ArKeyHandler_checkKeys(self)


    def getKey(self):
        """getKey(ArKeyHandler self) -> int"""
        return _AriaPy.ArKeyHandler_getKey(self)

ArKeyHandler_swigregister = _AriaPy.ArKeyHandler_swigregister
ArKeyHandler_swigregister(ArKeyHandler)

class ArLaserConnector(object):
    """Proxy of C++ ArLaserConnector 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__(ArLaserConnector self, ArArgumentParser parser, ArRobot robot, ArRobotConnector robotConnector, bool autoParseArgs=True, ArLog::LogLevel infoLogLevel, ArRetFunctor1< bool,char const * > * turnOnPowerOutputCB=None, ArRetFunctor1< bool,char const * > * turnOffPowerOutputCB=None) -> ArLaserConnector
        __init__(ArLaserConnector self, ArArgumentParser parser, ArRobot robot, ArRobotConnector robotConnector, bool autoParseArgs=True, ArLog::LogLevel infoLogLevel, ArRetFunctor1< bool,char const * > * turnOnPowerOutputCB=None) -> ArLaserConnector
        __init__(ArLaserConnector self, ArArgumentParser parser, ArRobot robot, ArRobotConnector robotConnector, bool autoParseArgs=True, ArLog::LogLevel infoLogLevel) -> ArLaserConnector
        __init__(ArLaserConnector self, ArArgumentParser parser, ArRobot robot, ArRobotConnector robotConnector, bool autoParseArgs=True) -> ArLaserConnector
        __init__(ArLaserConnector self, ArArgumentParser parser, ArRobot robot, ArRobotConnector robotConnector) -> ArLaserConnector
        """
        this = _AriaPy.new_ArLaserConnector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLaserConnector
    __del__ = lambda self: None

    def connectLasers(self, continueOnFailedConnect=False, addConnectedLasersToRobot=True, addAllLasersToRobot=False, turnOnLasers=True, powerCycleLaserOnFailedConnect=True, failedOnLaser=None):
        """
        connectLasers(ArLaserConnector self, bool continueOnFailedConnect=False, bool addConnectedLasersToRobot=True, bool addAllLasersToRobot=False, bool turnOnLasers=True, bool powerCycleLaserOnFailedConnect=True, int * failedOnLaser=None) -> bool
        connectLasers(ArLaserConnector self, bool continueOnFailedConnect=False, bool addConnectedLasersToRobot=True, bool addAllLasersToRobot=False, bool turnOnLasers=True, bool powerCycleLaserOnFailedConnect=True) -> bool
        connectLasers(ArLaserConnector self, bool continueOnFailedConnect=False, bool addConnectedLasersToRobot=True, bool addAllLasersToRobot=False, bool turnOnLasers=True) -> bool
        connectLasers(ArLaserConnector self, bool continueOnFailedConnect=False, bool addConnectedLasersToRobot=True, bool addAllLasersToRobot=False) -> bool
        connectLasers(ArLaserConnector self, bool continueOnFailedConnect=False, bool addConnectedLasersToRobot=True) -> bool
        connectLasers(ArLaserConnector self, bool continueOnFailedConnect=False) -> bool
        connectLasers(ArLaserConnector self) -> bool
        """
        return _AriaPy.ArLaserConnector_connectLasers(self, continueOnFailedConnect, addConnectedLasersToRobot, addAllLasersToRobot, turnOnLasers, powerCycleLaserOnFailedConnect, failedOnLaser)


    def setupLaser(self, laser, laserNumber=1):
        """
        setupLaser(ArLaserConnector self, ArLaser laser, int laserNumber=1) -> bool
        setupLaser(ArLaserConnector self, ArLaser laser) -> bool
        """
        return _AriaPy.ArLaserConnector_setupLaser(self, laser, laserNumber)


    def connectLaser(self, laser, laserNumber=1, forceConnection=True):
        """
        connectLaser(ArLaserConnector self, ArLaser laser, int laserNumber=1, bool forceConnection=True) -> bool
        connectLaser(ArLaserConnector self, ArLaser laser, int laserNumber=1) -> bool
        connectLaser(ArLaserConnector self, ArLaser laser) -> bool
        """
        return _AriaPy.ArLaserConnector_connectLaser(self, laser, laserNumber, forceConnection)


    def addLaser(self, laser, laserNumber=1):
        """
        addLaser(ArLaserConnector self, ArLaser laser, int laserNumber=1) -> bool
        addLaser(ArLaserConnector self, ArLaser laser) -> bool
        """
        return _AriaPy.ArLaserConnector_addLaser(self, laser, laserNumber)


    def addPlaceholderLaser(self, placeholderLaser, laserNumber=1, takeOwnershipOfPlaceholder=False):
        """
        addPlaceholderLaser(ArLaserConnector self, ArLaser placeholderLaser, int laserNumber=1, bool takeOwnershipOfPlaceholder=False) -> bool
        addPlaceholderLaser(ArLaserConnector self, ArLaser placeholderLaser, int laserNumber=1) -> bool
        addPlaceholderLaser(ArLaserConnector self, ArLaser placeholderLaser) -> bool
        """
        return _AriaPy.ArLaserConnector_addPlaceholderLaser(self, placeholderLaser, laserNumber, takeOwnershipOfPlaceholder)


    def parseArgs(self, *args):
        """
        parseArgs(ArLaserConnector self) -> bool
        parseArgs(ArLaserConnector self, ArArgumentParser parser) -> bool
        """
        return _AriaPy.ArLaserConnector_parseArgs(self, *args)


    def logOptions(self):
        """logOptions(ArLaserConnector self)"""
        return _AriaPy.ArLaserConnector_logOptions(self)


    def getLaser(self, laserNumber):
        """getLaser(ArLaserConnector self, int laserNumber) -> ArLaser"""
        return _AriaPy.ArLaserConnector_getLaser(self, laserNumber)


    def replaceLaser(self, laser, laserNumber):
        """replaceLaser(ArLaserConnector self, ArLaser laser, int laserNumber) -> bool"""
        return _AriaPy.ArLaserConnector_replaceLaser(self, laser, laserNumber)

ArLaserConnector_swigregister = _AriaPy.ArLaserConnector_swigregister
ArLaserConnector_swigregister(ArLaserConnector)

class ArLaserFilter(ArLaser):
    """Proxy of C++ ArLaserFilter 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, laser, name=None):
        """
        __init__(ArLaserFilter self, ArLaser laser, char const * name=None) -> ArLaserFilter
        __init__(ArLaserFilter self, ArLaser laser) -> ArLaserFilter
        """
        this = _AriaPy.new_ArLaserFilter(laser, name)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLaserFilter
    __del__ = lambda self: None

    def setRobot(self, robot):
        """setRobot(ArLaserFilter self, ArRobot robot)"""
        return _AriaPy.ArLaserFilter_setRobot(self, robot)


    def addToConfig(self, *args):
        """
        addToConfig(ArLaserFilter self, ArConfig config, char const * sectionName, char const * prefix)
        addToConfig(ArLaserFilter self, ArConfig config, char const * sectionName)
        """
        return _AriaPy.ArLaserFilter_addToConfig(self, *args)


    def blockingConnect(self):
        """blockingConnect(ArLaserFilter self) -> bool"""
        return _AriaPy.ArLaserFilter_blockingConnect(self)


    def asyncConnect(self):
        """asyncConnect(ArLaserFilter self) -> bool"""
        return _AriaPy.ArLaserFilter_asyncConnect(self)


    def disconnect(self):
        """disconnect(ArLaserFilter self) -> bool"""
        return _AriaPy.ArLaserFilter_disconnect(self)


    def isConnected(self):
        """isConnected(ArLaserFilter self) -> bool"""
        return _AriaPy.ArLaserFilter_isConnected(self)


    def isTryingToConnect(self):
        """isTryingToConnect(ArLaserFilter self) -> bool"""
        return _AriaPy.ArLaserFilter_isTryingToConnect(self)


    def runThread(self, arg):
        """runThread(ArLaserFilter self, void * arg) -> void *"""
        return _AriaPy.ArLaserFilter_runThread(self, arg)


    def laserCheckParams(self):
        """laserCheckParams(ArLaserFilter self) -> bool"""
        return _AriaPy.ArLaserFilter_laserCheckParams(self)


    def getBaseLaser(self):
        """getBaseLaser(ArLaserFilter self) -> ArLaser"""
        return _AriaPy.ArLaserFilter_getBaseLaser(self)

ArLaserFilter_swigregister = _AriaPy.ArLaserFilter_swigregister
ArLaserFilter_swigregister(ArLaserFilter)

class ArLaserLogger(object):
    """Proxy of C++ ArLaserLogger 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, robot, laser, distDiff, degDiff, fileName, addGoals=False, joyHandler=None, baseDirectory=None, useReflectorValues=False, robotJoyHandler=None, extraLocationData=None, extraLasers=None):
        """
        __init__(ArLaserLogger self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, char const * fileName, bool addGoals=False, ArJoyHandler joyHandler=None, char const * baseDirectory=None, bool useReflectorValues=False, ArRobotJoyHandler robotJoyHandler=None, std::map< std::string,ArRetFunctor3< int,ArTime,ArPose *,ArPoseWithTime * > *,ArStrCaseCmpOp,std::allocator< std::pair< std::string const,ArRetFunctor3< int,ArTime,ArPose *,ArPoseWithTime * > * > > > const * extraLocationData=None, std::list< ArLaser *,std::allocator< ArLaser * > > * extraLasers=None) -> ArLaserLogger
        __init__(ArLaserLogger self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, char const * fileName, bool addGoals=False, ArJoyHandler joyHandler=None, char const * baseDirectory=None, bool useReflectorValues=False, ArRobotJoyHandler robotJoyHandler=None, std::map< std::string,ArRetFunctor3< int,ArTime,ArPose *,ArPoseWithTime * > *,ArStrCaseCmpOp,std::allocator< std::pair< std::string const,ArRetFunctor3< int,ArTime,ArPose *,ArPoseWithTime * > * > > > const * extraLocationData=None) -> ArLaserLogger
        __init__(ArLaserLogger self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, char const * fileName, bool addGoals=False, ArJoyHandler joyHandler=None, char const * baseDirectory=None, bool useReflectorValues=False, ArRobotJoyHandler robotJoyHandler=None) -> ArLaserLogger
        __init__(ArLaserLogger self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, char const * fileName, bool addGoals=False, ArJoyHandler joyHandler=None, char const * baseDirectory=None, bool useReflectorValues=False) -> ArLaserLogger
        __init__(ArLaserLogger self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, char const * fileName, bool addGoals=False, ArJoyHandler joyHandler=None, char const * baseDirectory=None) -> ArLaserLogger
        __init__(ArLaserLogger self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, char const * fileName, bool addGoals=False, ArJoyHandler joyHandler=None) -> ArLaserLogger
        __init__(ArLaserLogger self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, char const * fileName, bool addGoals=False) -> ArLaserLogger
        __init__(ArLaserLogger self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, char const * fileName) -> ArLaserLogger
        """
        this = _AriaPy.new_ArLaserLogger(robot, laser, distDiff, degDiff, fileName, addGoals, joyHandler, baseDirectory, useReflectorValues, robotJoyHandler, extraLocationData, extraLasers)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLaserLogger
    __del__ = lambda self: None

    def addTagToLogPlain(self, str):
        """addTagToLogPlain(ArLaserLogger self, char const * str)"""
        return _AriaPy.ArLaserLogger_addTagToLogPlain(self, str)


    def addInfoToLogPlain(self, str):
        """addInfoToLogPlain(ArLaserLogger self, char const * str)"""
        return _AriaPy.ArLaserLogger_addInfoToLogPlain(self, str)


    def setDistDiff(self, distDiff):
        """setDistDiff(ArLaserLogger self, double distDiff)"""
        return _AriaPy.ArLaserLogger_setDistDiff(self, distDiff)


    def getDistDiff(self):
        """getDistDiff(ArLaserLogger self) -> double"""
        return _AriaPy.ArLaserLogger_getDistDiff(self)


    def setDegDiff(self, degDiff):
        """setDegDiff(ArLaserLogger self, double degDiff)"""
        return _AriaPy.ArLaserLogger_setDegDiff(self, degDiff)


    def getDegDiff(self):
        """getDegDiff(ArLaserLogger self) -> double"""
        return _AriaPy.ArLaserLogger_getDegDiff(self)


    def takeReading(self):
        """takeReading(ArLaserLogger self)"""
        return _AriaPy.ArLaserLogger_takeReading(self)


    def addGoal(self):
        """addGoal(ArLaserLogger self)"""
        return _AriaPy.ArLaserLogger_addGoal(self)


    def wasFileOpenedSuccessfully(self):
        """wasFileOpenedSuccessfully(ArLaserLogger self) -> bool"""
        return _AriaPy.ArLaserLogger_wasFileOpenedSuccessfully(self)


    def takingOldReadings(self):
        """takingOldReadings(ArLaserLogger self) -> bool"""
        return _AriaPy.ArLaserLogger_takingOldReadings(self)


    def takeOldReadings(self, takeOld):
        """takeOldReadings(ArLaserLogger self, bool takeOld)"""
        return _AriaPy.ArLaserLogger_takeOldReadings(self, takeOld)


    def takingNewReadings(self):
        """takingNewReadings(ArLaserLogger self) -> bool"""
        return _AriaPy.ArLaserLogger_takingNewReadings(self)


    def takeNewReadings(self, takeNew):
        """takeNewReadings(ArLaserLogger self, bool takeNew)"""
        return _AriaPy.ArLaserLogger_takeNewReadings(self, takeNew)

ArLaserLogger_swigregister = _AriaPy.ArLaserLogger_swigregister
ArLaserLogger_swigregister(ArLaserLogger)

class ArLaserReflectorDevice(ArRangeDevice):
    """Proxy of C++ ArLaserReflectorDevice 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__(ArLaserReflectorDevice self, ArRangeDevice laser, ArRobot robot, char const * name) -> ArLaserReflectorDevice
        __init__(ArLaserReflectorDevice self, ArRangeDevice laser, ArRobot robot) -> ArLaserReflectorDevice
        """
        this = _AriaPy.new_ArLaserReflectorDevice(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLaserReflectorDevice
    __del__ = lambda self: None

    def processReadings(self):
        """processReadings(ArLaserReflectorDevice self)"""
        return _AriaPy.ArLaserReflectorDevice_processReadings(self)


    def setRobot(self, robot):
        """setRobot(ArLaserReflectorDevice self, ArRobot robot)"""
        return _AriaPy.ArLaserReflectorDevice_setRobot(self, robot)


    def addToConfig(self, config, section):
        """addToConfig(ArLaserReflectorDevice self, ArConfig config, char const * section)"""
        return _AriaPy.ArLaserReflectorDevice_addToConfig(self, config, section)

ArLaserReflectorDevice_swigregister = _AriaPy.ArLaserReflectorDevice_swigregister
ArLaserReflectorDevice_swigregister(ArLaserReflectorDevice)

class ArLineFinder(object):
    """Proxy of C++ ArLineFinder 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, dev):
        """__init__(ArLineFinder self, ArRangeDevice dev) -> ArLineFinder"""
        this = _AriaPy.new_ArLineFinder(dev)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLineFinder
    __del__ = lambda self: None

    def getLinesAsSet(self):
        """getLinesAsSet(ArLineFinder self) -> std::set< ArLineFinderSegment *,std::less< ArLineFinderSegment * >,std::allocator< ArLineFinderSegment * > >"""
        return _AriaPy.ArLineFinder_getLinesAsSet(self)


    def getNonLinePointsAsSet(self):
        """getNonLinePointsAsSet(ArLineFinder self) -> std::set< ArPose,std::less< ArPose >,std::allocator< ArPose > >"""
        return _AriaPy.ArLineFinder_getNonLinePointsAsSet(self)


    def getLinesTakenPose(self):
        """getLinesTakenPose(ArLineFinder self) -> ArPose"""
        return _AriaPy.ArLineFinder_getLinesTakenPose(self)


    def saveLast(self):
        """saveLast(ArLineFinder self)"""
        return _AriaPy.ArLineFinder_saveLast(self)


    def getLinesAndSaveThem(self):
        """getLinesAndSaveThem(ArLineFinder self)"""
        return _AriaPy.ArLineFinder_getLinesAndSaveThem(self)


    def setVerbose(self, verbose):
        """setVerbose(ArLineFinder self, bool verbose)"""
        return _AriaPy.ArLineFinder_setVerbose(self, verbose)


    def getVerbose(self):
        """getVerbose(ArLineFinder self) -> bool"""
        return _AriaPy.ArLineFinder_getVerbose(self)


    def setLineCreationParams(self, minLineLen=40, minLinePoints=2):
        """
        setLineCreationParams(ArLineFinder self, int minLineLen=40, int minLinePoints=2)
        setLineCreationParams(ArLineFinder self, int minLineLen=40)
        setLineCreationParams(ArLineFinder self)
        """
        return _AriaPy.ArLineFinder_setLineCreationParams(self, minLineLen, minLinePoints)


    def setLineCombiningParams(self, angleTol=30, linesCloseEnough=75):
        """
        setLineCombiningParams(ArLineFinder self, int angleTol=30, int linesCloseEnough=75)
        setLineCombiningParams(ArLineFinder self, int angleTol=30)
        setLineCombiningParams(ArLineFinder self)
        """
        return _AriaPy.ArLineFinder_setLineCombiningParams(self, angleTol, linesCloseEnough)


    def setLineFilteringParams(self, minPointsInLine=3, minLineLength=75):
        """
        setLineFilteringParams(ArLineFinder self, int minPointsInLine=3, int minLineLength=75)
        setLineFilteringParams(ArLineFinder self, int minPointsInLine=3)
        setLineFilteringParams(ArLineFinder self)
        """
        return _AriaPy.ArLineFinder_setLineFilteringParams(self, minPointsInLine, minLineLength)


    def setLineValidParams(self, maxDistFromLine=30, maxAveDistFromLine=20):
        """
        setLineValidParams(ArLineFinder self, int maxDistFromLine=30, int maxAveDistFromLine=20)
        setLineValidParams(ArLineFinder self, int maxDistFromLine=30)
        setLineValidParams(ArLineFinder self)
        """
        return _AriaPy.ArLineFinder_setLineValidParams(self, maxDistFromLine, maxAveDistFromLine)


    def setMaxDistBetweenPoints(self, maxDistBetweenPoints=0):
        """
        setMaxDistBetweenPoints(ArLineFinder self, int maxDistBetweenPoints=0)
        setMaxDistBetweenPoints(ArLineFinder self)
        """
        return _AriaPy.ArLineFinder_setMaxDistBetweenPoints(self, maxDistBetweenPoints)


    def addToConfig(self, config, section):
        """addToConfig(ArLineFinder self, ArConfig config, char const * section)"""
        return _AriaPy.ArLineFinder_addToConfig(self, config, section)

ArLineFinder_swigregister = _AriaPy.ArLineFinder_swigregister
ArLineFinder_swigregister(ArLineFinder)

class ArLineFinderSegment(ArLineSegment):
    """Proxy of C++ ArLineFinderSegment 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__(ArLineFinderSegment self) -> ArLineFinderSegment
        __init__(ArLineFinderSegment self, double x1, double y1, double x2, double y2, int numPoints=0, int startPoint=0, int endPoint=0) -> ArLineFinderSegment
        __init__(ArLineFinderSegment self, double x1, double y1, double x2, double y2, int numPoints=0, int startPoint=0) -> ArLineFinderSegment
        __init__(ArLineFinderSegment self, double x1, double y1, double x2, double y2, int numPoints=0) -> ArLineFinderSegment
        __init__(ArLineFinderSegment self, double x1, double y1, double x2, double y2) -> ArLineFinderSegment
        """
        this = _AriaPy.new_ArLineFinderSegment(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLineFinderSegment
    __del__ = lambda self: None

    def newEndPoints(self, x1, y1, x2, y2, numPoints=0, startPoint=0, endPoint=0):
        """
        newEndPoints(ArLineFinderSegment self, double x1, double y1, double x2, double y2, int numPoints=0, int startPoint=0, int endPoint=0)
        newEndPoints(ArLineFinderSegment self, double x1, double y1, double x2, double y2, int numPoints=0, int startPoint=0)
        newEndPoints(ArLineFinderSegment self, double x1, double y1, double x2, double y2, int numPoints=0)
        newEndPoints(ArLineFinderSegment self, double x1, double y1, double x2, double y2)
        """
        return _AriaPy.ArLineFinderSegment_newEndPoints(self, x1, y1, x2, y2, numPoints, startPoint, endPoint)


    def getLineAngle(self):
        """getLineAngle(ArLineFinderSegment self) -> double"""
        return _AriaPy.ArLineFinderSegment_getLineAngle(self)


    def getLength(self):
        """getLength(ArLineFinderSegment self) -> double"""
        return _AriaPy.ArLineFinderSegment_getLength(self)


    def getNumPoints(self):
        """getNumPoints(ArLineFinderSegment self) -> int"""
        return _AriaPy.ArLineFinderSegment_getNumPoints(self)


    def getStartPoint(self):
        """getStartPoint(ArLineFinderSegment self) -> int"""
        return _AriaPy.ArLineFinderSegment_getStartPoint(self)


    def getEndPoint(self):
        """getEndPoint(ArLineFinderSegment self) -> int"""
        return _AriaPy.ArLineFinderSegment_getEndPoint(self)


    def setAveDistFromLine(self, aveDistFromLine):
        """setAveDistFromLine(ArLineFinderSegment self, double aveDistFromLine)"""
        return _AriaPy.ArLineFinderSegment_setAveDistFromLine(self, aveDistFromLine)


    def getAveDistFromLine(self):
        """getAveDistFromLine(ArLineFinderSegment self) -> double"""
        return _AriaPy.ArLineFinderSegment_getAveDistFromLine(self)

ArLineFinderSegment_swigregister = _AriaPy.ArLineFinderSegment_swigregister
ArLineFinderSegment_swigregister(ArLineFinderSegment)

class ArLog(object):
    """Proxy of C++ ArLog class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    StdOut = _AriaPy.ArLog_StdOut
    StdErr = _AriaPy.ArLog_StdErr
    File = _AriaPy.ArLog_File
    Colbert = _AriaPy.ArLog_Colbert
    NoLog = _AriaPy.ArLog_NoLog
    Terse = _AriaPy.ArLog_Terse
    Normal = _AriaPy.ArLog_Normal
    Verbose = _AriaPy.ArLog_Verbose

    def log(level, str):
        """log(ArLog::LogLevel level, char const * str)"""
        return _AriaPy.ArLog_log(level, str)

    log = staticmethod(log)

    def init(*args):
        """
        init(ArLog::LogType type, ArLog::LogLevel level, char const * fileName, bool logTime=False, bool alsoPrint=False, bool printThisCall=True) -> bool
        init(ArLog::LogType type, ArLog::LogLevel level, char const * fileName, bool logTime=False, bool alsoPrint=False) -> bool
        init(ArLog::LogType type, ArLog::LogLevel level, char const * fileName, bool logTime=False) -> bool
        init(ArLog::LogType type, ArLog::LogLevel level, char const * fileName) -> bool
        init(ArLog::LogType type, ArLog::LogLevel level) -> bool
        """
        return _AriaPy.ArLog_init(*args)

    init = staticmethod(init)

    def close():
        """close()"""
        return _AriaPy.ArLog_close()

    close = staticmethod(close)

    def logErrorFromOS(level, str):
        """logErrorFromOS(ArLog::LogLevel level, char const * str)"""
        return _AriaPy.ArLog_logErrorFromOS(level, str)

    logErrorFromOS = staticmethod(logErrorFromOS)

    def logErrorFromOSPlain(level, str):
        """logErrorFromOSPlain(ArLog::LogLevel level, char const * str)"""
        return _AriaPy.ArLog_logErrorFromOSPlain(level, str)

    logErrorFromOSPlain = staticmethod(logErrorFromOSPlain)

    def logBacktrace(level):
        """logBacktrace(ArLog::LogLevel level)"""
        return _AriaPy.ArLog_logBacktrace(level)

    logBacktrace = staticmethod(logBacktrace)
    colbertPrint = _swig_property(_AriaPy.ArLog_colbertPrint_get, _AriaPy.ArLog_colbertPrint_set)

    def addToConfig(config):
        """addToConfig(ArConfig config)"""
        return _AriaPy.ArLog_addToConfig(config)

    addToConfig = staticmethod(addToConfig)

    def aramInit(*args):
        """
        aramInit(char const * prefix, ArLog::LogLevel defaultLevel, double defaultSize=10, bool daemonized=False)
        aramInit(char const * prefix, ArLog::LogLevel defaultLevel, double defaultSize=10)
        aramInit(char const * prefix, ArLog::LogLevel defaultLevel)
        aramInit(char const * prefix)
        """
        return _AriaPy.ArLog_aramInit(*args)

    aramInit = staticmethod(aramInit)

    def setFunctor(functor):
        """setFunctor(ArFunctor1_CString functor)"""
        return _AriaPy.ArLog_setFunctor(functor)

    setFunctor = staticmethod(setFunctor)

    def internalForceLockup():
        """internalForceLockup()"""
        return _AriaPy.ArLog_internalForceLockup()

    internalForceLockup = staticmethod(internalForceLockup)

    def __init__(self):
        """__init__(ArLog self) -> ArLog"""
        this = _AriaPy.new_ArLog()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLog
    __del__ = lambda self: None
ArLog_swigregister = _AriaPy.ArLog_swigregister
ArLog_swigregister(ArLog)

def ArLog_log(level, str):
    """ArLog_log(ArLog::LogLevel level, char const * str)"""
    return _AriaPy.ArLog_log(level, str)

def ArLog_init(*args):
    """
    init(ArLog::LogType type, ArLog::LogLevel level, char const * fileName, bool logTime=False, bool alsoPrint=False, bool printThisCall=True) -> bool
    init(ArLog::LogType type, ArLog::LogLevel level, char const * fileName, bool logTime=False, bool alsoPrint=False) -> bool
    init(ArLog::LogType type, ArLog::LogLevel level, char const * fileName, bool logTime=False) -> bool
    init(ArLog::LogType type, ArLog::LogLevel level, char const * fileName) -> bool
    ArLog_init(ArLog::LogType type, ArLog::LogLevel level) -> bool
    """
    return _AriaPy.ArLog_init(*args)

def ArLog_close():
    """ArLog_close()"""
    return _AriaPy.ArLog_close()

def ArLog_logErrorFromOS(level, str):
    """ArLog_logErrorFromOS(ArLog::LogLevel level, char const * str)"""
    return _AriaPy.ArLog_logErrorFromOS(level, str)

def ArLog_logErrorFromOSPlain(level, str):
    """ArLog_logErrorFromOSPlain(ArLog::LogLevel level, char const * str)"""
    return _AriaPy.ArLog_logErrorFromOSPlain(level, str)

def ArLog_logBacktrace(level):
    """ArLog_logBacktrace(ArLog::LogLevel level)"""
    return _AriaPy.ArLog_logBacktrace(level)

def ArLog_addToConfig(config):
    """ArLog_addToConfig(ArConfig config)"""
    return _AriaPy.ArLog_addToConfig(config)

def ArLog_aramInit(*args):
    """
    aramInit(char const * prefix, ArLog::LogLevel defaultLevel, double defaultSize=10, bool daemonized=False)
    aramInit(char const * prefix, ArLog::LogLevel defaultLevel, double defaultSize=10)
    aramInit(char const * prefix, ArLog::LogLevel defaultLevel)
    ArLog_aramInit(char const * prefix)
    """
    return _AriaPy.ArLog_aramInit(*args)

def ArLog_setFunctor(functor):
    """ArLog_setFunctor(ArFunctor1_CString functor)"""
    return _AriaPy.ArLog_setFunctor(functor)

def ArLog_internalForceLockup():
    """ArLog_internalForceLockup()"""
    return _AriaPy.ArLog_internalForceLockup()

class ArLogFileConnection(ArDeviceConnection):
    """Proxy of C++ ArLogFileConnection 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):
        """__init__(ArLogFileConnection self) -> ArLogFileConnection"""
        this = _AriaPy.new_ArLogFileConnection()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLogFileConnection
    __del__ = lambda self: None

    def open(self, fname=None):
        """
        open(ArLogFileConnection self, char const * fname=None) -> int
        open(ArLogFileConnection self) -> int
        """
        return _AriaPy.ArLogFileConnection_open(self, fname)


    def setLogFile(self, fname=None):
        """
        setLogFile(ArLogFileConnection self, char const * fname=None)
        setLogFile(ArLogFileConnection self)
        """
        return _AriaPy.ArLogFileConnection_setLogFile(self, fname)


    def openSimple(self):
        """openSimple(ArLogFileConnection self) -> bool"""
        return _AriaPy.ArLogFileConnection_openSimple(self)


    def getStatus(self):
        """getStatus(ArLogFileConnection self) -> int"""
        return _AriaPy.ArLogFileConnection_getStatus(self)


    def close(self):
        """close(ArLogFileConnection self) -> bool"""
        return _AriaPy.ArLogFileConnection_close(self)


    def read(self, data, size, msWait=0):
        """
        read(ArLogFileConnection self, char const * data, unsigned int size, unsigned int msWait=0) -> int
        read(ArLogFileConnection self, char const * data, unsigned int size) -> int
        """
        return _AriaPy.ArLogFileConnection_read(self, data, size, msWait)


    def write(self, data, size):
        """write(ArLogFileConnection self, char const * data, unsigned int size) -> int"""
        return _AriaPy.ArLogFileConnection_write(self, data, size)


    def getOpenMessage(self, messageNumber):
        """getOpenMessage(ArLogFileConnection self, int messageNumber) -> char const *"""
        return _AriaPy.ArLogFileConnection_getOpenMessage(self, messageNumber)


    def getTimeRead(self, index):
        """getTimeRead(ArLogFileConnection self, int index) -> ArTime"""
        return _AriaPy.ArLogFileConnection_getTimeRead(self, index)


    def isTimeStamping(self):
        """isTimeStamping(ArLogFileConnection self) -> bool"""
        return _AriaPy.ArLogFileConnection_isTimeStamping(self)


    def getLogFile(self):
        """getLogFile(ArLogFileConnection self) -> char const *"""
        return _AriaPy.ArLogFileConnection_getLogFile(self)


    def internalOpen(self):
        """internalOpen(ArLogFileConnection self) -> int"""
        return _AriaPy.ArLogFileConnection_internalOpen(self)

    OPEN_FILE_NOT_FOUND = _AriaPy.ArLogFileConnection_OPEN_FILE_NOT_FOUND
    OPEN_NOT_A_LOG_FILE = _AriaPy.ArLogFileConnection_OPEN_NOT_A_LOG_FILE
    myPose = _swig_property(_AriaPy.ArLogFileConnection_myPose_get, _AriaPy.ArLogFileConnection_myPose_set)
    havePose = _swig_property(_AriaPy.ArLogFileConnection_havePose_get, _AriaPy.ArLogFileConnection_havePose_set)
    myName = _swig_property(_AriaPy.ArLogFileConnection_myName_get, _AriaPy.ArLogFileConnection_myName_set)
    myType = _swig_property(_AriaPy.ArLogFileConnection_myType_get, _AriaPy.ArLogFileConnection_myType_set)
    mySubtype = _swig_property(_AriaPy.ArLogFileConnection_mySubtype_get, _AriaPy.ArLogFileConnection_mySubtype_set)
ArLogFileConnection_swigregister = _AriaPy.ArLogFileConnection_swigregister
ArLogFileConnection_swigregister(ArLogFileConnection)

class ArMD5Calculator(object):
    """Proxy of C++ ArMD5Calculator class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    DIGEST_LENGTH = _AriaPy.ArMD5Calculator_DIGEST_LENGTH
    DISPLAY_LENGTH = _AriaPy.ArMD5Calculator_DISPLAY_LENGTH

    def toDisplay(digestBuf, digestLength, displayBuf, displayLength):
        """toDisplay(unsigned char const * digestBuf, size_t digestLength, char * displayBuf, size_t displayLength)"""
        return _AriaPy.ArMD5Calculator_toDisplay(digestBuf, digestLength, displayBuf, displayLength)

    toDisplay = staticmethod(toDisplay)

    def calculateChecksum(fileName, md5DigestBuffer, md5DigestBufferLen):
        """calculateChecksum(char const * fileName, unsigned char * md5DigestBuffer, size_t md5DigestBufferLen) -> bool"""
        return _AriaPy.ArMD5Calculator_calculateChecksum(fileName, md5DigestBuffer, md5DigestBufferLen)

    calculateChecksum = staticmethod(calculateChecksum)

    def __init__(self, secondFunctor=None):
        """
        __init__(ArMD5Calculator self, ArFunctor1_CString secondFunctor=None) -> ArMD5Calculator
        __init__(ArMD5Calculator self) -> ArMD5Calculator
        """
        this = _AriaPy.new_ArMD5Calculator(secondFunctor)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMD5Calculator
    __del__ = lambda self: None

    def reset(self):
        """reset(ArMD5Calculator self)"""
        return _AriaPy.ArMD5Calculator_reset(self)


    def append(self, str):
        """append(ArMD5Calculator self, char const * str)"""
        return _AriaPy.ArMD5Calculator_append(self, str)


    def getDigest(self):
        """getDigest(ArMD5Calculator self) -> unsigned char *"""
        return _AriaPy.ArMD5Calculator_getDigest(self)


    def getFunctor(self):
        """getFunctor(ArMD5Calculator self) -> ArFunctor1_CString"""
        return _AriaPy.ArMD5Calculator_getFunctor(self)


    def getSecondFunctor(self):
        """getSecondFunctor(ArMD5Calculator self) -> ArFunctor1_CString"""
        return _AriaPy.ArMD5Calculator_getSecondFunctor(self)


    def setSecondFunctor(self, secondFunctor):
        """setSecondFunctor(ArMD5Calculator self, ArFunctor1_CString secondFunctor)"""
        return _AriaPy.ArMD5Calculator_setSecondFunctor(self, secondFunctor)

ArMD5Calculator_swigregister = _AriaPy.ArMD5Calculator_swigregister
ArMD5Calculator_swigregister(ArMD5Calculator)

def ArMD5Calculator_toDisplay(digestBuf, digestLength, displayBuf, displayLength):
    """ArMD5Calculator_toDisplay(unsigned char const * digestBuf, size_t digestLength, char * displayBuf, size_t displayLength)"""
    return _AriaPy.ArMD5Calculator_toDisplay(digestBuf, digestLength, displayBuf, displayLength)

def ArMD5Calculator_calculateChecksum(fileName, md5DigestBuffer, md5DigestBufferLen):
    """ArMD5Calculator_calculateChecksum(char const * fileName, unsigned char * md5DigestBuffer, size_t md5DigestBufferLen) -> bool"""
    return _AriaPy.ArMD5Calculator_calculateChecksum(fileName, md5DigestBuffer, md5DigestBufferLen)

ARMAP_DEFAULT_SCAN_TYPE = _AriaPy.ARMAP_DEFAULT_SCAN_TYPE
class ArMapScanInterface(object):
    """Proxy of C++ ArMapScanInterface 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

    def isDefaultScanType(scanType):
        """isDefaultScanType(char const * scanType) -> bool"""
        return _AriaPy.ArMapScanInterface_isDefaultScanType(scanType)

    isDefaultScanType = staticmethod(isDefaultScanType)

    def isSummaryScanType(scanType):
        """isSummaryScanType(char const * scanType) -> bool"""
        return _AriaPy.ArMapScanInterface_isSummaryScanType(scanType)

    isSummaryScanType = staticmethod(isSummaryScanType)
    __swig_destroy__ = _AriaPy.delete_ArMapScanInterface
    __del__ = lambda self: None

    def getDisplayString(self, *args):
        """
        getDisplayString(ArMapScanInterface self, char const * scanType) -> char const
        getDisplayString(ArMapScanInterface self) -> char const *
        """
        return _AriaPy.ArMapScanInterface_getDisplayString(self, *args)


    def getPoints(self, *args):
        """
        getPoints(ArMapScanInterface self, char const * scanType) -> std::vector< ArPose,std::allocator< ArPose > >
        getPoints(ArMapScanInterface self) -> std::vector< ArPose,std::allocator< ArPose > > *
        """
        return _AriaPy.ArMapScanInterface_getPoints(self, *args)


    def getMinPose(self, *args):
        """
        getMinPose(ArMapScanInterface self, char const * scanType) -> ArPose
        getMinPose(ArMapScanInterface self) -> ArPose
        """
        return _AriaPy.ArMapScanInterface_getMinPose(self, *args)


    def getMaxPose(self, *args):
        """
        getMaxPose(ArMapScanInterface self, char const * scanType) -> ArPose
        getMaxPose(ArMapScanInterface self) -> ArPose
        """
        return _AriaPy.ArMapScanInterface_getMaxPose(self, *args)


    def getNumPoints(self, *args):
        """
        getNumPoints(ArMapScanInterface self, char const * scanType) -> int
        getNumPoints(ArMapScanInterface self) -> int
        """
        return _AriaPy.ArMapScanInterface_getNumPoints(self, *args)


    def isSortedPoints(self, *args):
        """
        isSortedPoints(ArMapScanInterface self, char const * scanType) -> bool
        isSortedPoints(ArMapScanInterface self) -> bool
        """
        return _AriaPy.ArMapScanInterface_isSortedPoints(self, *args)


    def setPoints(self, *args):
        """
        setPoints(ArMapScanInterface self, std::vector< ArPose,std::allocator< ArPose > > const * points, char const * scanType, bool isSortedPoints=False, ArMapChangeDetails * changeDetails=None)
        setPoints(ArMapScanInterface self, std::vector< ArPose,std::allocator< ArPose > > const * points, char const * scanType, bool isSortedPoints=False)
        setPoints(ArMapScanInterface self, std::vector< ArPose,std::allocator< ArPose > > const * points, char const * scanType)
        setPoints(ArMapScanInterface self, std::vector< ArPose,std::allocator< ArPose > > const * points)
        """
        return _AriaPy.ArMapScanInterface_setPoints(self, *args)


    def getLines(self, *args):
        """
        getLines(ArMapScanInterface self, char const * scanType) -> std::vector< ArLineSegment,std::allocator< ArLineSegment > >
        getLines(ArMapScanInterface self) -> std::vector< ArLineSegment,std::allocator< ArLineSegment > > *
        """
        return _AriaPy.ArMapScanInterface_getLines(self, *args)


    def getLineMinPose(self, *args):
        """
        getLineMinPose(ArMapScanInterface self, char const * scanType) -> ArPose
        getLineMinPose(ArMapScanInterface self) -> ArPose
        """
        return _AriaPy.ArMapScanInterface_getLineMinPose(self, *args)


    def getLineMaxPose(self, *args):
        """
        getLineMaxPose(ArMapScanInterface self, char const * scanType) -> ArPose
        getLineMaxPose(ArMapScanInterface self) -> ArPose
        """
        return _AriaPy.ArMapScanInterface_getLineMaxPose(self, *args)


    def getNumLines(self, *args):
        """
        getNumLines(ArMapScanInterface self, char const * scanType) -> int
        getNumLines(ArMapScanInterface self) -> int
        """
        return _AriaPy.ArMapScanInterface_getNumLines(self, *args)


    def isSortedLines(self, *args):
        """
        isSortedLines(ArMapScanInterface self, char const * scanType) -> bool
        isSortedLines(ArMapScanInterface self) -> bool
        """
        return _AriaPy.ArMapScanInterface_isSortedLines(self, *args)


    def setLines(self, *args):
        """
        setLines(ArMapScanInterface self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines, char const * scanType, bool isSortedLines=False, ArMapChangeDetails * changeDetails=None)
        setLines(ArMapScanInterface self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines, char const * scanType, bool isSortedLines=False)
        setLines(ArMapScanInterface self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines, char const * scanType)
        setLines(ArMapScanInterface self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines)
        """
        return _AriaPy.ArMapScanInterface_setLines(self, *args)


    def getResolution(self, *args):
        """
        getResolution(ArMapScanInterface self, char const * scanType) -> int
        getResolution(ArMapScanInterface self) -> int
        """
        return _AriaPy.ArMapScanInterface_getResolution(self, *args)


    def setResolution(self, *args):
        """
        setResolution(ArMapScanInterface self, int resolution, char const * scanType, ArMapChangeDetails * changeDetails=None)
        setResolution(ArMapScanInterface self, int resolution, char const * scanType)
        setResolution(ArMapScanInterface self, int resolution)
        """
        return _AriaPy.ArMapScanInterface_setResolution(self, *args)


    def writeScanToFunctor(self, *args):
        """
        writeScanToFunctor(ArMapScanInterface self, ArFunctor1_CString functor, char const * endOfLineChars, char const * scanType)
        writeScanToFunctor(ArMapScanInterface self, ArFunctor1_CString functor, char const * endOfLineChars)
        """
        return _AriaPy.ArMapScanInterface_writeScanToFunctor(self, *args)


    def writePointsToFunctor(self, *args):
        """
        writePointsToFunctor(ArMapScanInterface self, ArFunctor2< int,std::vector< ArPose,std::allocator< ArPose > > * > * functor, char const * scanType, ArFunctor1_CString keywordFunctor=None)
        writePointsToFunctor(ArMapScanInterface self, ArFunctor2< int,std::vector< ArPose,std::allocator< ArPose > > * > * functor, char const * scanType)
        writePointsToFunctor(ArMapScanInterface self, ArFunctor2< int,std::vector< ArPose,std::allocator< ArPose > > * > * functor)
        """
        return _AriaPy.ArMapScanInterface_writePointsToFunctor(self, *args)


    def writeLinesToFunctor(self, *args):
        """
        writeLinesToFunctor(ArMapScanInterface self, ArFunctor2< int,std::vector< ArLineSegment,std::allocator< ArLineSegment > > * > * functor, char const * scanType, ArFunctor1_CString keywordFunctor=None)
        writeLinesToFunctor(ArMapScanInterface self, ArFunctor2< int,std::vector< ArLineSegment,std::allocator< ArLineSegment > > * > * functor, char const * scanType)
        writeLinesToFunctor(ArMapScanInterface self, ArFunctor2< int,std::vector< ArLineSegment,std::allocator< ArLineSegment > > * > * functor)
        """
        return _AriaPy.ArMapScanInterface_writeLinesToFunctor(self, *args)


    def addToFileParser(self, fileParser):
        """addToFileParser(ArMapScanInterface self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMapScanInterface_addToFileParser(self, fileParser)


    def remFromFileParser(self, fileParser):
        """remFromFileParser(ArMapScanInterface self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMapScanInterface_remFromFileParser(self, fileParser)


    def readDataPoint(self, line):
        """readDataPoint(ArMapScanInterface self, char * line) -> bool"""
        return _AriaPy.ArMapScanInterface_readDataPoint(self, line)


    def readLineSegment(self, line):
        """readLineSegment(ArMapScanInterface self, char * line) -> bool"""
        return _AriaPy.ArMapScanInterface_readLineSegment(self, line)


    def loadDataPoint(self, x, y):
        """loadDataPoint(ArMapScanInterface self, double x, double y)"""
        return _AriaPy.ArMapScanInterface_loadDataPoint(self, x, y)


    def loadLineSegment(self, x1, y1, x2, y2):
        """loadLineSegment(ArMapScanInterface self, double x1, double y1, double x2, double y2)"""
        return _AriaPy.ArMapScanInterface_loadLineSegment(self, x1, y1, x2, y2)

ArMapScanInterface_swigregister = _AriaPy.ArMapScanInterface_swigregister
ArMapScanInterface_swigregister(ArMapScanInterface)

def ArMapScanInterface_isDefaultScanType(scanType):
    """ArMapScanInterface_isDefaultScanType(char const * scanType) -> bool"""
    return _AriaPy.ArMapScanInterface_isDefaultScanType(scanType)

def ArMapScanInterface_isSummaryScanType(scanType):
    """ArMapScanInterface_isSummaryScanType(char const * scanType) -> bool"""
    return _AriaPy.ArMapScanInterface_isSummaryScanType(scanType)

class ArMapObjectsInterface(object):
    """Proxy of C++ ArMapObjectsInterface 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__ = _AriaPy.delete_ArMapObjectsInterface
    __del__ = lambda self: None

    def findFirstMapObject(self, name, type, isIncludeWithHeading=False):
        """
        findFirstMapObject(ArMapObjectsInterface self, char const * name, char const * type, bool isIncludeWithHeading=False) -> ArMapObject
        findFirstMapObject(ArMapObjectsInterface self, char const * name, char const * type) -> ArMapObject
        """
        return _AriaPy.ArMapObjectsInterface_findFirstMapObject(self, name, type, isIncludeWithHeading)


    def findMapObject(self, name, type=None, isIncludeWithHeading=False):
        """
        findMapObject(ArMapObjectsInterface self, char const * name, char const * type=None, bool isIncludeWithHeading=False) -> ArMapObject
        findMapObject(ArMapObjectsInterface self, char const * name, char const * type=None) -> ArMapObject
        findMapObject(ArMapObjectsInterface self, char const * name) -> ArMapObject
        """
        return _AriaPy.ArMapObjectsInterface_findMapObject(self, name, type, isIncludeWithHeading)


    def findMapObjectsOfType(self, type, isIncludeWithHeading=False):
        """
        findMapObjectsOfType(ArMapObjectsInterface self, char const * type, bool isIncludeWithHeading=False) -> ArMapObjectPtrList
        findMapObjectsOfType(ArMapObjectsInterface self, char const * type) -> ArMapObjectPtrList
        """
        return _AriaPy.ArMapObjectsInterface_findMapObjectsOfType(self, type, isIncludeWithHeading)


    def getMapObjects(self):
        """getMapObjects(ArMapObjectsInterface self) -> ArMapObjectPtrList"""
        return _AriaPy.ArMapObjectsInterface_getMapObjects(self)


    def setMapObjects(self, mapObjects, isSortedObjects=False, changeDetails=None):
        """
        setMapObjects(ArMapObjectsInterface self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False, ArMapChangeDetails * changeDetails=None)
        setMapObjects(ArMapObjectsInterface self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False)
        setMapObjects(ArMapObjectsInterface self, ArMapObjectPtrList mapObjects)
        """
        return _AriaPy.ArMapObjectsInterface_setMapObjects(self, mapObjects, isSortedObjects, changeDetails)


    def writeObjectListToFunctor(self, functor, endOfLineChars):
        """writeObjectListToFunctor(ArMapObjectsInterface self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMapObjectsInterface_writeObjectListToFunctor(self, functor, endOfLineChars)

ArMapObjectsInterface_swigregister = _AriaPy.ArMapObjectsInterface_swigregister
ArMapObjectsInterface_swigregister(ArMapObjectsInterface)

class ArMapInfoInterface(object):
    """Proxy of C++ ArMapInfoInterface 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
    MAP_INFO_NAME = _swig_property(_AriaPy.ArMapInfoInterface_MAP_INFO_NAME_get, _AriaPy.ArMapInfoInterface_MAP_INFO_NAME_set)
    META_INFO_NAME = _swig_property(_AriaPy.ArMapInfoInterface_META_INFO_NAME_get, _AriaPy.ArMapInfoInterface_META_INFO_NAME_set)
    TASK_INFO_NAME = _swig_property(_AriaPy.ArMapInfoInterface_TASK_INFO_NAME_get, _AriaPy.ArMapInfoInterface_TASK_INFO_NAME_set)
    ROUTE_INFO_NAME = _swig_property(_AriaPy.ArMapInfoInterface_ROUTE_INFO_NAME_get, _AriaPy.ArMapInfoInterface_ROUTE_INFO_NAME_set)
    SCHED_TASK_INFO_NAME = _swig_property(_AriaPy.ArMapInfoInterface_SCHED_TASK_INFO_NAME_get, _AriaPy.ArMapInfoInterface_SCHED_TASK_INFO_NAME_set)
    SCHED_INFO_NAME = _swig_property(_AriaPy.ArMapInfoInterface_SCHED_INFO_NAME_get, _AriaPy.ArMapInfoInterface_SCHED_INFO_NAME_set)
    CAIRN_INFO_NAME = _swig_property(_AriaPy.ArMapInfoInterface_CAIRN_INFO_NAME_get, _AriaPy.ArMapInfoInterface_CAIRN_INFO_NAME_set)
    CUSTOM_INFO_NAME = _swig_property(_AriaPy.ArMapInfoInterface_CUSTOM_INFO_NAME_get, _AriaPy.ArMapInfoInterface_CUSTOM_INFO_NAME_set)
    __swig_destroy__ = _AriaPy.delete_ArMapInfoInterface
    __del__ = lambda self: None

    def getInfoCount(self):
        """getInfoCount(ArMapInfoInterface self) -> int"""
        return _AriaPy.ArMapInfoInterface_getInfoCount(self)


    def getInfoNames(self):
        """getInfoNames(ArMapInfoInterface self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArMapInfoInterface_getInfoNames(self)


    def getInfo(self, *args):
        """
        getInfo(ArMapInfoInterface self, char const * infoName) -> ArArgumentBuilderPtrList
        getInfo(ArMapInfoInterface self, int infoType) -> ArArgumentBuilderPtrList
        """
        return _AriaPy.ArMapInfoInterface_getInfo(self, *args)


    def getMapInfo(self):
        """getMapInfo(ArMapInfoInterface self) -> ArArgumentBuilderPtrList"""
        return _AriaPy.ArMapInfoInterface_getMapInfo(self)


    def setInfo(self, *args):
        """
        setInfo(ArMapInfoInterface self, char const * infoName, ArArgumentBuilderPtrList infoList, ArMapChangeDetails * changeDetails=None) -> bool
        setInfo(ArMapInfoInterface self, char const * infoName, ArArgumentBuilderPtrList infoList) -> bool
        setInfo(ArMapInfoInterface self, int infoType, ArArgumentBuilderPtrList infoList, ArMapChangeDetails * changeDetails=None) -> bool
        setInfo(ArMapInfoInterface self, int infoType, ArArgumentBuilderPtrList infoList) -> bool
        """
        return _AriaPy.ArMapInfoInterface_setInfo(self, *args)


    def setMapInfo(self, mapInfo, changeDetails=None):
        """
        setMapInfo(ArMapInfoInterface self, ArArgumentBuilderPtrList mapInfo, ArMapChangeDetails * changeDetails=None) -> bool
        setMapInfo(ArMapInfoInterface self, ArArgumentBuilderPtrList mapInfo) -> bool
        """
        return _AriaPy.ArMapInfoInterface_setMapInfo(self, mapInfo, changeDetails)


    def writeInfoToFunctor(self, functor, endOfLineChars):
        """writeInfoToFunctor(ArMapInfoInterface self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMapInfoInterface_writeInfoToFunctor(self, functor, endOfLineChars)

    MAP_INFO = _AriaPy.ArMapInfoInterface_MAP_INFO
    FIRST_INFO = _AriaPy.ArMapInfoInterface_FIRST_INFO
    META_INFO = _AriaPy.ArMapInfoInterface_META_INFO
    TASK_INFO = _AriaPy.ArMapInfoInterface_TASK_INFO
    ROUTE_INFO = _AriaPy.ArMapInfoInterface_ROUTE_INFO
    SCHED_TASK_INFO = _AriaPy.ArMapInfoInterface_SCHED_TASK_INFO
    SCHED_INFO = _AriaPy.ArMapInfoInterface_SCHED_INFO
    CAIRN_INFO = _AriaPy.ArMapInfoInterface_CAIRN_INFO
    CUSTOM_INFO = _AriaPy.ArMapInfoInterface_CUSTOM_INFO
    LAST_INFO = _AriaPy.ArMapInfoInterface_LAST_INFO
    INFO_COUNT = _AriaPy.ArMapInfoInterface_INFO_COUNT

    def getInfoName(self, infoType):
        """getInfoName(ArMapInfoInterface self, int infoType) -> char const *"""
        return _AriaPy.ArMapInfoInterface_getInfoName(self, infoType)

ArMapInfoInterface_swigregister = _AriaPy.ArMapInfoInterface_swigregister
ArMapInfoInterface_swigregister(ArMapInfoInterface)

class ArMapSupplementInterface(object):
    """Proxy of C++ ArMapSupplementInterface 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__ = _AriaPy.delete_ArMapSupplementInterface
    __del__ = lambda self: None

    def hasOriginLatLongAlt(self):
        """hasOriginLatLongAlt(ArMapSupplementInterface self) -> bool"""
        return _AriaPy.ArMapSupplementInterface_hasOriginLatLongAlt(self)


    def getOriginLatLong(self):
        """getOriginLatLong(ArMapSupplementInterface self) -> ArPose"""
        return _AriaPy.ArMapSupplementInterface_getOriginLatLong(self)


    def getOriginAltitude(self):
        """getOriginAltitude(ArMapSupplementInterface self) -> double"""
        return _AriaPy.ArMapSupplementInterface_getOriginAltitude(self)


    def setOriginLatLongAlt(self, hasOriginLatLong, originLatLong, altitude, changeDetails=None):
        """
        setOriginLatLongAlt(ArMapSupplementInterface self, bool hasOriginLatLong, ArPose originLatLong, double altitude, ArMapChangeDetails * changeDetails=None)
        setOriginLatLongAlt(ArMapSupplementInterface self, bool hasOriginLatLong, ArPose originLatLong, double altitude)
        """
        return _AriaPy.ArMapSupplementInterface_setOriginLatLongAlt(self, hasOriginLatLong, originLatLong, altitude, changeDetails)


    def writeSupplementToFunctor(self, functor, endOfLineChars):
        """writeSupplementToFunctor(ArMapSupplementInterface self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMapSupplementInterface_writeSupplementToFunctor(self, functor, endOfLineChars)

ArMapSupplementInterface_swigregister = _AriaPy.ArMapSupplementInterface_swigregister
ArMapSupplementInterface_swigregister(ArMapSupplementInterface)

class ArMapInterface(ArMapInfoInterface, ArMapObjectsInterface, ArMapScanInterface, ArMapSupplementInterface):
    """Proxy of C++ ArMapInterface 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
    MAX_MAP_NAME_LENGTH = _AriaPy.ArMapInterface_MAX_MAP_NAME_LENGTH
    MAP_CATEGORY_2D = _swig_property(_AriaPy.ArMapInterface_MAP_CATEGORY_2D_get, _AriaPy.ArMapInterface_MAP_CATEGORY_2D_set)
    MAP_CATEGORY_2D_MULTI_SOURCES = _swig_property(_AriaPy.ArMapInterface_MAP_CATEGORY_2D_MULTI_SOURCES_get, _AriaPy.ArMapInterface_MAP_CATEGORY_2D_MULTI_SOURCES_set)
    MAP_CATEGORY_2D_EXTENDED = _swig_property(_AriaPy.ArMapInterface_MAP_CATEGORY_2D_EXTENDED_get, _AriaPy.ArMapInterface_MAP_CATEGORY_2D_EXTENDED_set)
    MAP_CATEGORY_2D_COMPOSITE = _swig_property(_AriaPy.ArMapInterface_MAP_CATEGORY_2D_COMPOSITE_get, _AriaPy.ArMapInterface_MAP_CATEGORY_2D_COMPOSITE_set)
    __swig_destroy__ = _AriaPy.delete_ArMapInterface
    __del__ = lambda self: None

    def clear(self):
        """clear(ArMapInterface self)"""
        return _AriaPy.ArMapInterface_clear(self)


    def set(self, other):
        """set(ArMapInterface self, ArMapInterface other) -> bool"""
        return _AriaPy.ArMapInterface_set(self, other)


    def clone(self):
        """clone(ArMapInterface self) -> ArMapInterface"""
        return _AriaPy.ArMapInterface_clone(self)


    def getScanTypes(self):
        """getScanTypes(ArMapInterface self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArMapInterface_getScanTypes(self)


    def setScanTypes(self, scanTypeList):
        """setScanTypes(ArMapInterface self, std::list< std::string,std::allocator< std::string > > const & scanTypeList) -> bool"""
        return _AriaPy.ArMapInterface_setScanTypes(self, scanTypeList)


    def lock(self):
        """lock(ArMapInterface self) -> int"""
        return _AriaPy.ArMapInterface_lock(self)


    def tryLock(self):
        """tryLock(ArMapInterface self) -> int"""
        return _AriaPy.ArMapInterface_tryLock(self)


    def unlock(self):
        """unlock(ArMapInterface self) -> int"""
        return _AriaPy.ArMapInterface_unlock(self)


    def mapChanged(self):
        """mapChanged(ArMapInterface self)"""
        return _AriaPy.ArMapInterface_mapChanged(self)


    def addMapChangedCBPos(self, functor, position):
        """addMapChangedCBPos(ArMapInterface self, ArFunctor functor, ArListPos::Pos position)"""
        return _AriaPy.ArMapInterface_addMapChangedCBPos(self, functor, position)


    def addMapChangedCB(self, functor, position=50):
        """
        addMapChangedCB(ArMapInterface self, ArFunctor functor, int position=50)
        addMapChangedCB(ArMapInterface self, ArFunctor functor)
        """
        return _AriaPy.ArMapInterface_addMapChangedCB(self, functor, position)


    def remMapChangedCB(self, functor):
        """remMapChangedCB(ArMapInterface self, ArFunctor functor)"""
        return _AriaPy.ArMapInterface_remMapChangedCB(self, functor)


    def addPreMapChangedCBPos(self, functor, position):
        """addPreMapChangedCBPos(ArMapInterface self, ArFunctor functor, ArListPos::Pos position)"""
        return _AriaPy.ArMapInterface_addPreMapChangedCBPos(self, functor, position)


    def addPreMapChangedCB(self, functor, position=50):
        """
        addPreMapChangedCB(ArMapInterface self, ArFunctor functor, int position=50)
        addPreMapChangedCB(ArMapInterface self, ArFunctor functor)
        """
        return _AriaPy.ArMapInterface_addPreMapChangedCB(self, functor, position)


    def remPreMapChangedCB(self, functor):
        """remPreMapChangedCB(ArMapInterface self, ArFunctor functor)"""
        return _AriaPy.ArMapInterface_remPreMapChangedCB(self, functor)


    def setMapChangedLogLevel(self, level):
        """setMapChangedLogLevel(ArMapInterface self, ArLog::LogLevel level)"""
        return _AriaPy.ArMapInterface_setMapChangedLogLevel(self, level)


    def getMapChangedLogLevel(self):
        """getMapChangedLogLevel(ArMapInterface self) -> ArLog::LogLevel"""
        return _AriaPy.ArMapInterface_getMapChangedLogLevel(self)


    def writeToFunctor(self, functor, endOfLineChars):
        """writeToFunctor(ArMapInterface self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMapInterface_writeToFunctor(self, functor, endOfLineChars)


    def writeObjectsToFunctor(self, functor, endOfLineChars, isOverrideAsSingleScan=False, maxCategory=None):
        """
        writeObjectsToFunctor(ArMapInterface self, ArFunctor1_CString functor, char const * endOfLineChars, bool isOverrideAsSingleScan=False, char const * maxCategory=None)
        writeObjectsToFunctor(ArMapInterface self, ArFunctor1_CString functor, char const * endOfLineChars, bool isOverrideAsSingleScan=False)
        writeObjectsToFunctor(ArMapInterface self, ArFunctor1_CString functor, char const * endOfLineChars)
        """
        return _AriaPy.ArMapInterface_writeObjectsToFunctor(self, functor, endOfLineChars, isOverrideAsSingleScan, maxCategory)


    def addPreWriteFileCB(self, *args):
        """
        addPreWriteFileCB(ArMapInterface self, ArFunctor functor, ArListPos::Pos position)
        addPreWriteFileCB(ArMapInterface self, ArFunctor functor)
        """
        return _AriaPy.ArMapInterface_addPreWriteFileCB(self, *args)


    def remPreWriteFileCB(self, functor):
        """remPreWriteFileCB(ArMapInterface self, ArFunctor functor)"""
        return _AriaPy.ArMapInterface_remPreWriteFileCB(self, functor)


    def addPostWriteFileCB(self, *args):
        """
        addPostWriteFileCB(ArMapInterface self, ArFunctor functor, ArListPos::Pos position)
        addPostWriteFileCB(ArMapInterface self, ArFunctor functor)
        """
        return _AriaPy.ArMapInterface_addPostWriteFileCB(self, *args)


    def remPostWriteFileCB(self, functor):
        """remPostWriteFileCB(ArMapInterface self, ArFunctor functor)"""
        return _AriaPy.ArMapInterface_remPostWriteFileCB(self, functor)


    def getMapId(self, mapIdOut, isInternalCall=False):
        """
        getMapId(ArMapInterface self, ArMapId mapIdOut, bool isInternalCall=False) -> bool
        getMapId(ArMapInterface self, ArMapId mapIdOut) -> bool
        """
        return _AriaPy.ArMapInterface_getMapId(self, mapIdOut, isInternalCall)


    def calculateChecksum(self, md5DigestBuffer, md5DigestBufferLen):
        """calculateChecksum(ArMapInterface self, unsigned char * md5DigestBuffer, size_t md5DigestBufferLen) -> bool"""
        return _AriaPy.ArMapInterface_calculateChecksum(self, md5DigestBuffer, md5DigestBufferLen)


    def getBaseDirectory(self):
        """getBaseDirectory(ArMapInterface self) -> char const *"""
        return _AriaPy.ArMapInterface_getBaseDirectory(self)


    def setBaseDirectory(self, baseDirectory):
        """setBaseDirectory(ArMapInterface self, char const * baseDirectory)"""
        return _AriaPy.ArMapInterface_setBaseDirectory(self, baseDirectory)


    def getTempDirectory(self):
        """getTempDirectory(ArMapInterface self) -> char const *"""
        return _AriaPy.ArMapInterface_getTempDirectory(self)


    def setTempDirectory(self, tempDirectory):
        """setTempDirectory(ArMapInterface self, char const * tempDirectory)"""
        return _AriaPy.ArMapInterface_setTempDirectory(self, tempDirectory)


    def createRealFileName(self, *args):
        """
        createRealFileName(ArMapInterface self, char const * baseDirectory, char const * fileName, bool isIgnoreCase) -> std::string
        createRealFileName(ArMapInterface self, char const * fileName) -> std::string
        """
        return _AriaPy.ArMapInterface_createRealFileName(self, *args)


    def getFileName(self):
        """getFileName(ArMapInterface self) -> char const *"""
        return _AriaPy.ArMapInterface_getFileName(self)


    def setSourceFileName(self, sourceName, fileName, isInternalCall=False):
        """
        setSourceFileName(ArMapInterface self, char const * sourceName, char const * fileName, bool isInternalCall=False)
        setSourceFileName(ArMapInterface self, char const * sourceName, char const * fileName)
        """
        return _AriaPy.ArMapInterface_setSourceFileName(self, sourceName, fileName, isInternalCall)


    def refresh(self):
        """refresh(ArMapInterface self) -> bool"""
        return _AriaPy.ArMapInterface_refresh(self)


    def setIgnoreEmptyFileName(self, ignore):
        """setIgnoreEmptyFileName(ArMapInterface self, bool ignore)"""
        return _AriaPy.ArMapInterface_setIgnoreEmptyFileName(self, ignore)


    def getIgnoreEmptyFileName(self):
        """getIgnoreEmptyFileName(ArMapInterface self) -> bool"""
        return _AriaPy.ArMapInterface_getIgnoreEmptyFileName(self)


    def setIgnoreCase(self, ignoreCase=False):
        """
        setIgnoreCase(ArMapInterface self, bool ignoreCase=False)
        setIgnoreCase(ArMapInterface self)
        """
        return _AriaPy.ArMapInterface_setIgnoreCase(self, ignoreCase)


    def getIgnoreCase(self):
        """getIgnoreCase(ArMapInterface self) -> bool"""
        return _AriaPy.ArMapInterface_getIgnoreCase(self)


    def getInactiveInfo(self):
        """getInactiveInfo(ArMapInterface self) -> ArMapInfoInterface"""
        return _AriaPy.ArMapInterface_getInactiveInfo(self)


    def getInactiveObjects(self):
        """getInactiveObjects(ArMapInterface self) -> ArMapObjectsInterface"""
        return _AriaPy.ArMapInterface_getInactiveObjects(self)


    def getChildObjects(self):
        """getChildObjects(ArMapInterface self) -> ArMapObjectsInterface"""
        return _AriaPy.ArMapInterface_getChildObjects(self)


    def findMapObjectParams(self, mapObjectName):
        """findMapObjectParams(ArMapInterface self, char const * mapObjectName) -> ArArgumentBuilder"""
        return _AriaPy.ArMapInterface_findMapObjectParams(self, mapObjectName)


    def setMapObjectParams(self, mapObjectName, params, changeDetails=None):
        """
        setMapObjectParams(ArMapInterface self, char const * mapObjectName, ArArgumentBuilder params, ArMapChangeDetails * changeDetails=None) -> bool
        setMapObjectParams(ArMapInterface self, char const * mapObjectName, ArArgumentBuilder params) -> bool
        """
        return _AriaPy.ArMapInterface_setMapObjectParams(self, mapObjectName, params, changeDetails)


    def getRemainder(self):
        """getRemainder(ArMapInterface self) -> ArArgumentBuilderPtrList"""
        return _AriaPy.ArMapInterface_getRemainder(self)


    def setQuiet(self, isQuiet):
        """setQuiet(ArMapInterface self, bool isQuiet)"""
        return _AriaPy.ArMapInterface_setQuiet(self, isQuiet)


    def parseLine(self, line):
        """parseLine(ArMapInterface self, char * line) -> bool"""
        return _AriaPy.ArMapInterface_parseLine(self, line)


    def parsingComplete(self):
        """parsingComplete(ArMapInterface self)"""
        return _AriaPy.ArMapInterface_parsingComplete(self)


    def isLoadingDataStarted(self):
        """isLoadingDataStarted(ArMapInterface self) -> bool"""
        return _AriaPy.ArMapInterface_isLoadingDataStarted(self)


    def isLoadingLinesAndDataStarted(self):
        """isLoadingLinesAndDataStarted(ArMapInterface self) -> bool"""
        return _AriaPy.ArMapInterface_isLoadingLinesAndDataStarted(self)

ArMapInterface_swigregister = _AriaPy.ArMapInterface_swigregister
ArMapInterface_swigregister(ArMapInterface)

class ArMap(ArMapInterface):
    """Proxy of C++ ArMap 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__(ArMap self, char const * baseDirectory, bool addToGlobalConfig=True, char const * configSection, char const * configParam, char const * configDesc, bool ignoreEmptyFileName=True, ArPriority::Priority priority, char const * tempDirectory=None, int configProcessFilePriority=100) -> ArMap
        __init__(ArMap self, char const * baseDirectory, bool addToGlobalConfig=True, char const * configSection, char const * configParam, char const * configDesc, bool ignoreEmptyFileName=True, ArPriority::Priority priority, char const * tempDirectory=None) -> ArMap
        __init__(ArMap self, char const * baseDirectory, bool addToGlobalConfig=True, char const * configSection, char const * configParam, char const * configDesc, bool ignoreEmptyFileName=True, ArPriority::Priority priority) -> ArMap
        __init__(ArMap self, char const * baseDirectory, bool addToGlobalConfig=True, char const * configSection, char const * configParam, char const * configDesc, bool ignoreEmptyFileName=True) -> ArMap
        __init__(ArMap self, char const * baseDirectory, bool addToGlobalConfig=True, char const * configSection, char const * configParam, char const * configDesc) -> ArMap
        __init__(ArMap self, char const * baseDirectory, bool addToGlobalConfig=True, char const * configSection, char const * configParam) -> ArMap
        __init__(ArMap self, char const * baseDirectory, bool addToGlobalConfig=True, char const * configSection) -> ArMap
        __init__(ArMap self, char const * baseDirectory, bool addToGlobalConfig=True) -> ArMap
        __init__(ArMap self, char const * baseDirectory) -> ArMap
        __init__(ArMap self) -> ArMap
        __init__(ArMap self, ArMap other) -> ArMap
        """
        this = _AriaPy.new_ArMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMap
    __del__ = lambda self: None

    def getScanTypes(self):
        """getScanTypes(ArMap self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArMap_getScanTypes(self)


    def setScanTypes(self, scanTypeList):
        """setScanTypes(ArMap self, std::list< std::string,std::allocator< std::string > > const & scanTypeList) -> bool"""
        return _AriaPy.ArMap_setScanTypes(self, scanTypeList)


    def lock(self):
        """lock(ArMap self) -> int"""
        return _AriaPy.ArMap_lock(self)


    def tryLock(self):
        """tryLock(ArMap self) -> int"""
        return _AriaPy.ArMap_tryLock(self)


    def unlock(self):
        """unlock(ArMap self) -> int"""
        return _AriaPy.ArMap_unlock(self)


    def getDisplayString(self, *args):
        """
        getDisplayString(ArMap self, char const * scanType) -> char const
        getDisplayString(ArMap self) -> char const *
        """
        return _AriaPy.ArMap_getDisplayString(self, *args)


    def getPoints(self, *args):
        """
        getPoints(ArMap self, char const * scanType) -> std::vector< ArPose,std::allocator< ArPose > >
        getPoints(ArMap self) -> std::vector< ArPose,std::allocator< ArPose > > *
        """
        return _AriaPy.ArMap_getPoints(self, *args)


    def getMinPose(self, *args):
        """
        getMinPose(ArMap self, char const * scanType) -> ArPose
        getMinPose(ArMap self) -> ArPose
        """
        return _AriaPy.ArMap_getMinPose(self, *args)


    def getMaxPose(self, *args):
        """
        getMaxPose(ArMap self, char const * scanType) -> ArPose
        getMaxPose(ArMap self) -> ArPose
        """
        return _AriaPy.ArMap_getMaxPose(self, *args)


    def getNumPoints(self, *args):
        """
        getNumPoints(ArMap self, char const * scanType) -> int
        getNumPoints(ArMap self) -> int
        """
        return _AriaPy.ArMap_getNumPoints(self, *args)


    def isSortedPoints(self, *args):
        """
        isSortedPoints(ArMap self, char const * scanType) -> bool
        isSortedPoints(ArMap self) -> bool
        """
        return _AriaPy.ArMap_isSortedPoints(self, *args)


    def setPoints(self, *args):
        """
        setPoints(ArMap self, std::vector< ArPose,std::allocator< ArPose > > const * points, char const * scanType, bool isSortedPoints=False, ArMapChangeDetails * changeDetails=None)
        setPoints(ArMap self, std::vector< ArPose,std::allocator< ArPose > > const * points, char const * scanType, bool isSortedPoints=False)
        setPoints(ArMap self, std::vector< ArPose,std::allocator< ArPose > > const * points, char const * scanType)
        setPoints(ArMap self, std::vector< ArPose,std::allocator< ArPose > > const * points)
        """
        return _AriaPy.ArMap_setPoints(self, *args)


    def getLines(self, *args):
        """
        getLines(ArMap self, char const * scanType) -> std::vector< ArLineSegment,std::allocator< ArLineSegment > >
        getLines(ArMap self) -> std::vector< ArLineSegment,std::allocator< ArLineSegment > > *
        """
        return _AriaPy.ArMap_getLines(self, *args)


    def getLineMinPose(self, *args):
        """
        getLineMinPose(ArMap self, char const * scanType) -> ArPose
        getLineMinPose(ArMap self) -> ArPose
        """
        return _AriaPy.ArMap_getLineMinPose(self, *args)


    def getLineMaxPose(self, *args):
        """
        getLineMaxPose(ArMap self, char const * scanType) -> ArPose
        getLineMaxPose(ArMap self) -> ArPose
        """
        return _AriaPy.ArMap_getLineMaxPose(self, *args)


    def getNumLines(self, *args):
        """
        getNumLines(ArMap self, char const * scanType) -> int
        getNumLines(ArMap self) -> int
        """
        return _AriaPy.ArMap_getNumLines(self, *args)


    def isSortedLines(self, *args):
        """
        isSortedLines(ArMap self, char const * scanType) -> bool
        isSortedLines(ArMap self) -> bool
        """
        return _AriaPy.ArMap_isSortedLines(self, *args)


    def setLines(self, *args):
        """
        setLines(ArMap self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines, char const * scanType, bool isSortedLines=False, ArMapChangeDetails * changeDetails=None)
        setLines(ArMap self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines, char const * scanType, bool isSortedLines=False)
        setLines(ArMap self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines, char const * scanType)
        setLines(ArMap self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines)
        """
        return _AriaPy.ArMap_setLines(self, *args)


    def getResolution(self, *args):
        """
        getResolution(ArMap self, char const * scanType) -> int
        getResolution(ArMap self) -> int
        """
        return _AriaPy.ArMap_getResolution(self, *args)


    def setResolution(self, *args):
        """
        setResolution(ArMap self, int resolution, char const * scanType, ArMapChangeDetails * changeDetails=None)
        setResolution(ArMap self, int resolution, char const * scanType)
        setResolution(ArMap self, int resolution)
        """
        return _AriaPy.ArMap_setResolution(self, *args)


    def writeScanToFunctor(self, *args):
        """
        writeScanToFunctor(ArMap self, ArFunctor1_CString functor, char const * endOfLineChars, char const * scanType)
        writeScanToFunctor(ArMap self, ArFunctor1_CString functor, char const * endOfLineChars)
        """
        return _AriaPy.ArMap_writeScanToFunctor(self, *args)


    def writePointsToFunctor(self, *args):
        """
        writePointsToFunctor(ArMap self, ArFunctor2< int,std::vector< ArPose,std::allocator< ArPose > > * > * functor, char const * scanType, ArFunctor1_CString keywordFunctor=None)
        writePointsToFunctor(ArMap self, ArFunctor2< int,std::vector< ArPose,std::allocator< ArPose > > * > * functor, char const * scanType)
        writePointsToFunctor(ArMap self, ArFunctor2< int,std::vector< ArPose,std::allocator< ArPose > > * > * functor)
        """
        return _AriaPy.ArMap_writePointsToFunctor(self, *args)


    def writeLinesToFunctor(self, *args):
        """
        writeLinesToFunctor(ArMap self, ArFunctor2< int,std::vector< ArLineSegment,std::allocator< ArLineSegment > > * > * functor, char const * scanType, ArFunctor1_CString keywordFunctor=None)
        writeLinesToFunctor(ArMap self, ArFunctor2< int,std::vector< ArLineSegment,std::allocator< ArLineSegment > > * > * functor, char const * scanType)
        writeLinesToFunctor(ArMap self, ArFunctor2< int,std::vector< ArLineSegment,std::allocator< ArLineSegment > > * > * functor)
        """
        return _AriaPy.ArMap_writeLinesToFunctor(self, *args)


    def addToFileParser(self, fileParser):
        """addToFileParser(ArMap self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMap_addToFileParser(self, fileParser)


    def remFromFileParser(self, fileParser):
        """remFromFileParser(ArMap self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMap_remFromFileParser(self, fileParser)


    def readDataPoint(self, line):
        """readDataPoint(ArMap self, char * line) -> bool"""
        return _AriaPy.ArMap_readDataPoint(self, line)


    def readLineSegment(self, line):
        """readLineSegment(ArMap self, char * line) -> bool"""
        return _AriaPy.ArMap_readLineSegment(self, line)


    def loadDataPoint(self, x, y):
        """loadDataPoint(ArMap self, double x, double y)"""
        return _AriaPy.ArMap_loadDataPoint(self, x, y)


    def loadLineSegment(self, x1, y1, x2, y2):
        """loadLineSegment(ArMap self, double x1, double y1, double x2, double y2)"""
        return _AriaPy.ArMap_loadLineSegment(self, x1, y1, x2, y2)


    def findFirstMapObject(self, name, type, isIncludeWithHeading=False):
        """
        findFirstMapObject(ArMap self, char const * name, char const * type, bool isIncludeWithHeading=False) -> ArMapObject
        findFirstMapObject(ArMap self, char const * name, char const * type) -> ArMapObject
        """
        return _AriaPy.ArMap_findFirstMapObject(self, name, type, isIncludeWithHeading)


    def findMapObject(self, name, type=None, isIncludeWithHeading=False):
        """
        findMapObject(ArMap self, char const * name, char const * type=None, bool isIncludeWithHeading=False) -> ArMapObject
        findMapObject(ArMap self, char const * name, char const * type=None) -> ArMapObject
        findMapObject(ArMap self, char const * name) -> ArMapObject
        """
        return _AriaPy.ArMap_findMapObject(self, name, type, isIncludeWithHeading)


    def findMapObjectsOfType(self, type, isIncludeWithHeading=False):
        """
        findMapObjectsOfType(ArMap self, char const * type, bool isIncludeWithHeading=False) -> ArMapObjectPtrList
        findMapObjectsOfType(ArMap self, char const * type) -> ArMapObjectPtrList
        """
        return _AriaPy.ArMap_findMapObjectsOfType(self, type, isIncludeWithHeading)


    def getMapObjects(self):
        """getMapObjects(ArMap self) -> ArMapObjectPtrList"""
        return _AriaPy.ArMap_getMapObjects(self)


    def setMapObjects(self, mapObjects, isSortedObjects=False, changeDetails=None):
        """
        setMapObjects(ArMap self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False, ArMapChangeDetails * changeDetails=None)
        setMapObjects(ArMap self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False)
        setMapObjects(ArMap self, ArMapObjectPtrList mapObjects)
        """
        return _AriaPy.ArMap_setMapObjects(self, mapObjects, isSortedObjects, changeDetails)


    def writeObjectListToFunctor(self, functor, endOfLineChars):
        """writeObjectListToFunctor(ArMap self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMap_writeObjectListToFunctor(self, functor, endOfLineChars)


    def getInfo(self, *args):
        """
        getInfo(ArMap self, char const * infoName) -> ArArgumentBuilderPtrList
        getInfo(ArMap self, int infoType) -> ArArgumentBuilderPtrList
        """
        return _AriaPy.ArMap_getInfo(self, *args)


    def getMapInfo(self):
        """getMapInfo(ArMap self) -> ArArgumentBuilderPtrList"""
        return _AriaPy.ArMap_getMapInfo(self)


    def getInfoCount(self):
        """getInfoCount(ArMap self) -> int"""
        return _AriaPy.ArMap_getInfoCount(self)


    def getInfoNames(self):
        """getInfoNames(ArMap self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArMap_getInfoNames(self)


    def setInfo(self, *args):
        """
        setInfo(ArMap self, char const * infoName, ArArgumentBuilderPtrList infoList, ArMapChangeDetails * changeDetails=None) -> bool
        setInfo(ArMap self, char const * infoName, ArArgumentBuilderPtrList infoList) -> bool
        setInfo(ArMap self, int infoType, ArArgumentBuilderPtrList infoList, ArMapChangeDetails * changeDetails=None) -> bool
        setInfo(ArMap self, int infoType, ArArgumentBuilderPtrList infoList) -> bool
        """
        return _AriaPy.ArMap_setInfo(self, *args)


    def setMapInfo(self, mapInfo, changeDetails=None):
        """
        setMapInfo(ArMap self, ArArgumentBuilderPtrList mapInfo, ArMapChangeDetails * changeDetails=None) -> bool
        setMapInfo(ArMap self, ArArgumentBuilderPtrList mapInfo) -> bool
        """
        return _AriaPy.ArMap_setMapInfo(self, mapInfo, changeDetails)


    def getInfoName(self, infoType):
        """getInfoName(ArMap self, int infoType) -> char const *"""
        return _AriaPy.ArMap_getInfoName(self, infoType)


    def writeInfoToFunctor(self, functor, endOfLineChars):
        """writeInfoToFunctor(ArMap self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMap_writeInfoToFunctor(self, functor, endOfLineChars)


    def hasOriginLatLongAlt(self):
        """hasOriginLatLongAlt(ArMap self) -> bool"""
        return _AriaPy.ArMap_hasOriginLatLongAlt(self)


    def getOriginLatLong(self):
        """getOriginLatLong(ArMap self) -> ArPose"""
        return _AriaPy.ArMap_getOriginLatLong(self)


    def getOriginAltitude(self):
        """getOriginAltitude(ArMap self) -> double"""
        return _AriaPy.ArMap_getOriginAltitude(self)


    def setOriginLatLongAlt(self, hasOriginLatLong, originLatLong, altitude, changeDetails=None):
        """
        setOriginLatLongAlt(ArMap self, bool hasOriginLatLong, ArPose originLatLong, double altitude, ArMapChangeDetails * changeDetails=None)
        setOriginLatLongAlt(ArMap self, bool hasOriginLatLong, ArPose originLatLong, double altitude)
        """
        return _AriaPy.ArMap_setOriginLatLongAlt(self, hasOriginLatLong, originLatLong, altitude, changeDetails)


    def writeSupplementToFunctor(self, functor, endOfLineChars):
        """writeSupplementToFunctor(ArMap self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMap_writeSupplementToFunctor(self, functor, endOfLineChars)


    def clear(self):
        """clear(ArMap self)"""
        return _AriaPy.ArMap_clear(self)


    def set(self, other):
        """set(ArMap self, ArMapInterface other) -> bool"""
        return _AriaPy.ArMap_set(self, other)


    def clone(self):
        """clone(ArMap self) -> ArMapInterface"""
        return _AriaPy.ArMap_clone(self)


    def mapChanged(self):
        """mapChanged(ArMap self)"""
        return _AriaPy.ArMap_mapChanged(self)


    def addMapChangedCB(self, functor, position=50):
        """
        addMapChangedCB(ArMap self, ArFunctor functor, int position=50)
        addMapChangedCB(ArMap self, ArFunctor functor)
        """
        return _AriaPy.ArMap_addMapChangedCB(self, functor, position)


    def remMapChangedCB(self, functor):
        """remMapChangedCB(ArMap self, ArFunctor functor)"""
        return _AriaPy.ArMap_remMapChangedCB(self, functor)


    def addPreMapChangedCB(self, functor, position=50):
        """
        addPreMapChangedCB(ArMap self, ArFunctor functor, int position=50)
        addPreMapChangedCB(ArMap self, ArFunctor functor)
        """
        return _AriaPy.ArMap_addPreMapChangedCB(self, functor, position)


    def remPreMapChangedCB(self, functor):
        """remPreMapChangedCB(ArMap self, ArFunctor functor)"""
        return _AriaPy.ArMap_remPreMapChangedCB(self, functor)


    def setMapChangedLogLevel(self, level):
        """setMapChangedLogLevel(ArMap self, ArLog::LogLevel level)"""
        return _AriaPy.ArMap_setMapChangedLogLevel(self, level)


    def getMapChangedLogLevel(self):
        """getMapChangedLogLevel(ArMap self) -> ArLog::LogLevel"""
        return _AriaPy.ArMap_getMapChangedLogLevel(self)


    def writeToFunctor(self, functor, endOfLineChars):
        """writeToFunctor(ArMap self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMap_writeToFunctor(self, functor, endOfLineChars)


    def writeObjectsToFunctor(self, functor, endOfLineChars, isOverrideAsSingleScan=False, maxCategory=None):
        """
        writeObjectsToFunctor(ArMap self, ArFunctor1_CString functor, char const * endOfLineChars, bool isOverrideAsSingleScan=False, char const * maxCategory=None)
        writeObjectsToFunctor(ArMap self, ArFunctor1_CString functor, char const * endOfLineChars, bool isOverrideAsSingleScan=False)
        writeObjectsToFunctor(ArMap self, ArFunctor1_CString functor, char const * endOfLineChars)
        """
        return _AriaPy.ArMap_writeObjectsToFunctor(self, functor, endOfLineChars, isOverrideAsSingleScan, maxCategory)


    def addPreWriteFileCB(self, *args):
        """
        addPreWriteFileCB(ArMap self, ArFunctor functor, ArListPos::Pos position)
        addPreWriteFileCB(ArMap self, ArFunctor functor)
        """
        return _AriaPy.ArMap_addPreWriteFileCB(self, *args)


    def remPreWriteFileCB(self, functor):
        """remPreWriteFileCB(ArMap self, ArFunctor functor)"""
        return _AriaPy.ArMap_remPreWriteFileCB(self, functor)


    def addPostWriteFileCB(self, *args):
        """
        addPostWriteFileCB(ArMap self, ArFunctor functor, ArListPos::Pos position)
        addPostWriteFileCB(ArMap self, ArFunctor functor)
        """
        return _AriaPy.ArMap_addPostWriteFileCB(self, *args)


    def remPostWriteFileCB(self, functor):
        """remPostWriteFileCB(ArMap self, ArFunctor functor)"""
        return _AriaPy.ArMap_remPostWriteFileCB(self, functor)


    def forceMapLoadOnConfigProcessFile(self):
        """forceMapLoadOnConfigProcessFile(ArMap self)"""
        return _AriaPy.ArMap_forceMapLoadOnConfigProcessFile(self)


    def readFile(self, fileName):
        """readFile(ArMap self, char const * fileName) -> bool"""
        return _AriaPy.ArMap_readFile(self, fileName)


    def writeFile(self, fileName):
        """writeFile(ArMap self, char const * fileName) -> bool"""
        return _AriaPy.ArMap_writeFile(self, fileName)


    def getMapId(self, mapIdOut, isInternalCall=False):
        """
        getMapId(ArMap self, ArMapId mapIdOut, bool isInternalCall=False) -> bool
        getMapId(ArMap self, ArMapId mapIdOut) -> bool
        """
        return _AriaPy.ArMap_getMapId(self, mapIdOut, isInternalCall)


    def calculateChecksum(self, md5DigestBuffer, md5DigestBufferLen):
        """calculateChecksum(ArMap self, unsigned char * md5DigestBuffer, size_t md5DigestBufferLen) -> bool"""
        return _AriaPy.ArMap_calculateChecksum(self, md5DigestBuffer, md5DigestBufferLen)


    def getBaseDirectory(self):
        """getBaseDirectory(ArMap self) -> char const *"""
        return _AriaPy.ArMap_getBaseDirectory(self)


    def setBaseDirectory(self, baseDirectory):
        """setBaseDirectory(ArMap self, char const * baseDirectory)"""
        return _AriaPy.ArMap_setBaseDirectory(self, baseDirectory)


    def getTempDirectory(self):
        """getTempDirectory(ArMap self) -> char const *"""
        return _AriaPy.ArMap_getTempDirectory(self)


    def setTempDirectory(self, tempDirectory):
        """setTempDirectory(ArMap self, char const * tempDirectory)"""
        return _AriaPy.ArMap_setTempDirectory(self, tempDirectory)


    def createRealFileName(self, fileName):
        """createRealFileName(ArMap self, char const * fileName) -> std::string"""
        return _AriaPy.ArMap_createRealFileName(self, fileName)


    def getFileName(self):
        """getFileName(ArMap self) -> char const *"""
        return _AriaPy.ArMap_getFileName(self)


    def setSourceFileName(self, sourceName, fileName, isInternalCall=False):
        """
        setSourceFileName(ArMap self, char const * sourceName, char const * fileName, bool isInternalCall=False)
        setSourceFileName(ArMap self, char const * sourceName, char const * fileName)
        """
        return _AriaPy.ArMap_setSourceFileName(self, sourceName, fileName, isInternalCall)


    def refresh(self):
        """refresh(ArMap self) -> bool"""
        return _AriaPy.ArMap_refresh(self)


    def setIgnoreEmptyFileName(self, ignore):
        """setIgnoreEmptyFileName(ArMap self, bool ignore)"""
        return _AriaPy.ArMap_setIgnoreEmptyFileName(self, ignore)


    def getIgnoreEmptyFileName(self):
        """getIgnoreEmptyFileName(ArMap self) -> bool"""
        return _AriaPy.ArMap_getIgnoreEmptyFileName(self)


    def setIgnoreCase(self, ignoreCase=False):
        """
        setIgnoreCase(ArMap self, bool ignoreCase=False)
        setIgnoreCase(ArMap self)
        """
        return _AriaPy.ArMap_setIgnoreCase(self, ignoreCase)


    def getIgnoreCase(self):
        """getIgnoreCase(ArMap self) -> bool"""
        return _AriaPy.ArMap_getIgnoreCase(self)


    def getInactiveInfo(self):
        """getInactiveInfo(ArMap self) -> ArMapInfoInterface"""
        return _AriaPy.ArMap_getInactiveInfo(self)


    def getInactiveObjects(self):
        """getInactiveObjects(ArMap self) -> ArMapObjectsInterface"""
        return _AriaPy.ArMap_getInactiveObjects(self)


    def getChildObjects(self):
        """getChildObjects(ArMap self) -> ArMapObjectsInterface"""
        return _AriaPy.ArMap_getChildObjects(self)


    def findMapObjectParams(self, mapObjectName):
        """findMapObjectParams(ArMap self, char const * mapObjectName) -> ArArgumentBuilder"""
        return _AriaPy.ArMap_findMapObjectParams(self, mapObjectName)


    def setMapObjectParams(self, mapObjectName, params, changeDetails=None):
        """
        setMapObjectParams(ArMap self, char const * mapObjectName, ArArgumentBuilder params, ArMapChangeDetails * changeDetails=None) -> bool
        setMapObjectParams(ArMap self, char const * mapObjectName, ArArgumentBuilder params) -> bool
        """
        return _AriaPy.ArMap_setMapObjectParams(self, mapObjectName, params, changeDetails)


    def getRemainder(self):
        """getRemainder(ArMap self) -> ArArgumentBuilderPtrList"""
        return _AriaPy.ArMap_getRemainder(self)


    def setQuiet(self, isQuiet):
        """setQuiet(ArMap self, bool isQuiet)"""
        return _AriaPy.ArMap_setQuiet(self, isQuiet)


    def parseLine(self, line):
        """parseLine(ArMap self, char * line) -> bool"""
        return _AriaPy.ArMap_parseLine(self, line)


    def parsingComplete(self):
        """parsingComplete(ArMap self)"""
        return _AriaPy.ArMap_parsingComplete(self)


    def isLoadingDataStarted(self):
        """isLoadingDataStarted(ArMap self) -> bool"""
        return _AriaPy.ArMap_isLoadingDataStarted(self)


    def isLoadingLinesAndDataStarted(self):
        """isLoadingLinesAndDataStarted(ArMap self) -> bool"""
        return _AriaPy.ArMap_isLoadingLinesAndDataStarted(self)


    def readFileAndChangeConfig(self, fileName):
        """readFileAndChangeConfig(ArMap self, char const * fileName) -> bool"""
        return _AriaPy.ArMap_readFileAndChangeConfig(self, fileName)


    def changeConfigMapName(self, fileName):
        """changeConfigMapName(ArMap self, char const * fileName)"""
        return _AriaPy.ArMap_changeConfigMapName(self, fileName)

ArMap_swigregister = _AriaPy.ArMap_swigregister
ArMap_swigregister(ArMap)

class ArMapScan(ArMapScanInterface):
    """Proxy of C++ ArMapScan 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__(ArMapScan self, char const * scanType) -> ArMapScan
        __init__(ArMapScan self) -> ArMapScan
        __init__(ArMapScan self, ArMapScan other) -> ArMapScan
        """
        this = _AriaPy.new_ArMapScan(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMapScan
    __del__ = lambda self: None

    def getDisplayString(self, *args):
        """
        getDisplayString(ArMapScan self, char const * scanType) -> char const
        getDisplayString(ArMapScan self) -> char const *
        """
        return _AriaPy.ArMapScan_getDisplayString(self, *args)


    def getPoints(self, *args):
        """
        getPoints(ArMapScan self, char const * scanType) -> std::vector< ArPose,std::allocator< ArPose > >
        getPoints(ArMapScan self) -> std::vector< ArPose,std::allocator< ArPose > > *
        """
        return _AriaPy.ArMapScan_getPoints(self, *args)


    def getLines(self, *args):
        """
        getLines(ArMapScan self, char const * scanType) -> std::vector< ArLineSegment,std::allocator< ArLineSegment > >
        getLines(ArMapScan self) -> std::vector< ArLineSegment,std::allocator< ArLineSegment > > *
        """
        return _AriaPy.ArMapScan_getLines(self, *args)


    def getMinPose(self, *args):
        """
        getMinPose(ArMapScan self, char const * scanType) -> ArPose
        getMinPose(ArMapScan self) -> ArPose
        """
        return _AriaPy.ArMapScan_getMinPose(self, *args)


    def getMaxPose(self, *args):
        """
        getMaxPose(ArMapScan self, char const * scanType) -> ArPose
        getMaxPose(ArMapScan self) -> ArPose
        """
        return _AriaPy.ArMapScan_getMaxPose(self, *args)


    def getNumPoints(self, *args):
        """
        getNumPoints(ArMapScan self, char const * scanType) -> int
        getNumPoints(ArMapScan self) -> int
        """
        return _AriaPy.ArMapScan_getNumPoints(self, *args)


    def isSortedPoints(self, *args):
        """
        isSortedPoints(ArMapScan self, char const * scanType) -> bool
        isSortedPoints(ArMapScan self) -> bool
        """
        return _AriaPy.ArMapScan_isSortedPoints(self, *args)


    def setPoints(self, *args):
        """
        setPoints(ArMapScan self, std::vector< ArPose,std::allocator< ArPose > > const * points, char const * scanType, bool isSortedPoints=False, ArMapChangeDetails * changeDetails=None)
        setPoints(ArMapScan self, std::vector< ArPose,std::allocator< ArPose > > const * points, char const * scanType, bool isSortedPoints=False)
        setPoints(ArMapScan self, std::vector< ArPose,std::allocator< ArPose > > const * points, char const * scanType)
        setPoints(ArMapScan self, std::vector< ArPose,std::allocator< ArPose > > const * points)
        """
        return _AriaPy.ArMapScan_setPoints(self, *args)


    def getLineMinPose(self, *args):
        """
        getLineMinPose(ArMapScan self, char const * scanType) -> ArPose
        getLineMinPose(ArMapScan self) -> ArPose
        """
        return _AriaPy.ArMapScan_getLineMinPose(self, *args)


    def getLineMaxPose(self, *args):
        """
        getLineMaxPose(ArMapScan self, char const * scanType) -> ArPose
        getLineMaxPose(ArMapScan self) -> ArPose
        """
        return _AriaPy.ArMapScan_getLineMaxPose(self, *args)


    def getNumLines(self, *args):
        """
        getNumLines(ArMapScan self, char const * scanType) -> int
        getNumLines(ArMapScan self) -> int
        """
        return _AriaPy.ArMapScan_getNumLines(self, *args)


    def isSortedLines(self, *args):
        """
        isSortedLines(ArMapScan self, char const * scanType) -> bool
        isSortedLines(ArMapScan self) -> bool
        """
        return _AriaPy.ArMapScan_isSortedLines(self, *args)


    def setLines(self, *args):
        """
        setLines(ArMapScan self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines, char const * scanType, bool isSortedLines=False, ArMapChangeDetails * changeDetails=None)
        setLines(ArMapScan self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines, char const * scanType, bool isSortedLines=False)
        setLines(ArMapScan self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines, char const * scanType)
        setLines(ArMapScan self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines)
        """
        return _AriaPy.ArMapScan_setLines(self, *args)


    def getResolution(self, *args):
        """
        getResolution(ArMapScan self, char const * scanType) -> int
        getResolution(ArMapScan self) -> int
        """
        return _AriaPy.ArMapScan_getResolution(self, *args)


    def setResolution(self, *args):
        """
        setResolution(ArMapScan self, int resolution, char const * scanType, ArMapChangeDetails * changeDetails=None)
        setResolution(ArMapScan self, int resolution, char const * scanType)
        setResolution(ArMapScan self, int resolution)
        """
        return _AriaPy.ArMapScan_setResolution(self, *args)


    def writeScanToFunctor(self, *args):
        """
        writeScanToFunctor(ArMapScan self, ArFunctor1_CString functor, char const * endOfLineChars, char const * scanType)
        writeScanToFunctor(ArMapScan self, ArFunctor1_CString functor, char const * endOfLineChars)
        """
        return _AriaPy.ArMapScan_writeScanToFunctor(self, *args)


    def addToFileParser(self, fileParser):
        """addToFileParser(ArMapScan self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMapScan_addToFileParser(self, fileParser)


    def remFromFileParser(self, fileParser):
        """remFromFileParser(ArMapScan self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMapScan_remFromFileParser(self, fileParser)


    def readDataPoint(self, line):
        """readDataPoint(ArMapScan self, char * line) -> bool"""
        return _AriaPy.ArMapScan_readDataPoint(self, line)


    def readLineSegment(self, line):
        """readLineSegment(ArMapScan self, char * line) -> bool"""
        return _AriaPy.ArMapScan_readLineSegment(self, line)


    def loadDataPoint(self, x, y):
        """loadDataPoint(ArMapScan self, double x, double y)"""
        return _AriaPy.ArMapScan_loadDataPoint(self, x, y)


    def loadLineSegment(self, x1, y1, x2, y2):
        """loadLineSegment(ArMapScan self, double x1, double y1, double x2, double y2)"""
        return _AriaPy.ArMapScan_loadLineSegment(self, x1, y1, x2, y2)


    def clear(self):
        """clear(ArMapScan self)"""
        return _AriaPy.ArMapScan_clear(self)


    def unite(self, other, isIncludeDataPointsAndLines=False):
        """
        unite(ArMapScan self, ArMapScan other, bool isIncludeDataPointsAndLines=False) -> bool
        unite(ArMapScan self, ArMapScan other) -> bool
        """
        return _AriaPy.ArMapScan_unite(self, other, isIncludeDataPointsAndLines)


    def getTimeChanged(self):
        """getTimeChanged(ArMapScan self) -> ArTime"""
        return _AriaPy.ArMapScan_getTimeChanged(self)


    def getScanType(self):
        """getScanType(ArMapScan self) -> char const *"""
        return _AriaPy.ArMapScan_getScanType(self)


    def getPointsKeyword(self):
        """getPointsKeyword(ArMapScan self) -> char const *"""
        return _AriaPy.ArMapScan_getPointsKeyword(self)


    def getLinesKeyword(self):
        """getLinesKeyword(ArMapScan self) -> char const *"""
        return _AriaPy.ArMapScan_getLinesKeyword(self)


    def writePointsToFunctor(self, *args):
        """
        writePointsToFunctor(ArMapScan self, ArFunctor2< int,std::vector< ArPose,std::allocator< ArPose > > * > * functor, char const * scanType, ArFunctor1_CString keywordFunctor=None)
        writePointsToFunctor(ArMapScan self, ArFunctor2< int,std::vector< ArPose,std::allocator< ArPose > > * > * functor, char const * scanType)
        writePointsToFunctor(ArMapScan self, ArFunctor2< int,std::vector< ArPose,std::allocator< ArPose > > * > * functor)
        writePointsToFunctor(ArMapScan self, ArFunctor1_CString functor, char const * endOfLineChars, char const * scanType)
        writePointsToFunctor(ArMapScan self, ArFunctor1_CString functor, char const * endOfLineChars)
        """
        return _AriaPy.ArMapScan_writePointsToFunctor(self, *args)


    def writeLinesToFunctor(self, *args):
        """
        writeLinesToFunctor(ArMapScan self, ArFunctor2< int,std::vector< ArLineSegment,std::allocator< ArLineSegment > > * > * functor, char const * scanType, ArFunctor1_CString keywordFunctor=None)
        writeLinesToFunctor(ArMapScan self, ArFunctor2< int,std::vector< ArLineSegment,std::allocator< ArLineSegment > > * > * functor, char const * scanType)
        writeLinesToFunctor(ArMapScan self, ArFunctor2< int,std::vector< ArLineSegment,std::allocator< ArLineSegment > > * > * functor)
        writeLinesToFunctor(ArMapScan self, ArFunctor1_CString functor, char const * endOfLineChars, char const * scanType)
        writeLinesToFunctor(ArMapScan self, ArFunctor1_CString functor, char const * endOfLineChars)
        """
        return _AriaPy.ArMapScan_writeLinesToFunctor(self, *args)


    def addExtraToFileParser(self, fileParser, isAddLineHandler):
        """addExtraToFileParser(ArMapScan self, ArFileParser fileParser, bool isAddLineHandler) -> bool"""
        return _AriaPy.ArMapScan_addExtraToFileParser(self, fileParser, isAddLineHandler)


    def remExtraFromFileParser(self, fileParser):
        """remExtraFromFileParser(ArMapScan self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMapScan_remExtraFromFileParser(self, fileParser)

ArMapScan_swigregister = _AriaPy.ArMapScan_swigregister
ArMapScan_swigregister(ArMapScan)

class ArMapObjects(ArMapObjectsInterface):
    """Proxy of C++ ArMapObjects class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    DEFAULT_KEYWORD = _swig_property(_AriaPy.ArMapObjects_DEFAULT_KEYWORD_get, _AriaPy.ArMapObjects_DEFAULT_KEYWORD_set)

    def __init__(self, *args):
        """
        __init__(ArMapObjects self, char const * keyword) -> ArMapObjects
        __init__(ArMapObjects self) -> ArMapObjects
        __init__(ArMapObjects self, ArMapObjects other) -> ArMapObjects
        """
        this = _AriaPy.new_ArMapObjects(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMapObjects
    __del__ = lambda self: None

    def findFirstMapObject(self, name, type, isIncludeWithHeading=False):
        """
        findFirstMapObject(ArMapObjects self, char const * name, char const * type, bool isIncludeWithHeading=False) -> ArMapObject
        findFirstMapObject(ArMapObjects self, char const * name, char const * type) -> ArMapObject
        """
        return _AriaPy.ArMapObjects_findFirstMapObject(self, name, type, isIncludeWithHeading)


    def findMapObject(self, name, type=None, isIncludeWithHeading=False):
        """
        findMapObject(ArMapObjects self, char const * name, char const * type=None, bool isIncludeWithHeading=False) -> ArMapObject
        findMapObject(ArMapObjects self, char const * name, char const * type=None) -> ArMapObject
        findMapObject(ArMapObjects self, char const * name) -> ArMapObject
        """
        return _AriaPy.ArMapObjects_findMapObject(self, name, type, isIncludeWithHeading)


    def findMapObjectsOfType(self, type, isIncludeWithHeading=False):
        """
        findMapObjectsOfType(ArMapObjects self, char const * type, bool isIncludeWithHeading=False) -> ArMapObjectPtrList
        findMapObjectsOfType(ArMapObjects self, char const * type) -> ArMapObjectPtrList
        """
        return _AriaPy.ArMapObjects_findMapObjectsOfType(self, type, isIncludeWithHeading)


    def getMapObjects(self):
        """getMapObjects(ArMapObjects self) -> ArMapObjectPtrList"""
        return _AriaPy.ArMapObjects_getMapObjects(self)


    def setMapObjects(self, mapObjects, isSortedObjects=False, changeDetails=None):
        """
        setMapObjects(ArMapObjects self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False, ArMapChangeDetails * changeDetails=None)
        setMapObjects(ArMapObjects self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False)
        setMapObjects(ArMapObjects self, ArMapObjectPtrList mapObjects)
        """
        return _AriaPy.ArMapObjects_setMapObjects(self, mapObjects, isSortedObjects, changeDetails)


    def writeObjectListToFunctor(self, functor, endOfLineChars):
        """writeObjectListToFunctor(ArMapObjects self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMapObjects_writeObjectListToFunctor(self, functor, endOfLineChars)


    def clear(self):
        """clear(ArMapObjects self)"""
        return _AriaPy.ArMapObjects_clear(self)


    def addToFileParser(self, fileParser):
        """addToFileParser(ArMapObjects self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMapObjects_addToFileParser(self, fileParser)


    def remFromFileParser(self, fileParser):
        """remFromFileParser(ArMapObjects self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMapObjects_remFromFileParser(self, fileParser)


    def getTimeChanged(self):
        """getTimeChanged(ArMapObjects self) -> ArTime"""
        return _AriaPy.ArMapObjects_getTimeChanged(self)

ArMapObjects_swigregister = _AriaPy.ArMapObjects_swigregister
ArMapObjects_swigregister(ArMapObjects)

class ArMapInfo(ArMapInfoInterface):
    """Proxy of C++ ArMapInfo 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__(ArMapInfo self, char const ** infoNameList=None, size_t infoNameCount=0, char const * keywordPrefix=None) -> ArMapInfo
        __init__(ArMapInfo self, char const ** infoNameList=None, size_t infoNameCount=0) -> ArMapInfo
        __init__(ArMapInfo self, char const ** infoNameList=None) -> ArMapInfo
        __init__(ArMapInfo self) -> ArMapInfo
        __init__(ArMapInfo self, ArMapInfo other) -> ArMapInfo
        """
        this = _AriaPy.new_ArMapInfo(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMapInfo
    __del__ = lambda self: None

    def getInfo(self, *args):
        """
        getInfo(ArMapInfo self, char const * infoName) -> ArArgumentBuilderPtrList
        getInfo(ArMapInfo self, int infoType) -> ArArgumentBuilderPtrList
        """
        return _AriaPy.ArMapInfo_getInfo(self, *args)


    def getMapInfo(self):
        """getMapInfo(ArMapInfo self) -> ArArgumentBuilderPtrList"""
        return _AriaPy.ArMapInfo_getMapInfo(self)


    def getInfoCount(self):
        """getInfoCount(ArMapInfo self) -> int"""
        return _AriaPy.ArMapInfo_getInfoCount(self)


    def getInfoNames(self):
        """getInfoNames(ArMapInfo self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArMapInfo_getInfoNames(self)


    def setInfo(self, *args):
        """
        setInfo(ArMapInfo self, char const * infoName, ArArgumentBuilderPtrList infoList, ArMapChangeDetails * changeDetails) -> bool
        setInfo(ArMapInfo self, int infoType, ArArgumentBuilderPtrList infoList, ArMapChangeDetails * changeDetails=None) -> bool
        setInfo(ArMapInfo self, int infoType, ArArgumentBuilderPtrList infoList) -> bool
        """
        return _AriaPy.ArMapInfo_setInfo(self, *args)


    def setMapInfo(self, mapInfo, changeDetails=None):
        """
        setMapInfo(ArMapInfo self, ArArgumentBuilderPtrList mapInfo, ArMapChangeDetails * changeDetails=None) -> bool
        setMapInfo(ArMapInfo self, ArArgumentBuilderPtrList mapInfo) -> bool
        """
        return _AriaPy.ArMapInfo_setMapInfo(self, mapInfo, changeDetails)


    def getInfoName(self, infoType):
        """getInfoName(ArMapInfo self, int infoType) -> char const *"""
        return _AriaPy.ArMapInfo_getInfoName(self, infoType)


    def writeInfoToFunctor(self, functor, endOfLineChars):
        """writeInfoToFunctor(ArMapInfo self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMapInfo_writeInfoToFunctor(self, functor, endOfLineChars)


    def clear(self):
        """clear(ArMapInfo self)"""
        return _AriaPy.ArMapInfo_clear(self)


    def addToFileParser(self, fileParser):
        """addToFileParser(ArMapInfo self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMapInfo_addToFileParser(self, fileParser)


    def remFromFileParser(self, fileParser):
        """remFromFileParser(ArMapInfo self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMapInfo_remFromFileParser(self, fileParser)


    def getTimeChanged(self):
        """getTimeChanged(ArMapInfo self) -> ArTime"""
        return _AriaPy.ArMapInfo_getTimeChanged(self)

ArMapInfo_swigregister = _AriaPy.ArMapInfo_swigregister
ArMapInfo_swigregister(ArMapInfo)

class ArMapSupplement(ArMapSupplementInterface):
    """Proxy of C++ ArMapSupplement 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__(ArMapSupplement self) -> ArMapSupplement
        __init__(ArMapSupplement self, ArMapSupplement other) -> ArMapSupplement
        """
        this = _AriaPy.new_ArMapSupplement(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMapSupplement
    __del__ = lambda self: None

    def hasOriginLatLongAlt(self):
        """hasOriginLatLongAlt(ArMapSupplement self) -> bool"""
        return _AriaPy.ArMapSupplement_hasOriginLatLongAlt(self)


    def getOriginLatLong(self):
        """getOriginLatLong(ArMapSupplement self) -> ArPose"""
        return _AriaPy.ArMapSupplement_getOriginLatLong(self)


    def getOriginAltitude(self):
        """getOriginAltitude(ArMapSupplement self) -> double"""
        return _AriaPy.ArMapSupplement_getOriginAltitude(self)


    def setOriginLatLongAlt(self, hasOriginLatLong, originLatLong, altitude, changeDetails=None):
        """
        setOriginLatLongAlt(ArMapSupplement self, bool hasOriginLatLong, ArPose originLatLong, double altitude, ArMapChangeDetails * changeDetails=None)
        setOriginLatLongAlt(ArMapSupplement self, bool hasOriginLatLong, ArPose originLatLong, double altitude)
        """
        return _AriaPy.ArMapSupplement_setOriginLatLongAlt(self, hasOriginLatLong, originLatLong, altitude, changeDetails)


    def writeSupplementToFunctor(self, functor, endOfLineChars):
        """writeSupplementToFunctor(ArMapSupplement self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMapSupplement_writeSupplementToFunctor(self, functor, endOfLineChars)


    def clear(self):
        """clear(ArMapSupplement self)"""
        return _AriaPy.ArMapSupplement_clear(self)


    def addToFileParser(self, fileParser):
        """addToFileParser(ArMapSupplement self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMapSupplement_addToFileParser(self, fileParser)


    def remFromFileParser(self, fileParser):
        """remFromFileParser(ArMapSupplement self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMapSupplement_remFromFileParser(self, fileParser)


    def getTimeChanged(self):
        """getTimeChanged(ArMapSupplement self) -> ArTime"""
        return _AriaPy.ArMapSupplement_getTimeChanged(self)

ArMapSupplement_swigregister = _AriaPy.ArMapSupplement_swigregister
ArMapSupplement_swigregister(ArMapSupplement)

class ArDataTagCaseCmpOp(object):
    """Proxy of C++ ArDataTagCaseCmpOp class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __call__(self, s1, s2):
        """__call__(ArDataTagCaseCmpOp self, std::string const & s1, std::string const & s2) -> bool"""
        return _AriaPy.ArDataTagCaseCmpOp___call__(self, s1, s2)


    def __init__(self):
        """__init__(ArDataTagCaseCmpOp self) -> ArDataTagCaseCmpOp"""
        this = _AriaPy.new_ArDataTagCaseCmpOp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArDataTagCaseCmpOp
    __del__ = lambda self: None
ArDataTagCaseCmpOp_swigregister = _AriaPy.ArDataTagCaseCmpOp_swigregister
ArDataTagCaseCmpOp_swigregister(ArDataTagCaseCmpOp)

class ArMapSimple(ArMapInterface):
    """Proxy of C++ ArMapSimple 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__(ArMapSimple self, char const * baseDirectory, char const * tempDirectory=None, char const * overrideMutexName=None) -> ArMapSimple
        __init__(ArMapSimple self, char const * baseDirectory, char const * tempDirectory=None) -> ArMapSimple
        __init__(ArMapSimple self, char const * baseDirectory) -> ArMapSimple
        __init__(ArMapSimple self) -> ArMapSimple
        __init__(ArMapSimple self, ArMapSimple other) -> ArMapSimple
        """
        this = _AriaPy.new_ArMapSimple(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMapSimple
    __del__ = lambda self: None

    def clear(self):
        """clear(ArMapSimple self)"""
        return _AriaPy.ArMapSimple_clear(self)


    def set(self, other):
        """set(ArMapSimple self, ArMapInterface other) -> bool"""
        return _AriaPy.ArMapSimple_set(self, other)


    def clone(self):
        """clone(ArMapSimple self) -> ArMapInterface"""
        return _AriaPy.ArMapSimple_clone(self)


    def getScanTypes(self):
        """getScanTypes(ArMapSimple self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArMapSimple_getScanTypes(self)


    def setScanTypes(self, scanTypeList):
        """setScanTypes(ArMapSimple self, std::list< std::string,std::allocator< std::string > > const & scanTypeList) -> bool"""
        return _AriaPy.ArMapSimple_setScanTypes(self, scanTypeList)


    def lock(self):
        """lock(ArMapSimple self) -> int"""
        return _AriaPy.ArMapSimple_lock(self)


    def tryLock(self):
        """tryLock(ArMapSimple self) -> int"""
        return _AriaPy.ArMapSimple_tryLock(self)


    def unlock(self):
        """unlock(ArMapSimple self) -> int"""
        return _AriaPy.ArMapSimple_unlock(self)


    def getInfo(self, *args):
        """
        getInfo(ArMapSimple self, char const * infoName) -> ArArgumentBuilderPtrList
        getInfo(ArMapSimple self, int infoType) -> ArArgumentBuilderPtrList
        """
        return _AriaPy.ArMapSimple_getInfo(self, *args)


    def getMapInfo(self):
        """getMapInfo(ArMapSimple self) -> ArArgumentBuilderPtrList"""
        return _AriaPy.ArMapSimple_getMapInfo(self)


    def getInfoCount(self):
        """getInfoCount(ArMapSimple self) -> int"""
        return _AriaPy.ArMapSimple_getInfoCount(self)


    def getInfoNames(self):
        """getInfoNames(ArMapSimple self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArMapSimple_getInfoNames(self)


    def setInfo(self, *args):
        """
        setInfo(ArMapSimple self, char const * infoName, ArArgumentBuilderPtrList infoList, ArMapChangeDetails * changeDetails=None) -> bool
        setInfo(ArMapSimple self, char const * infoName, ArArgumentBuilderPtrList infoList) -> bool
        setInfo(ArMapSimple self, int infoType, ArArgumentBuilderPtrList infoList, ArMapChangeDetails * changeDetails=None) -> bool
        setInfo(ArMapSimple self, int infoType, ArArgumentBuilderPtrList infoList) -> bool
        """
        return _AriaPy.ArMapSimple_setInfo(self, *args)


    def setMapInfo(self, mapInfo, changeDetails=None):
        """
        setMapInfo(ArMapSimple self, ArArgumentBuilderPtrList mapInfo, ArMapChangeDetails * changeDetails=None) -> bool
        setMapInfo(ArMapSimple self, ArArgumentBuilderPtrList mapInfo) -> bool
        """
        return _AriaPy.ArMapSimple_setMapInfo(self, mapInfo, changeDetails)


    def writeInfoToFunctor(self, functor, endOfLineChars):
        """writeInfoToFunctor(ArMapSimple self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMapSimple_writeInfoToFunctor(self, functor, endOfLineChars)


    def getInfoName(self, infoType):
        """getInfoName(ArMapSimple self, int infoType) -> char const *"""
        return _AriaPy.ArMapSimple_getInfoName(self, infoType)


    def findFirstMapObject(self, name, type, isIncludeWithHeading=False):
        """
        findFirstMapObject(ArMapSimple self, char const * name, char const * type, bool isIncludeWithHeading=False) -> ArMapObject
        findFirstMapObject(ArMapSimple self, char const * name, char const * type) -> ArMapObject
        """
        return _AriaPy.ArMapSimple_findFirstMapObject(self, name, type, isIncludeWithHeading)


    def findMapObject(self, name, type=None, isIncludeWithHeading=False):
        """
        findMapObject(ArMapSimple self, char const * name, char const * type=None, bool isIncludeWithHeading=False) -> ArMapObject
        findMapObject(ArMapSimple self, char const * name, char const * type=None) -> ArMapObject
        findMapObject(ArMapSimple self, char const * name) -> ArMapObject
        """
        return _AriaPy.ArMapSimple_findMapObject(self, name, type, isIncludeWithHeading)


    def findMapObjectsOfType(self, type, isIncludeWithHeading=False):
        """
        findMapObjectsOfType(ArMapSimple self, char const * type, bool isIncludeWithHeading=False) -> ArMapObjectPtrList
        findMapObjectsOfType(ArMapSimple self, char const * type) -> ArMapObjectPtrList
        """
        return _AriaPy.ArMapSimple_findMapObjectsOfType(self, type, isIncludeWithHeading)


    def getMapObjects(self):
        """getMapObjects(ArMapSimple self) -> ArMapObjectPtrList"""
        return _AriaPy.ArMapSimple_getMapObjects(self)


    def setMapObjects(self, mapObjects, isSortedObjects=False, changeDetails=None):
        """
        setMapObjects(ArMapSimple self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False, ArMapChangeDetails * changeDetails=None)
        setMapObjects(ArMapSimple self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False)
        setMapObjects(ArMapSimple self, ArMapObjectPtrList mapObjects)
        """
        return _AriaPy.ArMapSimple_setMapObjects(self, mapObjects, isSortedObjects, changeDetails)


    def writeObjectListToFunctor(self, functor, endOfLineChars):
        """writeObjectListToFunctor(ArMapSimple self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMapSimple_writeObjectListToFunctor(self, functor, endOfLineChars)


    def hasOriginLatLongAlt(self):
        """hasOriginLatLongAlt(ArMapSimple self) -> bool"""
        return _AriaPy.ArMapSimple_hasOriginLatLongAlt(self)


    def getOriginLatLong(self):
        """getOriginLatLong(ArMapSimple self) -> ArPose"""
        return _AriaPy.ArMapSimple_getOriginLatLong(self)


    def getOriginAltitude(self):
        """getOriginAltitude(ArMapSimple self) -> double"""
        return _AriaPy.ArMapSimple_getOriginAltitude(self)


    def setOriginLatLongAlt(self, hasOriginLatLong, originLatLong, altitude, changeDetails=None):
        """
        setOriginLatLongAlt(ArMapSimple self, bool hasOriginLatLong, ArPose originLatLong, double altitude, ArMapChangeDetails * changeDetails=None)
        setOriginLatLongAlt(ArMapSimple self, bool hasOriginLatLong, ArPose originLatLong, double altitude)
        """
        return _AriaPy.ArMapSimple_setOriginLatLongAlt(self, hasOriginLatLong, originLatLong, altitude, changeDetails)


    def writeSupplementToFunctor(self, functor, endOfLineChars):
        """writeSupplementToFunctor(ArMapSimple self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMapSimple_writeSupplementToFunctor(self, functor, endOfLineChars)


    def getDisplayString(self, *args):
        """
        getDisplayString(ArMapSimple self, char const * scanType) -> char const
        getDisplayString(ArMapSimple self) -> char const *
        """
        return _AriaPy.ArMapSimple_getDisplayString(self, *args)


    def getPoints(self, *args):
        """
        getPoints(ArMapSimple self, char const * scanType) -> std::vector< ArPose,std::allocator< ArPose > >
        getPoints(ArMapSimple self) -> std::vector< ArPose,std::allocator< ArPose > > *
        """
        return _AriaPy.ArMapSimple_getPoints(self, *args)


    def getMinPose(self, *args):
        """
        getMinPose(ArMapSimple self, char const * scanType) -> ArPose
        getMinPose(ArMapSimple self) -> ArPose
        """
        return _AriaPy.ArMapSimple_getMinPose(self, *args)


    def getMaxPose(self, *args):
        """
        getMaxPose(ArMapSimple self, char const * scanType) -> ArPose
        getMaxPose(ArMapSimple self) -> ArPose
        """
        return _AriaPy.ArMapSimple_getMaxPose(self, *args)


    def getNumPoints(self, *args):
        """
        getNumPoints(ArMapSimple self, char const * scanType) -> int
        getNumPoints(ArMapSimple self) -> int
        """
        return _AriaPy.ArMapSimple_getNumPoints(self, *args)


    def isSortedPoints(self, *args):
        """
        isSortedPoints(ArMapSimple self, char const * scanType) -> bool
        isSortedPoints(ArMapSimple self) -> bool
        """
        return _AriaPy.ArMapSimple_isSortedPoints(self, *args)


    def setPoints(self, *args):
        """
        setPoints(ArMapSimple self, std::vector< ArPose,std::allocator< ArPose > > const * points, char const * scanType, bool isSortedPoints=False, ArMapChangeDetails * changeDetails=None)
        setPoints(ArMapSimple self, std::vector< ArPose,std::allocator< ArPose > > const * points, char const * scanType, bool isSortedPoints=False)
        setPoints(ArMapSimple self, std::vector< ArPose,std::allocator< ArPose > > const * points, char const * scanType)
        setPoints(ArMapSimple self, std::vector< ArPose,std::allocator< ArPose > > const * points)
        """
        return _AriaPy.ArMapSimple_setPoints(self, *args)


    def getLines(self, *args):
        """
        getLines(ArMapSimple self, char const * scanType) -> std::vector< ArLineSegment,std::allocator< ArLineSegment > >
        getLines(ArMapSimple self) -> std::vector< ArLineSegment,std::allocator< ArLineSegment > > *
        """
        return _AriaPy.ArMapSimple_getLines(self, *args)


    def getLineMinPose(self, *args):
        """
        getLineMinPose(ArMapSimple self, char const * scanType) -> ArPose
        getLineMinPose(ArMapSimple self) -> ArPose
        """
        return _AriaPy.ArMapSimple_getLineMinPose(self, *args)


    def getLineMaxPose(self, *args):
        """
        getLineMaxPose(ArMapSimple self, char const * scanType) -> ArPose
        getLineMaxPose(ArMapSimple self) -> ArPose
        """
        return _AriaPy.ArMapSimple_getLineMaxPose(self, *args)


    def getNumLines(self, *args):
        """
        getNumLines(ArMapSimple self, char const * scanType) -> int
        getNumLines(ArMapSimple self) -> int
        """
        return _AriaPy.ArMapSimple_getNumLines(self, *args)


    def isSortedLines(self, *args):
        """
        isSortedLines(ArMapSimple self, char const * scanType) -> bool
        isSortedLines(ArMapSimple self) -> bool
        """
        return _AriaPy.ArMapSimple_isSortedLines(self, *args)


    def setLines(self, *args):
        """
        setLines(ArMapSimple self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines, char const * scanType, bool isSortedLines=False, ArMapChangeDetails * changeDetails=None)
        setLines(ArMapSimple self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines, char const * scanType, bool isSortedLines=False)
        setLines(ArMapSimple self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines, char const * scanType)
        setLines(ArMapSimple self, std::vector< ArLineSegment,std::allocator< ArLineSegment > > const * lines)
        """
        return _AriaPy.ArMapSimple_setLines(self, *args)


    def getResolution(self, *args):
        """
        getResolution(ArMapSimple self, char const * scanType) -> int
        getResolution(ArMapSimple self) -> int
        """
        return _AriaPy.ArMapSimple_getResolution(self, *args)


    def setResolution(self, *args):
        """
        setResolution(ArMapSimple self, int resolution, char const * scanType, ArMapChangeDetails * changeDetails=None)
        setResolution(ArMapSimple self, int resolution, char const * scanType)
        setResolution(ArMapSimple self, int resolution)
        """
        return _AriaPy.ArMapSimple_setResolution(self, *args)


    def writeScanToFunctor(self, *args):
        """
        writeScanToFunctor(ArMapSimple self, ArFunctor1_CString functor, char const * endOfLineChars, char const * scanType)
        writeScanToFunctor(ArMapSimple self, ArFunctor1_CString functor, char const * endOfLineChars)
        """
        return _AriaPy.ArMapSimple_writeScanToFunctor(self, *args)


    def writePointsToFunctor(self, *args):
        """
        writePointsToFunctor(ArMapSimple self, ArFunctor2< int,std::vector< ArPose,std::allocator< ArPose > > * > * functor, char const * scanType, ArFunctor1_CString keywordFunctor=None)
        writePointsToFunctor(ArMapSimple self, ArFunctor2< int,std::vector< ArPose,std::allocator< ArPose > > * > * functor, char const * scanType)
        writePointsToFunctor(ArMapSimple self, ArFunctor2< int,std::vector< ArPose,std::allocator< ArPose > > * > * functor)
        """
        return _AriaPy.ArMapSimple_writePointsToFunctor(self, *args)


    def writeLinesToFunctor(self, *args):
        """
        writeLinesToFunctor(ArMapSimple self, ArFunctor2< int,std::vector< ArLineSegment,std::allocator< ArLineSegment > > * > * functor, char const * scanType, ArFunctor1_CString keywordFunctor=None)
        writeLinesToFunctor(ArMapSimple self, ArFunctor2< int,std::vector< ArLineSegment,std::allocator< ArLineSegment > > * > * functor, char const * scanType)
        writeLinesToFunctor(ArMapSimple self, ArFunctor2< int,std::vector< ArLineSegment,std::allocator< ArLineSegment > > * > * functor)
        """
        return _AriaPy.ArMapSimple_writeLinesToFunctor(self, *args)


    def addToFileParser(self, fileParser):
        """addToFileParser(ArMapSimple self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMapSimple_addToFileParser(self, fileParser)


    def remFromFileParser(self, fileParser):
        """remFromFileParser(ArMapSimple self, ArFileParser fileParser) -> bool"""
        return _AriaPy.ArMapSimple_remFromFileParser(self, fileParser)


    def readDataPoint(self, line):
        """readDataPoint(ArMapSimple self, char * line) -> bool"""
        return _AriaPy.ArMapSimple_readDataPoint(self, line)


    def readLineSegment(self, line):
        """readLineSegment(ArMapSimple self, char * line) -> bool"""
        return _AriaPy.ArMapSimple_readLineSegment(self, line)


    def loadDataPoint(self, x, y):
        """loadDataPoint(ArMapSimple self, double x, double y)"""
        return _AriaPy.ArMapSimple_loadDataPoint(self, x, y)


    def loadLineSegment(self, x1, y1, x2, y2):
        """loadLineSegment(ArMapSimple self, double x1, double y1, double x2, double y2)"""
        return _AriaPy.ArMapSimple_loadLineSegment(self, x1, y1, x2, y2)


    def mapChanged(self):
        """mapChanged(ArMapSimple self)"""
        return _AriaPy.ArMapSimple_mapChanged(self)


    def addMapChangedCB(self, functor, position=50):
        """
        addMapChangedCB(ArMapSimple self, ArFunctor functor, int position=50)
        addMapChangedCB(ArMapSimple self, ArFunctor functor)
        """
        return _AriaPy.ArMapSimple_addMapChangedCB(self, functor, position)


    def remMapChangedCB(self, functor):
        """remMapChangedCB(ArMapSimple self, ArFunctor functor)"""
        return _AriaPy.ArMapSimple_remMapChangedCB(self, functor)


    def addPreMapChangedCB(self, functor, position=50):
        """
        addPreMapChangedCB(ArMapSimple self, ArFunctor functor, int position=50)
        addPreMapChangedCB(ArMapSimple self, ArFunctor functor)
        """
        return _AriaPy.ArMapSimple_addPreMapChangedCB(self, functor, position)


    def remPreMapChangedCB(self, functor):
        """remPreMapChangedCB(ArMapSimple self, ArFunctor functor)"""
        return _AriaPy.ArMapSimple_remPreMapChangedCB(self, functor)


    def setMapChangedLogLevel(self, level):
        """setMapChangedLogLevel(ArMapSimple self, ArLog::LogLevel level)"""
        return _AriaPy.ArMapSimple_setMapChangedLogLevel(self, level)


    def getMapChangedLogLevel(self):
        """getMapChangedLogLevel(ArMapSimple self) -> ArLog::LogLevel"""
        return _AriaPy.ArMapSimple_getMapChangedLogLevel(self)


    def writeToFunctor(self, functor, endOfLineChars):
        """writeToFunctor(ArMapSimple self, ArFunctor1_CString functor, char const * endOfLineChars)"""
        return _AriaPy.ArMapSimple_writeToFunctor(self, functor, endOfLineChars)


    def writeObjectsToFunctor(self, functor, endOfLineChars, isOverrideAsSingleScan=False, maxCategory=None):
        """
        writeObjectsToFunctor(ArMapSimple self, ArFunctor1_CString functor, char const * endOfLineChars, bool isOverrideAsSingleScan=False, char const * maxCategory=None)
        writeObjectsToFunctor(ArMapSimple self, ArFunctor1_CString functor, char const * endOfLineChars, bool isOverrideAsSingleScan=False)
        writeObjectsToFunctor(ArMapSimple self, ArFunctor1_CString functor, char const * endOfLineChars)
        """
        return _AriaPy.ArMapSimple_writeObjectsToFunctor(self, functor, endOfLineChars, isOverrideAsSingleScan, maxCategory)


    def addPreWriteFileCB(self, *args):
        """
        addPreWriteFileCB(ArMapSimple self, ArFunctor functor, ArListPos::Pos position)
        addPreWriteFileCB(ArMapSimple self, ArFunctor functor)
        """
        return _AriaPy.ArMapSimple_addPreWriteFileCB(self, *args)


    def remPreWriteFileCB(self, functor):
        """remPreWriteFileCB(ArMapSimple self, ArFunctor functor)"""
        return _AriaPy.ArMapSimple_remPreWriteFileCB(self, functor)


    def addPostWriteFileCB(self, *args):
        """
        addPostWriteFileCB(ArMapSimple self, ArFunctor functor, ArListPos::Pos position)
        addPostWriteFileCB(ArMapSimple self, ArFunctor functor)
        """
        return _AriaPy.ArMapSimple_addPostWriteFileCB(self, *args)


    def remPostWriteFileCB(self, functor):
        """remPostWriteFileCB(ArMapSimple self, ArFunctor functor)"""
        return _AriaPy.ArMapSimple_remPostWriteFileCB(self, functor)


    def readFile(self, fileName, errorBuffer=None, errorBufferLen=0, md5DigestBuffer=None, md5DigestBufferLen=0):
        """
        readFile(ArMapSimple self, char const * fileName, char * errorBuffer=None, size_t errorBufferLen=0, unsigned char * md5DigestBuffer=None, size_t md5DigestBufferLen=0) -> bool
        readFile(ArMapSimple self, char const * fileName, char * errorBuffer=None, size_t errorBufferLen=0, unsigned char * md5DigestBuffer=None) -> bool
        readFile(ArMapSimple self, char const * fileName, char * errorBuffer=None, size_t errorBufferLen=0) -> bool
        readFile(ArMapSimple self, char const * fileName, char * errorBuffer=None) -> bool
        readFile(ArMapSimple self, char const * fileName) -> bool
        """
        return _AriaPy.ArMapSimple_readFile(self, fileName, errorBuffer, errorBufferLen, md5DigestBuffer, md5DigestBufferLen)


    def writeFile(self, fileName, internalCall=False, md5DigestBuffer=None, md5DigestBufferLen=0, fileTimestamp=-1):
        """
        writeFile(ArMapSimple self, char const * fileName, bool internalCall=False, unsigned char * md5DigestBuffer=None, size_t md5DigestBufferLen=0, time_t fileTimestamp=-1) -> bool
        writeFile(ArMapSimple self, char const * fileName, bool internalCall=False, unsigned char * md5DigestBuffer=None, size_t md5DigestBufferLen=0) -> bool
        writeFile(ArMapSimple self, char const * fileName, bool internalCall=False, unsigned char * md5DigestBuffer=None) -> bool
        writeFile(ArMapSimple self, char const * fileName, bool internalCall=False) -> bool
        writeFile(ArMapSimple self, char const * fileName) -> bool
        """
        return _AriaPy.ArMapSimple_writeFile(self, fileName, internalCall, md5DigestBuffer, md5DigestBufferLen, fileTimestamp)


    def getMapId(self, mapIdOut, isInternalCall=False):
        """
        getMapId(ArMapSimple self, ArMapId mapIdOut, bool isInternalCall=False) -> bool
        getMapId(ArMapSimple self, ArMapId mapIdOut) -> bool
        """
        return _AriaPy.ArMapSimple_getMapId(self, mapIdOut, isInternalCall)


    def calculateChecksum(self, md5DigestBuffer, md5DigestBufferLen):
        """calculateChecksum(ArMapSimple self, unsigned char * md5DigestBuffer, size_t md5DigestBufferLen) -> bool"""
        return _AriaPy.ArMapSimple_calculateChecksum(self, md5DigestBuffer, md5DigestBufferLen)


    def getBaseDirectory(self):
        """getBaseDirectory(ArMapSimple self) -> char const *"""
        return _AriaPy.ArMapSimple_getBaseDirectory(self)


    def setBaseDirectory(self, baseDirectory):
        """setBaseDirectory(ArMapSimple self, char const * baseDirectory)"""
        return _AriaPy.ArMapSimple_setBaseDirectory(self, baseDirectory)


    def getTempDirectory(self):
        """getTempDirectory(ArMapSimple self) -> char const *"""
        return _AriaPy.ArMapSimple_getTempDirectory(self)


    def setTempDirectory(self, tempDirectory):
        """setTempDirectory(ArMapSimple self, char const * tempDirectory)"""
        return _AriaPy.ArMapSimple_setTempDirectory(self, tempDirectory)


    def createRealFileName(self, fileName):
        """createRealFileName(ArMapSimple self, char const * fileName) -> std::string"""
        return _AriaPy.ArMapSimple_createRealFileName(self, fileName)


    def getFileName(self):
        """getFileName(ArMapSimple self) -> char const *"""
        return _AriaPy.ArMapSimple_getFileName(self)


    def setSourceFileName(self, sourceName, fileName, isInternalCall=False):
        """
        setSourceFileName(ArMapSimple self, char const * sourceName, char const * fileName, bool isInternalCall=False)
        setSourceFileName(ArMapSimple self, char const * sourceName, char const * fileName)
        """
        return _AriaPy.ArMapSimple_setSourceFileName(self, sourceName, fileName, isInternalCall)


    def refresh(self):
        """refresh(ArMapSimple self) -> bool"""
        return _AriaPy.ArMapSimple_refresh(self)


    def setIgnoreEmptyFileName(self, ignore):
        """setIgnoreEmptyFileName(ArMapSimple self, bool ignore)"""
        return _AriaPy.ArMapSimple_setIgnoreEmptyFileName(self, ignore)


    def getIgnoreEmptyFileName(self):
        """getIgnoreEmptyFileName(ArMapSimple self) -> bool"""
        return _AriaPy.ArMapSimple_getIgnoreEmptyFileName(self)


    def setIgnoreCase(self, ignoreCase=False):
        """
        setIgnoreCase(ArMapSimple self, bool ignoreCase=False)
        setIgnoreCase(ArMapSimple self)
        """
        return _AriaPy.ArMapSimple_setIgnoreCase(self, ignoreCase)


    def getIgnoreCase(self):
        """getIgnoreCase(ArMapSimple self) -> bool"""
        return _AriaPy.ArMapSimple_getIgnoreCase(self)


    def getInactiveInfo(self):
        """getInactiveInfo(ArMapSimple self) -> ArMapInfoInterface"""
        return _AriaPy.ArMapSimple_getInactiveInfo(self)


    def getInactiveObjects(self):
        """getInactiveObjects(ArMapSimple self) -> ArMapObjectsInterface"""
        return _AriaPy.ArMapSimple_getInactiveObjects(self)


    def getChildObjects(self):
        """getChildObjects(ArMapSimple self) -> ArMapObjectsInterface"""
        return _AriaPy.ArMapSimple_getChildObjects(self)


    def findMapObjectParams(self, mapObjectName):
        """findMapObjectParams(ArMapSimple self, char const * mapObjectName) -> ArArgumentBuilder"""
        return _AriaPy.ArMapSimple_findMapObjectParams(self, mapObjectName)


    def setMapObjectParams(self, mapObjectName, params, changeDetails=None):
        """
        setMapObjectParams(ArMapSimple self, char const * mapObjectName, ArArgumentBuilder params, ArMapChangeDetails * changeDetails=None) -> bool
        setMapObjectParams(ArMapSimple self, char const * mapObjectName, ArArgumentBuilder params) -> bool
        """
        return _AriaPy.ArMapSimple_setMapObjectParams(self, mapObjectName, params, changeDetails)


    def getRemainder(self):
        """getRemainder(ArMapSimple self) -> ArArgumentBuilderPtrList"""
        return _AriaPy.ArMapSimple_getRemainder(self)


    def setQuiet(self, isQuiet):
        """setQuiet(ArMapSimple self, bool isQuiet)"""
        return _AriaPy.ArMapSimple_setQuiet(self, isQuiet)


    def parseLine(self, line):
        """parseLine(ArMapSimple self, char * line) -> bool"""
        return _AriaPy.ArMapSimple_parseLine(self, line)


    def parsingComplete(self):
        """parsingComplete(ArMapSimple self)"""
        return _AriaPy.ArMapSimple_parsingComplete(self)


    def isLoadingDataStarted(self):
        """isLoadingDataStarted(ArMapSimple self) -> bool"""
        return _AriaPy.ArMapSimple_isLoadingDataStarted(self)


    def isLoadingLinesAndDataStarted(self):
        """isLoadingLinesAndDataStarted(ArMapSimple self) -> bool"""
        return _AriaPy.ArMapSimple_isLoadingLinesAndDataStarted(self)


    def findMapObjectParamInfo(mapObjectName, cairnInfoList):
        """findMapObjectParamInfo(char const * mapObjectName, ArArgumentBuilderPtrList cairnInfoList) -> std::list< ArArgumentBuilder *,std::allocator< ArArgumentBuilder * > >::iterator"""
        return _AriaPy.ArMapSimple_findMapObjectParamInfo(mapObjectName, cairnInfoList)

    findMapObjectParamInfo = staticmethod(findMapObjectParamInfo)
ArMapSimple_swigregister = _AriaPy.ArMapSimple_swigregister
ArMapSimple_swigregister(ArMapSimple)

def ArMapSimple_findMapObjectParamInfo(mapObjectName, cairnInfoList):
    """ArMapSimple_findMapObjectParamInfo(char const * mapObjectName, ArArgumentBuilderPtrList cairnInfoList) -> std::list< ArArgumentBuilder *,std::allocator< ArArgumentBuilder * > >::iterator"""
    return _AriaPy.ArMapSimple_findMapObjectParamInfo(mapObjectName, cairnInfoList)

class ArMapObject(object):
    """Proxy of C++ ArMapObject class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def createMapObject(arg):
        """createMapObject(ArArgumentBuilder arg) -> ArMapObject"""
        return _AriaPy.ArMapObject_createMapObject(arg)

    createMapObject = staticmethod(createMapObject)
    TYPE_ARG_INDEX = _AriaPy.ArMapObject_TYPE_ARG_INDEX
    POSE_X_ARG_INDEX = _AriaPy.ArMapObject_POSE_X_ARG_INDEX
    POSE_Y_ARG_INDEX = _AriaPy.ArMapObject_POSE_Y_ARG_INDEX
    TH_ARG_INDEX = _AriaPy.ArMapObject_TH_ARG_INDEX
    DESC_ARG_INDEX = _AriaPy.ArMapObject_DESC_ARG_INDEX
    ICON_ARG_INDEX = _AriaPy.ArMapObject_ICON_ARG_INDEX
    NAME_ARG_INDEX = _AriaPy.ArMapObject_NAME_ARG_INDEX
    LAST_POSE_ARG_INDEX = _AriaPy.ArMapObject_LAST_POSE_ARG_INDEX
    FROM_X_ARG_INDEX = _AriaPy.ArMapObject_FROM_X_ARG_INDEX
    FROM_Y_ARG_INDEX = _AriaPy.ArMapObject_FROM_Y_ARG_INDEX
    TO_X_ARG_INDEX = _AriaPy.ArMapObject_TO_X_ARG_INDEX
    TO_Y_ARG_INDEX = _AriaPy.ArMapObject_TO_Y_ARG_INDEX
    LAST_ARG_INDEX = _AriaPy.ArMapObject_LAST_ARG_INDEX
    ARG_INDEX_COUNT = _AriaPy.ArMapObject_ARG_INDEX_COUNT

    def __init__(self, *args):
        """
        __init__(ArMapObject self, char const * type, ArPose pose, char const * description, char const * iconName, char const * name, bool hasFromTo, ArPose fromPose, ArPose toPose) -> ArMapObject
        __init__(ArMapObject self, ArMapObject mapObject) -> ArMapObject
        """
        this = _AriaPy.new_ArMapObject(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMapObject
    __del__ = lambda self: None

    def getType(self):
        """getType(ArMapObject self) -> char const *"""
        return _AriaPy.ArMapObject_getType(self)


    def getBaseType(self):
        """getBaseType(ArMapObject self) -> char const *"""
        return _AriaPy.ArMapObject_getBaseType(self)


    def getName(self):
        """getName(ArMapObject self) -> char const *"""
        return _AriaPy.ArMapObject_getName(self)


    def getDescription(self):
        """getDescription(ArMapObject self) -> char const *"""
        return _AriaPy.ArMapObject_getDescription(self)


    def getIconName(self):
        """getIconName(ArMapObject self) -> char const *"""
        return _AriaPy.ArMapObject_getIconName(self)


    def getId(self):
        """getId(ArMapObject self) -> int"""
        return _AriaPy.ArMapObject_getId(self)


    def setDescription(self, description):
        """setDescription(ArMapObject self, char const * description)"""
        return _AriaPy.ArMapObject_setDescription(self, description)


    def getPose(self):
        """getPose(ArMapObject self) -> ArPose"""
        return _AriaPy.ArMapObject_getPose(self)


    def hasFromTo(self):
        """hasFromTo(ArMapObject self) -> bool"""
        return _AriaPy.ArMapObject_hasFromTo(self)


    def getFromPose(self):
        """getFromPose(ArMapObject self) -> ArPose"""
        return _AriaPy.ArMapObject_getFromPose(self)


    def getToPose(self):
        """getToPose(ArMapObject self) -> ArPose"""
        return _AriaPy.ArMapObject_getToPose(self)


    def getFromToRotation(self):
        """getFromToRotation(ArMapObject self) -> double"""
        return _AriaPy.ArMapObject_getFromToRotation(self)


    def getFromToSegments(self):
        """getFromToSegments(ArMapObject self) -> ArLineSegmentList"""
        return _AriaPy.ArMapObject_getFromToSegments(self)


    def getFromToSegment(self):
        """getFromToSegment(ArMapObject self) -> ArLineSegment"""
        return _AriaPy.ArMapObject_getFromToSegment(self)


    def findCenter(self):
        """findCenter(ArMapObject self) -> ArPose"""
        return _AriaPy.ArMapObject_findCenter(self)


    def toString(self):
        """toString(ArMapObject self) -> char const *"""
        return _AriaPy.ArMapObject_toString(self)


    def getStringRepresentation(self):
        """getStringRepresentation(ArMapObject self) -> char const *"""
        return _AriaPy.ArMapObject_getStringRepresentation(self)


    def log(self, intro=None):
        """
        log(ArMapObject self, char const * intro=None)
        log(ArMapObject self)
        """
        return _AriaPy.ArMapObject_log(self, intro)


    def __lt__(self, other):
        """__lt__(ArMapObject self, ArMapObject other) -> bool"""
        return _AriaPy.ArMapObject___lt__(self, other)


    def getFileName(self):
        """getFileName(ArMapObject self) -> char const *"""
        return _AriaPy.ArMapObject_getFileName(self)

ArMapObject_swigregister = _AriaPy.ArMapObject_swigregister
ArMapObject_swigregister(ArMapObject)

def ArMapObject_createMapObject(arg):
    """ArMapObject_createMapObject(ArArgumentBuilder arg) -> ArMapObject"""
    return _AriaPy.ArMapObject_createMapObject(arg)

class ArMapId(object):
    """Proxy of C++ ArMapId class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def create(fileName, mapIdOut):
        """create(char const * fileName, ArMapId mapIdOut) -> bool"""
        return _AriaPy.ArMapId_create(fileName, mapIdOut)

    create = staticmethod(create)

    def toPacket(mapId, packetOut):
        """toPacket(ArMapId mapId, ArBasePacket packetOut) -> bool"""
        return _AriaPy.ArMapId_toPacket(mapId, packetOut)

    toPacket = staticmethod(toPacket)

    def fromPacket(packetIn, mapIdOut):
        """fromPacket(ArBasePacket packetIn, ArMapId mapIdOut) -> bool"""
        return _AriaPy.ArMapId_fromPacket(packetIn, mapIdOut)

    fromPacket = staticmethod(fromPacket)

    def __init__(self, *args):
        """
        __init__(ArMapId self) -> ArMapId
        __init__(ArMapId self, char const * sourceName, char const * fileName, unsigned char const * checksum, size_t checksumLength, long size, time_t const timestamp) -> ArMapId
        __init__(ArMapId self, ArMapId other) -> ArMapId
        """
        this = _AriaPy.new_ArMapId(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMapId
    __del__ = lambda self: None

    def isNull(self):
        """isNull(ArMapId self) -> bool"""
        return _AriaPy.ArMapId_isNull(self)


    def getSourceName(self):
        """getSourceName(ArMapId self) -> char const *"""
        return _AriaPy.ArMapId_getSourceName(self)


    def getFileName(self):
        """getFileName(ArMapId self) -> char const *"""
        return _AriaPy.ArMapId_getFileName(self)


    def getChecksum(self):
        """getChecksum(ArMapId self) -> unsigned char const *"""
        return _AriaPy.ArMapId_getChecksum(self)


    def getChecksumLength(self):
        """getChecksumLength(ArMapId self) -> size_t"""
        return _AriaPy.ArMapId_getChecksumLength(self)


    def getDisplayChecksum(self):
        """getDisplayChecksum(ArMapId self) -> char const *"""
        return _AriaPy.ArMapId_getDisplayChecksum(self)


    def getSize(self):
        """getSize(ArMapId self) -> long"""
        return _AriaPy.ArMapId_getSize(self)


    def getTimestamp(self):
        """getTimestamp(ArMapId self) -> time_t"""
        return _AriaPy.ArMapId_getTimestamp(self)


    def clear(self):
        """clear(ArMapId self)"""
        return _AriaPy.ArMapId_clear(self)


    def setSourceName(self, sourceName):
        """setSourceName(ArMapId self, char const * sourceName)"""
        return _AriaPy.ArMapId_setSourceName(self, sourceName)


    def setFileName(self, fileName):
        """setFileName(ArMapId self, char const * fileName)"""
        return _AriaPy.ArMapId_setFileName(self, fileName)


    def setChecksum(self, checksum, checksumLen):
        """setChecksum(ArMapId self, unsigned char const * checksum, size_t checksumLen)"""
        return _AriaPy.ArMapId_setChecksum(self, checksum, checksumLen)


    def setSize(self, size):
        """setSize(ArMapId self, long size)"""
        return _AriaPy.ArMapId_setSize(self, size)


    def setTimestamp(self, timestamp):
        """setTimestamp(ArMapId self, time_t const & timestamp)"""
        return _AriaPy.ArMapId_setTimestamp(self, timestamp)


    def isSameFile(self, other):
        """isSameFile(ArMapId self, ArMapId other) -> bool"""
        return _AriaPy.ArMapId_isSameFile(self, other)


    def isVersionOfSameFile(self, other):
        """isVersionOfSameFile(ArMapId self, ArMapId other) -> bool"""
        return _AriaPy.ArMapId_isVersionOfSameFile(self, other)


    def isValidTimestamp(self):
        """isValidTimestamp(ArMapId self) -> bool"""
        return _AriaPy.ArMapId_isValidTimestamp(self)


    def log(self, prefix):
        """log(ArMapId self, char const * prefix)"""
        return _AriaPy.ArMapId_log(self, prefix)

ArMapId_swigregister = _AriaPy.ArMapId_swigregister
ArMapId_swigregister(ArMapId)

def ArMapId_create(fileName, mapIdOut):
    """ArMapId_create(char const * fileName, ArMapId mapIdOut) -> bool"""
    return _AriaPy.ArMapId_create(fileName, mapIdOut)

def ArMapId_toPacket(mapId, packetOut):
    """ArMapId_toPacket(ArMapId mapId, ArBasePacket packetOut) -> bool"""
    return _AriaPy.ArMapId_toPacket(mapId, packetOut)

def ArMapId_fromPacket(packetIn, mapIdOut):
    """ArMapId_fromPacket(ArBasePacket packetIn, ArMapId mapIdOut) -> bool"""
    return _AriaPy.ArMapId_fromPacket(packetIn, mapIdOut)

class ArMode(object):
    """Proxy of C++ ArMode 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__ = _AriaPy.delete_ArMode
    __del__ = lambda self: None

    def getName(self):
        """getName(ArMode self) -> char const *"""
        return _AriaPy.ArMode_getName(self)


    def activate(self):
        """activate(ArMode self)"""
        return _AriaPy.ArMode_activate(self)


    def deactivate(self):
        """deactivate(ArMode self)"""
        return _AriaPy.ArMode_deactivate(self)


    def userTask(self):
        """userTask(ArMode self)"""
        return _AriaPy.ArMode_userTask(self)


    def help(self):
        """help(ArMode self)"""
        return _AriaPy.ArMode_help(self)


    def baseActivate(self):
        """baseActivate(ArMode self) -> bool"""
        return _AriaPy.ArMode_baseActivate(self)


    def baseDeactivate(self):
        """baseDeactivate(ArMode self) -> bool"""
        return _AriaPy.ArMode_baseDeactivate(self)


    def baseHelp():
        """baseHelp()"""
        return _AriaPy.ArMode_baseHelp()

    baseHelp = staticmethod(baseHelp)

    def getKey(self):
        """getKey(ArMode self) -> char"""
        return _AriaPy.ArMode_getKey(self)


    def getKey2(self):
        """getKey2(ArMode self) -> char"""
        return _AriaPy.ArMode_getKey2(self)

ArMode_swigregister = _AriaPy.ArMode_swigregister
ArMode_swigregister(ArMode)

def ArMode_baseHelp():
    """ArMode_baseHelp()"""
    return _AriaPy.ArMode_baseHelp()

class ArModeTeleop(ArMode):
    """Proxy of C++ ArModeTeleop 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, robot, name, key, key2):
        """__init__(ArModeTeleop self, ArRobot robot, char const * name, char key, char key2) -> ArModeTeleop"""
        this = _AriaPy.new_ArModeTeleop(robot, name, key, key2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeTeleop
    __del__ = lambda self: None

    def activate(self):
        """activate(ArModeTeleop self)"""
        return _AriaPy.ArModeTeleop_activate(self)


    def deactivate(self):
        """deactivate(ArModeTeleop self)"""
        return _AriaPy.ArModeTeleop_deactivate(self)


    def help(self):
        """help(ArModeTeleop self)"""
        return _AriaPy.ArModeTeleop_help(self)


    def userTask(self):
        """userTask(ArModeTeleop self)"""
        return _AriaPy.ArModeTeleop_userTask(self)

ArModeTeleop_swigregister = _AriaPy.ArModeTeleop_swigregister
ArModeTeleop_swigregister(ArModeTeleop)

class ArModeUnguardedTeleop(ArMode):
    """Proxy of C++ ArModeUnguardedTeleop 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, robot, name, key, key2):
        """__init__(ArModeUnguardedTeleop self, ArRobot robot, char const * name, char key, char key2) -> ArModeUnguardedTeleop"""
        this = _AriaPy.new_ArModeUnguardedTeleop(robot, name, key, key2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeUnguardedTeleop
    __del__ = lambda self: None

    def activate(self):
        """activate(ArModeUnguardedTeleop self)"""
        return _AriaPy.ArModeUnguardedTeleop_activate(self)


    def deactivate(self):
        """deactivate(ArModeUnguardedTeleop self)"""
        return _AriaPy.ArModeUnguardedTeleop_deactivate(self)


    def help(self):
        """help(ArModeUnguardedTeleop self)"""
        return _AriaPy.ArModeUnguardedTeleop_help(self)


    def userTask(self):
        """userTask(ArModeUnguardedTeleop self)"""
        return _AriaPy.ArModeUnguardedTeleop_userTask(self)

ArModeUnguardedTeleop_swigregister = _AriaPy.ArModeUnguardedTeleop_swigregister
ArModeUnguardedTeleop_swigregister(ArModeUnguardedTeleop)

class ArModeWander(ArMode):
    """Proxy of C++ ArModeWander 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, robot, name, key, key2):
        """__init__(ArModeWander self, ArRobot robot, char const * name, char key, char key2) -> ArModeWander"""
        this = _AriaPy.new_ArModeWander(robot, name, key, key2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeWander
    __del__ = lambda self: None

    def activate(self):
        """activate(ArModeWander self)"""
        return _AriaPy.ArModeWander_activate(self)


    def deactivate(self):
        """deactivate(ArModeWander self)"""
        return _AriaPy.ArModeWander_deactivate(self)


    def help(self):
        """help(ArModeWander self)"""
        return _AriaPy.ArModeWander_help(self)


    def userTask(self):
        """userTask(ArModeWander self)"""
        return _AriaPy.ArModeWander_userTask(self)

ArModeWander_swigregister = _AriaPy.ArModeWander_swigregister
ArModeWander_swigregister(ArModeWander)

class ArModeGripper(ArMode):
    """Proxy of C++ ArModeGripper 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, robot, name, key, key2):
        """__init__(ArModeGripper self, ArRobot robot, char const * name, char key, char key2) -> ArModeGripper"""
        this = _AriaPy.new_ArModeGripper(robot, name, key, key2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeGripper
    __del__ = lambda self: None

    def activate(self):
        """activate(ArModeGripper self)"""
        return _AriaPy.ArModeGripper_activate(self)


    def deactivate(self):
        """deactivate(ArModeGripper self)"""
        return _AriaPy.ArModeGripper_deactivate(self)


    def userTask(self):
        """userTask(ArModeGripper self)"""
        return _AriaPy.ArModeGripper_userTask(self)


    def help(self):
        """help(ArModeGripper self)"""
        return _AriaPy.ArModeGripper_help(self)


    def open(self):
        """open(ArModeGripper self)"""
        return _AriaPy.ArModeGripper_open(self)


    def close(self):
        """close(ArModeGripper self)"""
        return _AriaPy.ArModeGripper_close(self)


    def up(self):
        """up(ArModeGripper self)"""
        return _AriaPy.ArModeGripper_up(self)


    def down(self):
        """down(ArModeGripper self)"""
        return _AriaPy.ArModeGripper_down(self)


    def stop(self):
        """stop(ArModeGripper self)"""
        return _AriaPy.ArModeGripper_stop(self)


    def exercise(self):
        """exercise(ArModeGripper self)"""
        return _AriaPy.ArModeGripper_exercise(self)

ArModeGripper_swigregister = _AriaPy.ArModeGripper_swigregister
ArModeGripper_swigregister(ArModeGripper)

class ArModeCamera(ArMode):
    """Proxy of C++ ArModeCamera 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, robot, name, key, key2):
        """__init__(ArModeCamera self, ArRobot robot, char const * name, char key, char key2) -> ArModeCamera"""
        this = _AriaPy.new_ArModeCamera(robot, name, key, key2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeCamera
    __del__ = lambda self: None

    def activate(self):
        """activate(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_activate(self)


    def deactivate(self):
        """deactivate(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_deactivate(self)


    def userTask(self):
        """userTask(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_userTask(self)


    def help(self):
        """help(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_help(self)


    def up(self):
        """up(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_up(self)


    def down(self):
        """down(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_down(self)


    def left(self):
        """left(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_left(self)


    def right(self):
        """right(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_right(self)


    def center(self):
        """center(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_center(self)


    def zoomIn(self):
        """zoomIn(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_zoomIn(self)


    def zoomOut(self):
        """zoomOut(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_zoomOut(self)


    def exercise(self):
        """exercise(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_exercise(self)


    def sony(self):
        """sony(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_sony(self)


    def canon(self):
        """canon(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_canon(self)


    def dpptu(self):
        """dpptu(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_dpptu(self)


    def amptu(self):
        """amptu(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_amptu(self)


    def canonInverted(self):
        """canonInverted(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_canonInverted(self)


    def sonySerial(self):
        """sonySerial(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_sonySerial(self)


    def canonSerial(self):
        """canonSerial(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_canonSerial(self)


    def dpptuSerial(self):
        """dpptuSerial(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_dpptuSerial(self)


    def amptuSerial(self):
        """amptuSerial(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_amptuSerial(self)


    def canonInvertedSerial(self):
        """canonInvertedSerial(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_canonInvertedSerial(self)


    def rvisionSerial(self):
        """rvisionSerial(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_rvisionSerial(self)


    def com1(self):
        """com1(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_com1(self)


    def com2(self):
        """com2(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_com2(self)


    def com3(self):
        """com3(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_com3(self)


    def com4(self):
        """com4(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_com4(self)


    def aux1(self):
        """aux1(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_aux1(self)


    def aux2(self):
        """aux2(ArModeCamera self)"""
        return _AriaPy.ArModeCamera_aux2(self)

ArModeCamera_swigregister = _AriaPy.ArModeCamera_swigregister
ArModeCamera_swigregister(ArModeCamera)

class ArModeSonar(ArMode):
    """Proxy of C++ ArModeSonar 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, robot, name, key, key2):
        """__init__(ArModeSonar self, ArRobot robot, char const * name, char key, char key2) -> ArModeSonar"""
        this = _AriaPy.new_ArModeSonar(robot, name, key, key2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeSonar
    __del__ = lambda self: None

    def activate(self):
        """activate(ArModeSonar self)"""
        return _AriaPy.ArModeSonar_activate(self)


    def deactivate(self):
        """deactivate(ArModeSonar self)"""
        return _AriaPy.ArModeSonar_deactivate(self)


    def userTask(self):
        """userTask(ArModeSonar self)"""
        return _AriaPy.ArModeSonar_userTask(self)


    def help(self):
        """help(ArModeSonar self)"""
        return _AriaPy.ArModeSonar_help(self)


    def allSonar(self):
        """allSonar(ArModeSonar self)"""
        return _AriaPy.ArModeSonar_allSonar(self)


    def firstSonar(self):
        """firstSonar(ArModeSonar self)"""
        return _AriaPy.ArModeSonar_firstSonar(self)


    def secondSonar(self):
        """secondSonar(ArModeSonar self)"""
        return _AriaPy.ArModeSonar_secondSonar(self)


    def thirdSonar(self):
        """thirdSonar(ArModeSonar self)"""
        return _AriaPy.ArModeSonar_thirdSonar(self)


    def fourthSonar(self):
        """fourthSonar(ArModeSonar self)"""
        return _AriaPy.ArModeSonar_fourthSonar(self)

ArModeSonar_swigregister = _AriaPy.ArModeSonar_swigregister
ArModeSonar_swigregister(ArModeSonar)

class ArModeBumps(ArMode):
    """Proxy of C++ ArModeBumps 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, robot, name, key, key2):
        """__init__(ArModeBumps self, ArRobot robot, char const * name, char key, char key2) -> ArModeBumps"""
        this = _AriaPy.new_ArModeBumps(robot, name, key, key2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeBumps
    __del__ = lambda self: None

    def activate(self):
        """activate(ArModeBumps self)"""
        return _AriaPy.ArModeBumps_activate(self)


    def deactivate(self):
        """deactivate(ArModeBumps self)"""
        return _AriaPy.ArModeBumps_deactivate(self)


    def userTask(self):
        """userTask(ArModeBumps self)"""
        return _AriaPy.ArModeBumps_userTask(self)


    def help(self):
        """help(ArModeBumps self)"""
        return _AriaPy.ArModeBumps_help(self)

ArModeBumps_swigregister = _AriaPy.ArModeBumps_swigregister
ArModeBumps_swigregister(ArModeBumps)

class ArModePosition(ArMode):
    """Proxy of C++ ArModePosition 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, robot, name, key, key2, gyro=None):
        """
        __init__(ArModePosition self, ArRobot robot, char const * name, char key, char key2, ArAnalogGyro gyro=None) -> ArModePosition
        __init__(ArModePosition self, ArRobot robot, char const * name, char key, char key2) -> ArModePosition
        """
        this = _AriaPy.new_ArModePosition(robot, name, key, key2, gyro)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModePosition
    __del__ = lambda self: None

    def activate(self):
        """activate(ArModePosition self)"""
        return _AriaPy.ArModePosition_activate(self)


    def deactivate(self):
        """deactivate(ArModePosition self)"""
        return _AriaPy.ArModePosition_deactivate(self)


    def userTask(self):
        """userTask(ArModePosition self)"""
        return _AriaPy.ArModePosition_userTask(self)


    def help(self):
        """help(ArModePosition self)"""
        return _AriaPy.ArModePosition_help(self)


    def up(self):
        """up(ArModePosition self)"""
        return _AriaPy.ArModePosition_up(self)


    def down(self):
        """down(ArModePosition self)"""
        return _AriaPy.ArModePosition_down(self)


    def left(self):
        """left(ArModePosition self)"""
        return _AriaPy.ArModePosition_left(self)


    def right(self):
        """right(ArModePosition self)"""
        return _AriaPy.ArModePosition_right(self)


    def stop(self):
        """stop(ArModePosition self)"""
        return _AriaPy.ArModePosition_stop(self)


    def reset(self):
        """reset(ArModePosition self)"""
        return _AriaPy.ArModePosition_reset(self)


    def mode(self):
        """mode(ArModePosition self)"""
        return _AriaPy.ArModePosition_mode(self)


    def gyro(self):
        """gyro(ArModePosition self)"""
        return _AriaPy.ArModePosition_gyro(self)


    def incDistance(self):
        """incDistance(ArModePosition self)"""
        return _AriaPy.ArModePosition_incDistance(self)


    def decDistance(self):
        """decDistance(ArModePosition self)"""
        return _AriaPy.ArModePosition_decDistance(self)

ArModePosition_swigregister = _AriaPy.ArModePosition_swigregister
ArModePosition_swigregister(ArModePosition)

class ArModeIO(ArMode):
    """Proxy of C++ ArModeIO 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, robot, name, key, key2):
        """__init__(ArModeIO self, ArRobot robot, char const * name, char key, char key2) -> ArModeIO"""
        this = _AriaPy.new_ArModeIO(robot, name, key, key2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeIO
    __del__ = lambda self: None

    def activate(self):
        """activate(ArModeIO self)"""
        return _AriaPy.ArModeIO_activate(self)


    def deactivate(self):
        """deactivate(ArModeIO self)"""
        return _AriaPy.ArModeIO_deactivate(self)


    def userTask(self):
        """userTask(ArModeIO self)"""
        return _AriaPy.ArModeIO_userTask(self)


    def help(self):
        """help(ArModeIO self)"""
        return _AriaPy.ArModeIO_help(self)

ArModeIO_swigregister = _AriaPy.ArModeIO_swigregister
ArModeIO_swigregister(ArModeIO)

class ArModeLaser(ArMode):
    """Proxy of C++ ArModeLaser 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, robot, name, key, key2, obsolete=None):
        """
        __init__(ArModeLaser self, ArRobot robot, char const * name, char key, char key2, ArSick * obsolete=None) -> ArModeLaser
        __init__(ArModeLaser self, ArRobot robot, char const * name, char key, char key2) -> ArModeLaser
        """
        this = _AriaPy.new_ArModeLaser(robot, name, key, key2, obsolete)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeLaser
    __del__ = lambda self: None

    def activate(self):
        """activate(ArModeLaser self)"""
        return _AriaPy.ArModeLaser_activate(self)


    def deactivate(self):
        """deactivate(ArModeLaser self)"""
        return _AriaPy.ArModeLaser_deactivate(self)


    def userTask(self):
        """userTask(ArModeLaser self)"""
        return _AriaPy.ArModeLaser_userTask(self)


    def help(self):
        """help(ArModeLaser self)"""
        return _AriaPy.ArModeLaser_help(self)


    def switchToLaser(self, laserNumber):
        """switchToLaser(ArModeLaser self, int laserNumber)"""
        return _AriaPy.ArModeLaser_switchToLaser(self, laserNumber)

ArModeLaser_swigregister = _AriaPy.ArModeLaser_swigregister
ArModeLaser_swigregister(ArModeLaser)

class ArModeActs(ArMode):
    """Proxy of C++ ArModeActs 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, robot, name, key, key2, acts=None):
        """
        __init__(ArModeActs self, ArRobot robot, char const * name, char key, char key2, ArACTS_1_2 acts=None) -> ArModeActs
        __init__(ArModeActs self, ArRobot robot, char const * name, char key, char key2) -> ArModeActs
        """
        this = _AriaPy.new_ArModeActs(robot, name, key, key2, acts)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeActs
    __del__ = lambda self: None

    def activate(self):
        """activate(ArModeActs self)"""
        return _AriaPy.ArModeActs_activate(self)


    def deactivate(self):
        """deactivate(ArModeActs self)"""
        return _AriaPy.ArModeActs_deactivate(self)


    def help(self):
        """help(ArModeActs self)"""
        return _AriaPy.ArModeActs_help(self)


    def userTask(self):
        """userTask(ArModeActs self)"""
        return _AriaPy.ArModeActs_userTask(self)


    def channel1(self):
        """channel1(ArModeActs self)"""
        return _AriaPy.ArModeActs_channel1(self)


    def channel2(self):
        """channel2(ArModeActs self)"""
        return _AriaPy.ArModeActs_channel2(self)


    def channel3(self):
        """channel3(ArModeActs self)"""
        return _AriaPy.ArModeActs_channel3(self)


    def channel4(self):
        """channel4(ArModeActs self)"""
        return _AriaPy.ArModeActs_channel4(self)


    def channel5(self):
        """channel5(ArModeActs self)"""
        return _AriaPy.ArModeActs_channel5(self)


    def channel6(self):
        """channel6(ArModeActs self)"""
        return _AriaPy.ArModeActs_channel6(self)


    def channel7(self):
        """channel7(ArModeActs self)"""
        return _AriaPy.ArModeActs_channel7(self)


    def channel8(self):
        """channel8(ArModeActs self)"""
        return _AriaPy.ArModeActs_channel8(self)


    def stop(self):
        """stop(ArModeActs self)"""
        return _AriaPy.ArModeActs_stop(self)


    def start(self):
        """start(ArModeActs self)"""
        return _AriaPy.ArModeActs_start(self)


    def toggleAcquire(self):
        """toggleAcquire(ArModeActs self)"""
        return _AriaPy.ArModeActs_toggleAcquire(self)

ArModeActs_swigregister = _AriaPy.ArModeActs_swigregister
ArModeActs_swigregister(ArModeActs)

class ArModeCommand(ArMode):
    """Proxy of C++ ArModeCommand 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, robot, name, key, key2):
        """__init__(ArModeCommand self, ArRobot robot, char const * name, char key, char key2) -> ArModeCommand"""
        this = _AriaPy.new_ArModeCommand(robot, name, key, key2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeCommand
    __del__ = lambda self: None

    def activate(self):
        """activate(ArModeCommand self)"""
        return _AriaPy.ArModeCommand_activate(self)


    def deactivate(self):
        """deactivate(ArModeCommand self)"""
        return _AriaPy.ArModeCommand_deactivate(self)


    def help(self):
        """help(ArModeCommand self)"""
        return _AriaPy.ArModeCommand_help(self)

ArModeCommand_swigregister = _AriaPy.ArModeCommand_swigregister
ArModeCommand_swigregister(ArModeCommand)

class ArModeTCM2(ArMode):
    """Proxy of C++ ArModeTCM2 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, robot, name, key, key2, tcm2=None):
        """
        __init__(ArModeTCM2 self, ArRobot robot, char const * name, char key, char key2, ArTCM2 tcm2=None) -> ArModeTCM2
        __init__(ArModeTCM2 self, ArRobot robot, char const * name, char key, char key2) -> ArModeTCM2
        """
        this = _AriaPy.new_ArModeTCM2(robot, name, key, key2, tcm2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeTCM2
    __del__ = lambda self: None

    def activate(self):
        """activate(ArModeTCM2 self)"""
        return _AriaPy.ArModeTCM2_activate(self)


    def deactivate(self):
        """deactivate(ArModeTCM2 self)"""
        return _AriaPy.ArModeTCM2_deactivate(self)


    def help(self):
        """help(ArModeTCM2 self)"""
        return _AriaPy.ArModeTCM2_help(self)


    def userTask(self):
        """userTask(ArModeTCM2 self)"""
        return _AriaPy.ArModeTCM2_userTask(self)

ArModeTCM2_swigregister = _AriaPy.ArModeTCM2_swigregister
ArModeTCM2_swigregister(ArModeTCM2)

class ArModeConfig(ArMode):
    """Proxy of C++ ArModeConfig 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, robot, name, key, key2):
        """__init__(ArModeConfig self, ArRobot robot, char const * name, char key, char key2) -> ArModeConfig"""
        this = _AriaPy.new_ArModeConfig(robot, name, key, key2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def activate(self):
        """activate(ArModeConfig self)"""
        return _AriaPy.ArModeConfig_activate(self)


    def deactivate(self):
        """deactivate(ArModeConfig self)"""
        return _AriaPy.ArModeConfig_deactivate(self)


    def help(self):
        """help(ArModeConfig self)"""
        return _AriaPy.ArModeConfig_help(self)

    __swig_destroy__ = _AriaPy.delete_ArModeConfig
    __del__ = lambda self: None
ArModeConfig_swigregister = _AriaPy.ArModeConfig_swigregister
ArModeConfig_swigregister(ArModeConfig)

class ArModule(object):
    """Proxy of C++ ArModule 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__ = _AriaPy.delete_ArModule
    __del__ = lambda self: None

    def init(self, robot, argument=None):
        """
        init(ArModule self, ArRobot robot, void * argument=None) -> bool
        init(ArModule self, ArRobot robot) -> bool
        """
        return _AriaPy.ArModule_init(self, robot, argument)


    def exit(self):
        """exit(ArModule self) -> bool"""
        return _AriaPy.ArModule_exit(self)


    def getRobot(self):
        """getRobot(ArModule self) -> ArRobot"""
        return _AriaPy.ArModule_getRobot(self)


    def setRobot(self, robot):
        """setRobot(ArModule self, ArRobot robot)"""
        return _AriaPy.ArModule_setRobot(self, robot)

ArModule_swigregister = _AriaPy.ArModule_swigregister
ArModule_swigregister(ArModule)

class ArModuleLoader(object):
    """Proxy of C++ ArModuleLoader class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    STATUS_SUCCESS = _AriaPy.ArModuleLoader_STATUS_SUCCESS
    STATUS_ALREADY_LOADED = _AriaPy.ArModuleLoader_STATUS_ALREADY_LOADED
    STATUS_FAILED_OPEN = _AriaPy.ArModuleLoader_STATUS_FAILED_OPEN
    STATUS_INVALID = _AriaPy.ArModuleLoader_STATUS_INVALID
    STATUS_INIT_FAILED = _AriaPy.ArModuleLoader_STATUS_INIT_FAILED
    STATUS_EXIT_FAILED = _AriaPy.ArModuleLoader_STATUS_EXIT_FAILED
    STATUS_NOT_FOUND = _AriaPy.ArModuleLoader_STATUS_NOT_FOUND

    def load(modName, robot, modArgument=None, quiet=False):
        """
        load(char const * modName, ArRobot robot, void * modArgument=None, bool quiet=False) -> ArModuleLoader::Status
        load(char const * modName, ArRobot robot, void * modArgument=None) -> ArModuleLoader::Status
        load(char const * modName, ArRobot robot) -> ArModuleLoader::Status
        """
        return _AriaPy.ArModuleLoader_load(modName, robot, modArgument, quiet)

    load = staticmethod(load)

    def reload(modName, robot, modArgument=None, quiet=False):
        """
        reload(char const * modName, ArRobot robot, void * modArgument=None, bool quiet=False) -> ArModuleLoader::Status
        reload(char const * modName, ArRobot robot, void * modArgument=None) -> ArModuleLoader::Status
        reload(char const * modName, ArRobot robot) -> ArModuleLoader::Status
        """
        return _AriaPy.ArModuleLoader_reload(modName, robot, modArgument, quiet)

    reload = staticmethod(reload)

    def close(modName, quiet=False):
        """
        close(char const * modName, bool quiet=False) -> ArModuleLoader::Status
        close(char const * modName) -> ArModuleLoader::Status
        """
        return _AriaPy.ArModuleLoader_close(modName, quiet)

    close = staticmethod(close)

    def closeAll():
        """closeAll()"""
        return _AriaPy.ArModuleLoader_closeAll()

    closeAll = staticmethod(closeAll)

    def __init__(self):
        """__init__(ArModuleLoader self) -> ArModuleLoader"""
        this = _AriaPy.new_ArModuleLoader()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModuleLoader
    __del__ = lambda self: None
ArModuleLoader_swigregister = _AriaPy.ArModuleLoader_swigregister
ArModuleLoader_swigregister(ArModuleLoader)

def ArModuleLoader_load(modName, robot, modArgument=None, quiet=False):
    """
    load(char const * modName, ArRobot robot, void * modArgument=None, bool quiet=False) -> ArModuleLoader::Status
    load(char const * modName, ArRobot robot, void * modArgument=None) -> ArModuleLoader::Status
    ArModuleLoader_load(char const * modName, ArRobot robot) -> ArModuleLoader::Status
    """
    return _AriaPy.ArModuleLoader_load(modName, robot, modArgument, quiet)

def ArModuleLoader_reload(modName, robot, modArgument=None, quiet=False):
    """
    reload(char const * modName, ArRobot robot, void * modArgument=None, bool quiet=False) -> ArModuleLoader::Status
    reload(char const * modName, ArRobot robot, void * modArgument=None) -> ArModuleLoader::Status
    ArModuleLoader_reload(char const * modName, ArRobot robot) -> ArModuleLoader::Status
    """
    return _AriaPy.ArModuleLoader_reload(modName, robot, modArgument, quiet)

def ArModuleLoader_close(modName, quiet=False):
    """
    close(char const * modName, bool quiet=False) -> ArModuleLoader::Status
    ArModuleLoader_close(char const * modName) -> ArModuleLoader::Status
    """
    return _AriaPy.ArModuleLoader_close(modName, quiet)

def ArModuleLoader_closeAll():
    """ArModuleLoader_closeAll()"""
    return _AriaPy.ArModuleLoader_closeAll()

class ArMutex(object):
    """Proxy of C++ ArMutex class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    STATUS_FAILED_INIT = _AriaPy.ArMutex_STATUS_FAILED_INIT
    STATUS_FAILED = _AriaPy.ArMutex_STATUS_FAILED
    STATUS_ALREADY_LOCKED = _AriaPy.ArMutex_STATUS_ALREADY_LOCKED
    __swig_destroy__ = _AriaPy.delete_ArMutex
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(ArMutex self, bool recursive=True) -> ArMutex
        __init__(ArMutex self) -> ArMutex
        __init__(ArMutex self, ArMutex mutex) -> ArMutex
        """
        this = _AriaPy.new_ArMutex(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def lock(self):
        """lock(ArMutex self) -> int"""
        return _AriaPy.ArMutex_lock(self)


    def tryLock(self):
        """tryLock(ArMutex self) -> int"""
        return _AriaPy.ArMutex_tryLock(self)


    def unlock(self):
        """unlock(ArMutex self) -> int"""
        return _AriaPy.ArMutex_unlock(self)


    def getError(self, messageNumber):
        """getError(ArMutex self, int messageNumber) -> char const *"""
        return _AriaPy.ArMutex_getError(self, messageNumber)


    def setLog(self, log):
        """setLog(ArMutex self, bool log)"""
        return _AriaPy.ArMutex_setLog(self, log)


    def setLogName(self, logName):
        """setLogName(ArMutex self, char const * logName)"""
        return _AriaPy.ArMutex_setLogName(self, logName)


    def getMutex(self):
        """getMutex(ArMutex self) -> ArMutex::MutexType &"""
        return _AriaPy.ArMutex_getMutex(self)


    def setLockWarningTime(lockWarningSeconds):
        """setLockWarningTime(double lockWarningSeconds)"""
        return _AriaPy.ArMutex_setLockWarningTime(lockWarningSeconds)

    setLockWarningTime = staticmethod(setLockWarningTime)

    def getLockWarningTime():
        """getLockWarningTime() -> double"""
        return _AriaPy.ArMutex_getLockWarningTime()

    getLockWarningTime = staticmethod(getLockWarningTime)

    def setUnlockWarningTime(unlockWarningSeconds):
        """setUnlockWarningTime(double unlockWarningSeconds)"""
        return _AriaPy.ArMutex_setUnlockWarningTime(unlockWarningSeconds)

    setUnlockWarningTime = staticmethod(setUnlockWarningTime)

    def getUnlockWarningTime():
        """getUnlockWarningTime() -> double"""
        return _AriaPy.ArMutex_getUnlockWarningTime()

    getUnlockWarningTime = staticmethod(getUnlockWarningTime)
ArMutex_swigregister = _AriaPy.ArMutex_swigregister
ArMutex_swigregister(ArMutex)

def ArMutex_setLockWarningTime(lockWarningSeconds):
    """ArMutex_setLockWarningTime(double lockWarningSeconds)"""
    return _AriaPy.ArMutex_setLockWarningTime(lockWarningSeconds)

def ArMutex_getLockWarningTime():
    """ArMutex_getLockWarningTime() -> double"""
    return _AriaPy.ArMutex_getLockWarningTime()

def ArMutex_setUnlockWarningTime(unlockWarningSeconds):
    """ArMutex_setUnlockWarningTime(double unlockWarningSeconds)"""
    return _AriaPy.ArMutex_setUnlockWarningTime(unlockWarningSeconds)

def ArMutex_getUnlockWarningTime():
    """ArMutex_getUnlockWarningTime() -> double"""
    return _AriaPy.ArMutex_getUnlockWarningTime()

class ArNMEAParser(object):
    """Proxy of C++ ArNMEAParser 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__(ArNMEAParser self, char const * name) -> ArNMEAParser
        __init__(ArNMEAParser self) -> ArNMEAParser
        """
        this = _AriaPy.new_ArNMEAParser(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    ParseFinished = _AriaPy.ArNMEAParser_ParseFinished
    ParseError = _AriaPy.ArNMEAParser_ParseError
    ParseData = _AriaPy.ArNMEAParser_ParseData
    ParseUpdated = _AriaPy.ArNMEAParser_ParseUpdated
    ParseFlags = _swig_property(_AriaPy.ArNMEAParser_ParseFlags_get, _AriaPy.ArNMEAParser_ParseFlags_set)

    def setIgnoreChecksum(self, ignore):
        """setIgnoreChecksum(ArNMEAParser self, bool ignore)"""
        return _AriaPy.ArNMEAParser_setIgnoreChecksum(self, ignore)


    def addHandler(self, message, handler):
        """addHandler(ArNMEAParser self, char const * message, ArNMEAParser::Handler * handler)"""
        return _AriaPy.ArNMEAParser_addHandler(self, message, handler)


    def removeHandler(self, message):
        """removeHandler(ArNMEAParser self, char const * message)"""
        return _AriaPy.ArNMEAParser_removeHandler(self, message)


    def parse(self, *args):
        """
        parse(ArNMEAParser self, ArDeviceConnection dev) -> int
        parse(ArNMEAParser self, char const * buf, int n) -> int
        """
        return _AriaPy.ArNMEAParser_parse(self, *args)


    def getHandlersRef(self):
        """getHandlersRef(ArNMEAParser self) -> ArNMEAParser::HandlerMap const &"""
        return _AriaPy.ArNMEAParser_getHandlersRef(self)

    __swig_destroy__ = _AriaPy.delete_ArNMEAParser
    __del__ = lambda self: None
ArNMEAParser_swigregister = _AriaPy.ArNMEAParser_swigregister
ArNMEAParser_swigregister(ArNMEAParser)

class ArNetServer(object):
    """Proxy of C++ ArNetServer 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, addAriaExitCB=True, doNotAddShutdownServer=False):
        """
        __init__(ArNetServer self, bool addAriaExitCB=True, bool doNotAddShutdownServer=False) -> ArNetServer
        __init__(ArNetServer self, bool addAriaExitCB=True) -> ArNetServer
        __init__(ArNetServer self) -> ArNetServer
        """
        this = _AriaPy.new_ArNetServer(addAriaExitCB, doNotAddShutdownServer)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArNetServer
    __del__ = lambda self: None

    def open(self, robot, port, password, multipleClients=True, openOnIP=None):
        """
        open(ArNetServer self, ArRobot robot, unsigned int port, char const * password, bool multipleClients=True, char const * openOnIP=None) -> bool
        open(ArNetServer self, ArRobot robot, unsigned int port, char const * password, bool multipleClients=True) -> bool
        open(ArNetServer self, ArRobot robot, unsigned int port, char const * password) -> bool
        """
        return _AriaPy.ArNetServer_open(self, robot, port, password, multipleClients, openOnIP)


    def close(self):
        """close(ArNetServer self)"""
        return _AriaPy.ArNetServer_close(self)


    def addCommand(self, command, functor, help):
        """addCommand(ArNetServer self, char const * command, ArFunctor3< char **,int,ArSocket * > * functor, char const * help) -> bool"""
        return _AriaPy.ArNetServer_addCommand(self, command, functor, help)


    def remCommand(self, command):
        """remCommand(ArNetServer self, char const * command) -> bool"""
        return _AriaPy.ArNetServer_remCommand(self, command)


    def sendToAllClientsPlain(self, str):
        """sendToAllClientsPlain(ArNetServer self, char const * str)"""
        return _AriaPy.ArNetServer_sendToAllClientsPlain(self, str)


    def sendToAllClientsNextCyclePlain(self, str):
        """sendToAllClientsNextCyclePlain(ArNetServer self, char const * str)"""
        return _AriaPy.ArNetServer_sendToAllClientsNextCyclePlain(self, str)


    def sendToClientPlain(self, socket, ipString, str):
        """sendToClientPlain(ArNetServer self, ArSocket socket, char const * ipString, char const * str)"""
        return _AriaPy.ArNetServer_sendToClientPlain(self, socket, ipString, str)


    def isOpen(self):
        """isOpen(ArNetServer self) -> bool"""
        return _AriaPy.ArNetServer_isOpen(self)


    def setLoggingDataSent(self, loggingData):
        """setLoggingDataSent(ArNetServer self, bool loggingData)"""
        return _AriaPy.ArNetServer_setLoggingDataSent(self, loggingData)


    def getLoggingDataSent(self):
        """getLoggingDataSent(ArNetServer self) -> bool"""
        return _AriaPy.ArNetServer_getLoggingDataSent(self)


    def setLoggingDataReceived(self, loggingData):
        """setLoggingDataReceived(ArNetServer self, bool loggingData)"""
        return _AriaPy.ArNetServer_setLoggingDataReceived(self, loggingData)


    def getLoggingDataReceived(self):
        """getLoggingDataReceived(ArNetServer self) -> bool"""
        return _AriaPy.ArNetServer_getLoggingDataReceived(self)


    def setUseWrongEndChars(self, useWrongEndChars):
        """setUseWrongEndChars(ArNetServer self, bool useWrongEndChars)"""
        return _AriaPy.ArNetServer_setUseWrongEndChars(self, useWrongEndChars)


    def getUseWrongEndChars(self):
        """getUseWrongEndChars(ArNetServer self) -> bool"""
        return _AriaPy.ArNetServer_getUseWrongEndChars(self)


    def runOnce(self):
        """runOnce(ArNetServer self)"""
        return _AriaPy.ArNetServer_runOnce(self)


    def internalGreeting(self, socket):
        """internalGreeting(ArNetServer self, ArSocket socket)"""
        return _AriaPy.ArNetServer_internalGreeting(self, socket)


    def internalHelp(self, *args):
        """
        internalHelp(ArNetServer self, ArSocket socket)
        internalHelp(ArNetServer self, char ** argv, int argc, ArSocket socket)
        """
        return _AriaPy.ArNetServer_internalHelp(self, *args)


    def internalEcho(self, argv, argc, socket):
        """internalEcho(ArNetServer self, char ** argv, int argc, ArSocket socket)"""
        return _AriaPy.ArNetServer_internalEcho(self, argv, argc, socket)


    def internalQuit(self, argv, argc, socket):
        """internalQuit(ArNetServer self, char ** argv, int argc, ArSocket socket)"""
        return _AriaPy.ArNetServer_internalQuit(self, argv, argc, socket)


    def internalShutdownServer(self, argv, argc, socket):
        """internalShutdownServer(ArNetServer self, char ** argv, int argc, ArSocket socket)"""
        return _AriaPy.ArNetServer_internalShutdownServer(self, argv, argc, socket)


    def parseCommandOnSocket(self, args, socket, allowLog=True):
        """
        parseCommandOnSocket(ArNetServer self, ArArgumentBuilder args, ArSocket socket, bool allowLog=True)
        parseCommandOnSocket(ArNetServer self, ArArgumentBuilder args, ArSocket socket)
        """
        return _AriaPy.ArNetServer_parseCommandOnSocket(self, args, socket, allowLog)


    def internalAddSocketToList(self, socket):
        """internalAddSocketToList(ArNetServer self, ArSocket socket)"""
        return _AriaPy.ArNetServer_internalAddSocketToList(self, socket)


    def internalAddSocketToDeleteList(self, socket):
        """internalAddSocketToDeleteList(ArNetServer self, ArSocket socket)"""
        return _AriaPy.ArNetServer_internalAddSocketToDeleteList(self, socket)


    def squelchNormal(self):
        """squelchNormal(ArNetServer self)"""
        return _AriaPy.ArNetServer_squelchNormal(self)


    def setExtraString(self, str):
        """setExtraString(ArNetServer self, char const * str)"""
        return _AriaPy.ArNetServer_setExtraString(self, str)


    def getExtraString(self):
        """getExtraString(ArNetServer self) -> char const *"""
        return _AriaPy.ArNetServer_getExtraString(self)


    def lock(self):
        """lock(ArNetServer self) -> int"""
        return _AriaPy.ArNetServer_lock(self)


    def tryLock(self):
        """tryLock(ArNetServer self) -> int"""
        return _AriaPy.ArNetServer_tryLock(self)


    def unlock(self):
        """unlock(ArNetServer self) -> int"""
        return _AriaPy.ArNetServer_unlock(self)

ArNetServer_swigregister = _AriaPy.ArNetServer_swigregister
ArNetServer_swigregister(ArNetServer)

class ArNovatelGPS(ArGPS):
    """Proxy of C++ ArNovatelGPS 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):
        """__init__(ArNovatelGPS self) -> ArNovatelGPS"""
        this = _AriaPy.new_ArNovatelGPS()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArNovatelGPS
    __del__ = lambda self: None
ArNovatelGPS_swigregister = _AriaPy.ArNovatelGPS_swigregister
ArNovatelGPS_swigregister(ArNovatelGPS)

class ArNovatelSPAN(ArNovatelGPS):
    """Proxy of C++ ArNovatelSPAN class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    GPSLatitude = _swig_property(_AriaPy.ArNovatelSPAN_GPSLatitude_get, _AriaPy.ArNovatelSPAN_GPSLatitude_set)
    GPSLongitude = _swig_property(_AriaPy.ArNovatelSPAN_GPSLongitude_get, _AriaPy.ArNovatelSPAN_GPSLongitude_set)
    haveGPSPosition = _swig_property(_AriaPy.ArNovatelSPAN_haveGPSPosition_get, _AriaPy.ArNovatelSPAN_haveGPSPosition_set)
    GPSValidFlag = _swig_property(_AriaPy.ArNovatelSPAN_GPSValidFlag_get, _AriaPy.ArNovatelSPAN_GPSValidFlag_set)
    timeGotGPSPosition = _swig_property(_AriaPy.ArNovatelSPAN_timeGotGPSPosition_get, _AriaPy.ArNovatelSPAN_timeGotGPSPosition_set)
    GPSTimestamp = _swig_property(_AriaPy.ArNovatelSPAN_GPSTimestamp_get, _AriaPy.ArNovatelSPAN_GPSTimestamp_set)

    def __init__(self):
        """__init__(ArNovatelSPAN self) -> ArNovatelSPAN"""
        this = _AriaPy.new_ArNovatelSPAN()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArNovatelSPAN
    __del__ = lambda self: None
ArNovatelSPAN_swigregister = _AriaPy.ArNovatelSPAN_swigregister
ArNovatelSPAN_swigregister(ArNovatelSPAN)

class P2ArmJoint(object):
    """Proxy of C++ P2ArmJoint 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):
        """__init__(P2ArmJoint self) -> P2ArmJoint"""
        this = _AriaPy.new_P2ArmJoint()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_P2ArmJoint
    __del__ = lambda self: None
    myPos = _swig_property(_AriaPy.P2ArmJoint_myPos_get, _AriaPy.P2ArmJoint_myPos_set)
    myVel = _swig_property(_AriaPy.P2ArmJoint_myVel_get, _AriaPy.P2ArmJoint_myVel_set)
    myHome = _swig_property(_AriaPy.P2ArmJoint_myHome_get, _AriaPy.P2ArmJoint_myHome_set)
    myMin = _swig_property(_AriaPy.P2ArmJoint_myMin_get, _AriaPy.P2ArmJoint_myMin_set)
    myCenter = _swig_property(_AriaPy.P2ArmJoint_myCenter_get, _AriaPy.P2ArmJoint_myCenter_set)
    myMax = _swig_property(_AriaPy.P2ArmJoint_myMax_get, _AriaPy.P2ArmJoint_myMax_set)
    myTicksPer90 = _swig_property(_AriaPy.P2ArmJoint_myTicksPer90_get, _AriaPy.P2ArmJoint_myTicksPer90_set)
P2ArmJoint_swigregister = _AriaPy.P2ArmJoint_swigregister
P2ArmJoint_swigregister(P2ArmJoint)

class ArP2Arm(object):
    """Proxy of C++ ArP2Arm class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    SUCCESS = _AriaPy.ArP2Arm_SUCCESS
    ALREADY_INITED = _AriaPy.ArP2Arm_ALREADY_INITED
    NOT_INITED = _AriaPy.ArP2Arm_NOT_INITED
    ROBOT_NOT_SETUP = _AriaPy.ArP2Arm_ROBOT_NOT_SETUP
    NO_ARM_FOUND = _AriaPy.ArP2Arm_NO_ARM_FOUND
    COMM_FAILED = _AriaPy.ArP2Arm_COMM_FAILED
    COULD_NOT_OPEN_PORT = _AriaPy.ArP2Arm_COULD_NOT_OPEN_PORT
    COULD_NOT_SET_UP_PORT = _AriaPy.ArP2Arm_COULD_NOT_SET_UP_PORT
    ALREADY_CONNECTED = _AriaPy.ArP2Arm_ALREADY_CONNECTED
    NOT_CONNECTED = _AriaPy.ArP2Arm_NOT_CONNECTED
    INVALID_JOINT = _AriaPy.ArP2Arm_INVALID_JOINT
    INVALID_POSITION = _AriaPy.ArP2Arm_INVALID_POSITION
    StatusPacket = _AriaPy.ArP2Arm_StatusPacket
    InfoPacket = _AriaPy.ArP2Arm_InfoPacket
    StatusOff = _AriaPy.ArP2Arm_StatusOff
    StatusSingle = _AriaPy.ArP2Arm_StatusSingle
    StatusContinuous = _AriaPy.ArP2Arm_StatusContinuous
    NumJoints = _swig_property(_AriaPy.ArP2Arm_NumJoints_get, _AriaPy.ArP2Arm_NumJoints_set)

    def __init__(self):
        """__init__(ArP2Arm self) -> ArP2Arm"""
        this = _AriaPy.new_ArP2Arm()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArP2Arm
    __del__ = lambda self: None

    def setRobot(self, robot):
        """setRobot(ArP2Arm self, ArRobot robot)"""
        return _AriaPy.ArP2Arm_setRobot(self, robot)


    def init(self):
        """init(ArP2Arm self) -> ArP2Arm::State"""
        return _AriaPy.ArP2Arm_init(self)


    def uninit(self):
        """uninit(ArP2Arm self) -> ArP2Arm::State"""
        return _AriaPy.ArP2Arm_uninit(self)


    def powerOn(self, doWait=True):
        """
        powerOn(ArP2Arm self, bool doWait=True) -> ArP2Arm::State
        powerOn(ArP2Arm self) -> ArP2Arm::State
        """
        return _AriaPy.ArP2Arm_powerOn(self, doWait)


    def powerOff(self):
        """powerOff(ArP2Arm self) -> ArP2Arm::State"""
        return _AriaPy.ArP2Arm_powerOff(self)


    def requestInfo(self):
        """requestInfo(ArP2Arm self) -> ArP2Arm::State"""
        return _AriaPy.ArP2Arm_requestInfo(self)


    def requestStatus(self, status):
        """requestStatus(ArP2Arm self, ArP2Arm::StatusType status) -> ArP2Arm::State"""
        return _AriaPy.ArP2Arm_requestStatus(self, status)


    def requestInit(self):
        """requestInit(ArP2Arm self) -> ArP2Arm::State"""
        return _AriaPy.ArP2Arm_requestInit(self)


    def checkArm(self, waitForResponse=True):
        """
        checkArm(ArP2Arm self, bool waitForResponse=True) -> ArP2Arm::State
        checkArm(ArP2Arm self) -> ArP2Arm::State
        """
        return _AriaPy.ArP2Arm_checkArm(self, waitForResponse)


    def home(self, joint=-1):
        """
        home(ArP2Arm self, int joint=-1) -> ArP2Arm::State
        home(ArP2Arm self) -> ArP2Arm::State
        """
        return _AriaPy.ArP2Arm_home(self, joint)


    def park(self):
        """park(ArP2Arm self) -> ArP2Arm::State"""
        return _AriaPy.ArP2Arm_park(self)


    def moveTo(self, joint, pos, vel=0):
        """
        moveTo(ArP2Arm self, int joint, float pos, unsigned char vel=0) -> ArP2Arm::State
        moveTo(ArP2Arm self, int joint, float pos) -> ArP2Arm::State
        """
        return _AriaPy.ArP2Arm_moveTo(self, joint, pos, vel)


    def moveToTicks(self, joint, pos):
        """moveToTicks(ArP2Arm self, int joint, unsigned char pos) -> ArP2Arm::State"""
        return _AriaPy.ArP2Arm_moveToTicks(self, joint, pos)


    def moveStep(self, joint, pos, vel=0):
        """
        moveStep(ArP2Arm self, int joint, float pos, unsigned char vel=0) -> ArP2Arm::State
        moveStep(ArP2Arm self, int joint, float pos) -> ArP2Arm::State
        """
        return _AriaPy.ArP2Arm_moveStep(self, joint, pos, vel)


    def moveStepTicks(self, joint, pos):
        """moveStepTicks(ArP2Arm self, int joint, signed char pos) -> ArP2Arm::State"""
        return _AriaPy.ArP2Arm_moveStepTicks(self, joint, pos)


    def moveVel(self, joint, vel):
        """moveVel(ArP2Arm self, int joint, int vel) -> ArP2Arm::State"""
        return _AriaPy.ArP2Arm_moveVel(self, joint, vel)


    def stop(self):
        """stop(ArP2Arm self) -> ArP2Arm::State"""
        return _AriaPy.ArP2Arm_stop(self)


    def setAutoParkTimer(self, waitSecs):
        """setAutoParkTimer(ArP2Arm self, int waitSecs) -> ArP2Arm::State"""
        return _AriaPy.ArP2Arm_setAutoParkTimer(self, waitSecs)


    def setGripperParkTimer(self, waitSecs):
        """setGripperParkTimer(ArP2Arm self, int waitSecs) -> ArP2Arm::State"""
        return _AriaPy.ArP2Arm_setGripperParkTimer(self, waitSecs)


    def setStoppedCB(self, func):
        """setStoppedCB(ArP2Arm self, ArFunctor func)"""
        return _AriaPy.ArP2Arm_setStoppedCB(self, func)


    def setPacketCB(self, func):
        """setPacketCB(ArP2Arm self, ArFunctor1< ArP2Arm::PacketType > * func)"""
        return _AriaPy.ArP2Arm_setPacketCB(self, func)


    def getArmVersion(self):
        """getArmVersion(ArP2Arm self) -> std::string"""
        return _AriaPy.ArP2Arm_getArmVersion(self)


    def getJointPos(self, joint):
        """getJointPos(ArP2Arm self, int joint) -> float"""
        return _AriaPy.ArP2Arm_getJointPos(self, joint)


    def getJointPosTicks(self, joint):
        """getJointPosTicks(ArP2Arm self, int joint) -> unsigned char"""
        return _AriaPy.ArP2Arm_getJointPosTicks(self, joint)


    def getMoving(self, joint=-1):
        """
        getMoving(ArP2Arm self, int joint=-1) -> bool
        getMoving(ArP2Arm self) -> bool
        """
        return _AriaPy.ArP2Arm_getMoving(self, joint)


    def isPowered(self):
        """isPowered(ArP2Arm self) -> bool"""
        return _AriaPy.ArP2Arm_isPowered(self)


    def isGood(self):
        """isGood(ArP2Arm self) -> bool"""
        return _AriaPy.ArP2Arm_isGood(self)


    def getStatus(self):
        """getStatus(ArP2Arm self) -> int"""
        return _AriaPy.ArP2Arm_getStatus(self)


    def getLastStatusTime(self):
        """getLastStatusTime(ArP2Arm self) -> ArTime"""
        return _AriaPy.ArP2Arm_getLastStatusTime(self)


    def getRobot(self):
        """getRobot(ArP2Arm self) -> ArRobot"""
        return _AriaPy.ArP2Arm_getRobot(self)


    def getJoint(self, joint):
        """getJoint(ArP2Arm self, int joint) -> P2ArmJoint"""
        return _AriaPy.ArP2Arm_getJoint(self, joint)


    def convertDegToTicks(self, joint, pos, ticks):
        """convertDegToTicks(ArP2Arm self, int joint, float pos, unsigned char * ticks) -> bool"""
        return _AriaPy.ArP2Arm_convertDegToTicks(self, joint, pos, ticks)


    def convertTicksToDeg(self, joint, pos, degrees):
        """convertTicksToDeg(ArP2Arm self, int joint, unsigned char pos, float * degrees) -> bool"""
        return _AriaPy.ArP2Arm_convertTicksToDeg(self, joint, pos, degrees)

ArP2Arm_swigregister = _AriaPy.ArP2Arm_swigregister
ArP2Arm_swigregister(ArP2Arm)
ArP2Arm.ArmJoint1 = _AriaPy.cvar.ArP2Arm_ArmJoint1
ArP2Arm.ArmJoint2 = _AriaPy.cvar.ArP2Arm_ArmJoint2
ArP2Arm.ArmJoint3 = _AriaPy.cvar.ArP2Arm_ArmJoint3
ArP2Arm.ArmJoint4 = _AriaPy.cvar.ArP2Arm_ArmJoint4
ArP2Arm.ArmJoint5 = _AriaPy.cvar.ArP2Arm_ArmJoint5
ArP2Arm.ArmJoint6 = _AriaPy.cvar.ArP2Arm_ArmJoint6
ArP2Arm.ArmGood = _AriaPy.cvar.ArP2Arm_ArmGood
ArP2Arm.ArmInited = _AriaPy.cvar.ArP2Arm_ArmInited
ArP2Arm.ArmPower = _AriaPy.cvar.ArP2Arm_ArmPower
ArP2Arm.ArmHoming = _AriaPy.cvar.ArP2Arm_ArmHoming

class ArPriorityResolver(ArResolver):
    """Proxy of C++ ArPriorityResolver 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):
        """__init__(ArPriorityResolver self) -> ArPriorityResolver"""
        this = _AriaPy.new_ArPriorityResolver()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArPriorityResolver
    __del__ = lambda self: None

    def resolve(self, actions, robot, logActions=False):
        """
        resolve(ArPriorityResolver self, ArResolver::ActionMap * actions, ArRobot robot, bool logActions=False) -> ArActionDesired
        resolve(ArPriorityResolver self, ArResolver::ActionMap * actions, ArRobot robot) -> ArActionDesired
        """
        return _AriaPy.ArPriorityResolver_resolve(self, actions, robot, logActions)

ArPriorityResolver_swigregister = _AriaPy.ArPriorityResolver_swigregister
ArPriorityResolver_swigregister(ArPriorityResolver)

class ArRangeBuffer(object):
    """Proxy of C++ ArRangeBuffer 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, size):
        """__init__(ArRangeBuffer self, int size) -> ArRangeBuffer"""
        this = _AriaPy.new_ArRangeBuffer(size)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRangeBuffer
    __del__ = lambda self: None

    def getSize(self):
        """getSize(ArRangeBuffer self) -> size_t"""
        return _AriaPy.ArRangeBuffer_getSize(self)


    def setSize(self, size):
        """setSize(ArRangeBuffer self, size_t size)"""
        return _AriaPy.ArRangeBuffer_setSize(self, size)


    def getPoseTaken(self):
        """getPoseTaken(ArRangeBuffer self) -> ArPose"""
        return _AriaPy.ArRangeBuffer_getPoseTaken(self)


    def setPoseTaken(self, p):
        """setPoseTaken(ArRangeBuffer self, ArPose p)"""
        return _AriaPy.ArRangeBuffer_setPoseTaken(self, p)


    def getEncoderPoseTaken(self):
        """getEncoderPoseTaken(ArRangeBuffer self) -> ArPose"""
        return _AriaPy.ArRangeBuffer_getEncoderPoseTaken(self)


    def setEncoderPoseTaken(self, p):
        """setEncoderPoseTaken(ArRangeBuffer self, ArPose p)"""
        return _AriaPy.ArRangeBuffer_setEncoderPoseTaken(self, p)


    def addReading(self, x, y):
        """addReading(ArRangeBuffer self, double x, double y)"""
        return _AriaPy.ArRangeBuffer_addReading(self, x, y)


    def addReadingConditional(self, x, y, closeDistSquared, wasAdded=None):
        """
        addReadingConditional(ArRangeBuffer self, double x, double y, double closeDistSquared, bool * wasAdded=None)
        addReadingConditional(ArRangeBuffer self, double x, double y, double closeDistSquared)
        """
        return _AriaPy.ArRangeBuffer_addReadingConditional(self, x, y, closeDistSquared, wasAdded)


    def beginInvalidationSweep(self):
        """beginInvalidationSweep(ArRangeBuffer self)"""
        return _AriaPy.ArRangeBuffer_beginInvalidationSweep(self)


    def invalidateReading(self, readingIt):
        """invalidateReading(ArRangeBuffer self, std::list< ArPoseWithTime *,std::allocator< ArPoseWithTime * > >::iterator readingIt)"""
        return _AriaPy.ArRangeBuffer_invalidateReading(self, readingIt)


    def endInvalidationSweep(self):
        """endInvalidationSweep(ArRangeBuffer self)"""
        return _AriaPy.ArRangeBuffer_endInvalidationSweep(self)


    def getBuffer(self):
        """getBuffer(ArRangeBuffer self) -> ArPoseWithTimePtrList"""
        return _AriaPy.ArRangeBuffer_getBuffer(self)


    def getClosestPolar(self, startAngle, endAngle, position, maxRange, angle=None):
        """
        getClosestPolar(ArRangeBuffer self, double startAngle, double endAngle, ArPose position, unsigned int maxRange, double * angle=None) -> double
        getClosestPolar(ArRangeBuffer self, double startAngle, double endAngle, ArPose position, unsigned int maxRange) -> double
        """
        return _AriaPy.ArRangeBuffer_getClosestPolar(self, startAngle, endAngle, position, maxRange, angle)


    def getClosestBox(self, *args):
        """
        getClosestBox(ArRangeBuffer self, double x1, double y1, double x2, double y2, ArPose position, unsigned int maxRange, ArPose readingPos=None, ArPose targetPose) -> double
        getClosestBox(ArRangeBuffer self, double x1, double y1, double x2, double y2, ArPose position, unsigned int maxRange, ArPose readingPos=None) -> double
        getClosestBox(ArRangeBuffer self, double x1, double y1, double x2, double y2, ArPose position, unsigned int maxRange) -> double
        """
        return _AriaPy.ArRangeBuffer_getClosestBox(self, *args)


    def applyTransform(self, trans):
        """applyTransform(ArRangeBuffer self, ArTransform trans)"""
        return _AriaPy.ArRangeBuffer_applyTransform(self, trans)


    def clear(self):
        """clear(ArRangeBuffer self)"""
        return _AriaPy.ArRangeBuffer_clear(self)


    def clearOlderThan(self, milliSeconds):
        """clearOlderThan(ArRangeBuffer self, int milliSeconds)"""
        return _AriaPy.ArRangeBuffer_clearOlderThan(self, milliSeconds)


    def clearOlderThanSeconds(self, seconds):
        """clearOlderThanSeconds(ArRangeBuffer self, int seconds)"""
        return _AriaPy.ArRangeBuffer_clearOlderThanSeconds(self, seconds)


    def reset(self):
        """reset(ArRangeBuffer self)"""
        return _AriaPy.ArRangeBuffer_reset(self)


    def beginRedoBuffer(self):
        """beginRedoBuffer(ArRangeBuffer self)"""
        return _AriaPy.ArRangeBuffer_beginRedoBuffer(self)


    def redoReading(self, x, y):
        """redoReading(ArRangeBuffer self, double x, double y)"""
        return _AriaPy.ArRangeBuffer_redoReading(self, x, y)


    def endRedoBuffer(self):
        """endRedoBuffer(ArRangeBuffer self)"""
        return _AriaPy.ArRangeBuffer_endRedoBuffer(self)


    def getBufferAsVector(self):
        """getBufferAsVector(ArRangeBuffer self) -> ArPoseWithTimeVector"""
        return _AriaPy.ArRangeBuffer_getBufferAsVector(self)


    def getClosestPolarInList(startAngle, endAngle, position, maxRange, angle, buffer):
        """getClosestPolarInList(double startAngle, double endAngle, ArPose position, unsigned int maxRange, double * angle, ArPoseWithTimePtrList buffer) -> double"""
        return _AriaPy.ArRangeBuffer_getClosestPolarInList(startAngle, endAngle, position, maxRange, angle, buffer)

    getClosestPolarInList = staticmethod(getClosestPolarInList)

    def getClosestBoxInList(x1, y1, x2, y2, position, maxRange, readingPos, targetPose, buffer):
        """getClosestBoxInList(double x1, double y1, double x2, double y2, ArPose position, unsigned int maxRange, ArPose readingPos, ArPose targetPose, ArPoseWithTimePtrList buffer) -> double"""
        return _AriaPy.ArRangeBuffer_getClosestBoxInList(x1, y1, x2, y2, position, maxRange, readingPos, targetPose, buffer)

    getClosestBoxInList = staticmethod(getClosestBoxInList)
ArRangeBuffer_swigregister = _AriaPy.ArRangeBuffer_swigregister
ArRangeBuffer_swigregister(ArRangeBuffer)

def ArRangeBuffer_getClosestPolarInList(startAngle, endAngle, position, maxRange, angle, buffer):
    """ArRangeBuffer_getClosestPolarInList(double startAngle, double endAngle, ArPose position, unsigned int maxRange, double * angle, ArPoseWithTimePtrList buffer) -> double"""
    return _AriaPy.ArRangeBuffer_getClosestPolarInList(startAngle, endAngle, position, maxRange, angle, buffer)

def ArRangeBuffer_getClosestBoxInList(x1, y1, x2, y2, position, maxRange, readingPos, targetPose, buffer):
    """ArRangeBuffer_getClosestBoxInList(double x1, double y1, double x2, double y2, ArPose position, unsigned int maxRange, ArPose readingPos, ArPose targetPose, ArPoseWithTimePtrList buffer) -> double"""
    return _AriaPy.ArRangeBuffer_getClosestBoxInList(x1, y1, x2, y2, position, maxRange, readingPos, targetPose, buffer)

class ArRatioInputJoydrive(object):
    """Proxy of C++ ArRatioInputJoydrive 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, robot, input, priority=50, stopIfNoButtonPressed=False, useOSCalForJoystick=True):
        """
        __init__(ArRatioInputJoydrive self, ArRobot robot, ArActionRatioInput input, int priority=50, bool stopIfNoButtonPressed=False, bool useOSCalForJoystick=True) -> ArRatioInputJoydrive
        __init__(ArRatioInputJoydrive self, ArRobot robot, ArActionRatioInput input, int priority=50, bool stopIfNoButtonPressed=False) -> ArRatioInputJoydrive
        __init__(ArRatioInputJoydrive self, ArRobot robot, ArActionRatioInput input, int priority=50) -> ArRatioInputJoydrive
        __init__(ArRatioInputJoydrive self, ArRobot robot, ArActionRatioInput input) -> ArRatioInputJoydrive
        """
        this = _AriaPy.new_ArRatioInputJoydrive(robot, input, priority, stopIfNoButtonPressed, useOSCalForJoystick)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRatioInputJoydrive
    __del__ = lambda self: None

    def joystickInited(self):
        """joystickInited(ArRatioInputJoydrive self) -> bool"""
        return _AriaPy.ArRatioInputJoydrive_joystickInited(self)


    def setStopIfNoButtonPressed(self, stopIfNoButtonPressed):
        """setStopIfNoButtonPressed(ArRatioInputJoydrive self, bool stopIfNoButtonPressed)"""
        return _AriaPy.ArRatioInputJoydrive_setStopIfNoButtonPressed(self, stopIfNoButtonPressed)


    def getStopIfNoButtonPressed(self):
        """getStopIfNoButtonPressed(ArRatioInputJoydrive self) -> bool"""
        return _AriaPy.ArRatioInputJoydrive_getStopIfNoButtonPressed(self)


    def setUseOSCal(self, useOSCal):
        """setUseOSCal(ArRatioInputJoydrive self, bool useOSCal)"""
        return _AriaPy.ArRatioInputJoydrive_setUseOSCal(self, useOSCal)


    def getUseOSCal(self):
        """getUseOSCal(ArRatioInputJoydrive self) -> bool"""
        return _AriaPy.ArRatioInputJoydrive_getUseOSCal(self)


    def getJoyHandler(self):
        """getJoyHandler(ArRatioInputJoydrive self) -> ArJoyHandler"""
        return _AriaPy.ArRatioInputJoydrive_getJoyHandler(self)

ArRatioInputJoydrive_swigregister = _AriaPy.ArRatioInputJoydrive_swigregister
ArRatioInputJoydrive_swigregister(ArRatioInputJoydrive)

class ArRatioInputKeydrive(object):
    """Proxy of C++ ArRatioInputKeydrive 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, robot, input, priority=25, velIncrement=5):
        """
        __init__(ArRatioInputKeydrive self, ArRobot robot, ArActionRatioInput input, int priority=25, double velIncrement=5) -> ArRatioInputKeydrive
        __init__(ArRatioInputKeydrive self, ArRobot robot, ArActionRatioInput input, int priority=25) -> ArRatioInputKeydrive
        __init__(ArRatioInputKeydrive self, ArRobot robot, ArActionRatioInput input) -> ArRatioInputKeydrive
        """
        this = _AriaPy.new_ArRatioInputKeydrive(robot, input, priority, velIncrement)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRatioInputKeydrive
    __del__ = lambda self: None

    def takeKeys(self):
        """takeKeys(ArRatioInputKeydrive self)"""
        return _AriaPy.ArRatioInputKeydrive_takeKeys(self)


    def giveUpKeys(self):
        """giveUpKeys(ArRatioInputKeydrive self)"""
        return _AriaPy.ArRatioInputKeydrive_giveUpKeys(self)


    def up(self):
        """up(ArRatioInputKeydrive self)"""
        return _AriaPy.ArRatioInputKeydrive_up(self)


    def down(self):
        """down(ArRatioInputKeydrive self)"""
        return _AriaPy.ArRatioInputKeydrive_down(self)


    def z(self):
        """z(ArRatioInputKeydrive self)"""
        return _AriaPy.ArRatioInputKeydrive_z(self)


    def x(self):
        """x(ArRatioInputKeydrive self)"""
        return _AriaPy.ArRatioInputKeydrive_x(self)


    def left(self):
        """left(ArRatioInputKeydrive self)"""
        return _AriaPy.ArRatioInputKeydrive_left(self)


    def right(self):
        """right(ArRatioInputKeydrive self)"""
        return _AriaPy.ArRatioInputKeydrive_right(self)


    def space(self):
        """space(ArRatioInputKeydrive self)"""
        return _AriaPy.ArRatioInputKeydrive_space(self)


    def getFireCB(self):
        """getFireCB(ArRatioInputKeydrive self) -> ArFunctor"""
        return _AriaPy.ArRatioInputKeydrive_getFireCB(self)

ArRatioInputKeydrive_swigregister = _AriaPy.ArRatioInputKeydrive_swigregister
ArRatioInputKeydrive_swigregister(ArRatioInputKeydrive)

class ArRatioInputRobotJoydrive(object):
    """Proxy of C++ ArRatioInputRobotJoydrive 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, robot, input, priority=75, requireDeadmanPushed=True):
        """
        __init__(ArRatioInputRobotJoydrive self, ArRobot robot, ArActionRatioInput input, int priority=75, bool requireDeadmanPushed=True) -> ArRatioInputRobotJoydrive
        __init__(ArRatioInputRobotJoydrive self, ArRobot robot, ArActionRatioInput input, int priority=75) -> ArRatioInputRobotJoydrive
        __init__(ArRatioInputRobotJoydrive self, ArRobot robot, ArActionRatioInput input) -> ArRatioInputRobotJoydrive
        """
        this = _AriaPy.new_ArRatioInputRobotJoydrive(robot, input, priority, requireDeadmanPushed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRatioInputRobotJoydrive
    __del__ = lambda self: None
ArRatioInputRobotJoydrive_swigregister = _AriaPy.ArRatioInputRobotJoydrive_swigregister
ArRatioInputRobotJoydrive_swigregister(ArRatioInputRobotJoydrive)

class ArRecurrentTask(ArASyncTask):
    """Proxy of C++ ArRecurrentTask 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__ = _AriaPy.delete_ArRecurrentTask
    __del__ = lambda self: None

    def task(self):
        """task(ArRecurrentTask self)"""
        return _AriaPy.ArRecurrentTask_task(self)


    def go(self):
        """go(ArRecurrentTask self)"""
        return _AriaPy.ArRecurrentTask_go(self)


    def done(self):
        """done(ArRecurrentTask self) -> int"""
        return _AriaPy.ArRecurrentTask_done(self)


    def reset(self):
        """reset(ArRecurrentTask self)"""
        return _AriaPy.ArRecurrentTask_reset(self)


    def kill(self):
        """kill(ArRecurrentTask self)"""
        return _AriaPy.ArRecurrentTask_kill(self)


    def runThread(self, ptr):
        """runThread(ArRecurrentTask self, void * ptr) -> void *"""
        return _AriaPy.ArRecurrentTask_runThread(self, ptr)

ArRecurrentTask_swigregister = _AriaPy.ArRecurrentTask_swigregister
ArRecurrentTask_swigregister(ArRecurrentTask)

class ArRobot(object):
    """Proxy of C++ ArRobot class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    WAIT_CONNECTED = _AriaPy.ArRobot_WAIT_CONNECTED
    WAIT_FAILED_CONN = _AriaPy.ArRobot_WAIT_FAILED_CONN
    WAIT_RUN_EXIT = _AriaPy.ArRobot_WAIT_RUN_EXIT
    WAIT_TIMEDOUT = _AriaPy.ArRobot_WAIT_TIMEDOUT
    WAIT_INTR = _AriaPy.ArRobot_WAIT_INTR
    WAIT_FAIL = _AriaPy.ArRobot_WAIT_FAIL
    CHARGING_UNKNOWN = _AriaPy.ArRobot_CHARGING_UNKNOWN
    CHARGING_NOT = _AriaPy.ArRobot_CHARGING_NOT
    CHARGING_BULK = _AriaPy.ArRobot_CHARGING_BULK
    CHARGING_OVERCHARGE = _AriaPy.ArRobot_CHARGING_OVERCHARGE
    CHARGING_FLOAT = _AriaPy.ArRobot_CHARGING_FLOAT
    CHARGING_BALANCE = _AriaPy.ArRobot_CHARGING_BALANCE

    def __init__(self, name=None, ignored=True, doSigHandle=True, normalInit=True, addAriaExitCallback=True):
        """
        __init__(ArRobot self, char const * name=None, bool ignored=True, bool doSigHandle=True, bool normalInit=True, bool addAriaExitCallback=True) -> ArRobot
        __init__(ArRobot self, char const * name=None, bool ignored=True, bool doSigHandle=True, bool normalInit=True) -> ArRobot
        __init__(ArRobot self, char const * name=None, bool ignored=True, bool doSigHandle=True) -> ArRobot
        __init__(ArRobot self, char const * name=None, bool ignored=True) -> ArRobot
        __init__(ArRobot self, char const * name=None) -> ArRobot
        __init__(ArRobot self) -> ArRobot
        """
        this = _AriaPy.new_ArRobot(name, ignored, doSigHandle, normalInit, addAriaExitCallback)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobot
    __del__ = lambda self: None

    def run(self, stopRunIfNotConnected, runNonThreaded=False):
        """
        run(ArRobot self, bool stopRunIfNotConnected, bool runNonThreaded=False)
        run(ArRobot self, bool stopRunIfNotConnected)
        """
        return _AriaPy.ArRobot_run(self, stopRunIfNotConnected, runNonThreaded)


    def runAsync(self, stopRunIfNotConnected, runNonThreadedPacketReader=False):
        """
        runAsync(ArRobot self, bool stopRunIfNotConnected, bool runNonThreadedPacketReader=False)
        runAsync(ArRobot self, bool stopRunIfNotConnected)
        """
        return _AriaPy.ArRobot_runAsync(self, stopRunIfNotConnected, runNonThreadedPacketReader)


    def isRunning(self):
        """isRunning(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_isRunning(self)


    def stopRunning(self, doDisconnect=True):
        """
        stopRunning(ArRobot self, bool doDisconnect=True)
        stopRunning(ArRobot self)
        """
        return _AriaPy.ArRobot_stopRunning(self, doDisconnect)


    def setDeviceConnection(self, connection):
        """setDeviceConnection(ArRobot self, ArDeviceConnection connection)"""
        return _AriaPy.ArRobot_setDeviceConnection(self, connection)


    def getDeviceConnection(self):
        """getDeviceConnection(ArRobot self) -> ArDeviceConnection"""
        return _AriaPy.ArRobot_getDeviceConnection(self)


    def isConnected(self):
        """isConnected(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_isConnected(self)


    def blockingConnect(self):
        """blockingConnect(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_blockingConnect(self)


    def asyncConnect(self):
        """asyncConnect(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_asyncConnect(self)


    def disconnect(self):
        """disconnect(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_disconnect(self)


    def clearDirectMotion(self):
        """clearDirectMotion(ArRobot self)"""
        return _AriaPy.ArRobot_clearDirectMotion(self)


    def isDirectMotion(self):
        """isDirectMotion(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_isDirectMotion(self)


    def stopStateReflection(self):
        """stopStateReflection(ArRobot self)"""
        return _AriaPy.ArRobot_stopStateReflection(self)


    def enableMotors(self):
        """enableMotors(ArRobot self)"""
        return _AriaPy.ArRobot_enableMotors(self)


    def disableMotors(self):
        """disableMotors(ArRobot self)"""
        return _AriaPy.ArRobot_disableMotors(self)


    def enableSonar(self):
        """enableSonar(ArRobot self)"""
        return _AriaPy.ArRobot_enableSonar(self)


    def enableAutonomousDrivingSonar(self):
        """enableAutonomousDrivingSonar(ArRobot self)"""
        return _AriaPy.ArRobot_enableAutonomousDrivingSonar(self)


    def disableSonar(self):
        """disableSonar(ArRobot self)"""
        return _AriaPy.ArRobot_disableSonar(self)


    def stop(self):
        """stop(ArRobot self)"""
        return _AriaPy.ArRobot_stop(self)


    def setVel(self, velocity):
        """setVel(ArRobot self, double velocity)"""
        return _AriaPy.ArRobot_setVel(self, velocity)


    def setVel2(self, leftVelocity, rightVelocity):
        """setVel2(ArRobot self, double leftVelocity, double rightVelocity)"""
        return _AriaPy.ArRobot_setVel2(self, leftVelocity, rightVelocity)


    def move(self, distance):
        """move(ArRobot self, double distance)"""
        return _AriaPy.ArRobot_move(self, distance)


    def isMoveDone(self, delta=0.0):
        """
        isMoveDone(ArRobot self, double delta=0.0) -> bool
        isMoveDone(ArRobot self) -> bool
        """
        return _AriaPy.ArRobot_isMoveDone(self, delta)


    def setMoveDoneDist(self, dist):
        """setMoveDoneDist(ArRobot self, double dist)"""
        return _AriaPy.ArRobot_setMoveDoneDist(self, dist)


    def getMoveDoneDist(self):
        """getMoveDoneDist(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getMoveDoneDist(self)


    def setHeading(self, heading):
        """setHeading(ArRobot self, double heading)"""
        return _AriaPy.ArRobot_setHeading(self, heading)


    def setRotVel(self, velocity):
        """setRotVel(ArRobot self, double velocity)"""
        return _AriaPy.ArRobot_setRotVel(self, velocity)


    def setDeltaHeading(self, deltaHeading):
        """setDeltaHeading(ArRobot self, double deltaHeading)"""
        return _AriaPy.ArRobot_setDeltaHeading(self, deltaHeading)


    def isHeadingDone(self, delta=0.0):
        """
        isHeadingDone(ArRobot self, double delta=0.0) -> bool
        isHeadingDone(ArRobot self) -> bool
        """
        return _AriaPy.ArRobot_isHeadingDone(self, delta)


    def setHeadingDoneDiff(self, degrees):
        """setHeadingDoneDiff(ArRobot self, double degrees)"""
        return _AriaPy.ArRobot_setHeadingDoneDiff(self, degrees)


    def getHeadingDoneDiff(self):
        """getHeadingDoneDiff(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getHeadingDoneDiff(self)


    def setLatVel(self, latVelocity):
        """setLatVel(ArRobot self, double latVelocity)"""
        return _AriaPy.ArRobot_setLatVel(self, latVelocity)


    def setDirectMotionPrecedenceTime(self, mSec):
        """setDirectMotionPrecedenceTime(ArRobot self, int mSec)"""
        return _AriaPy.ArRobot_setDirectMotionPrecedenceTime(self, mSec)


    def getDirectMotionPrecedenceTime(self):
        """getDirectMotionPrecedenceTime(ArRobot self) -> unsigned int"""
        return _AriaPy.ArRobot_getDirectMotionPrecedenceTime(self)


    def com(self, command):
        """com(ArRobot self, unsigned char command) -> bool"""
        return _AriaPy.ArRobot_com(self, command)


    def comInt(self, command, argument):
        """comInt(ArRobot self, unsigned char command, short argument) -> bool"""
        return _AriaPy.ArRobot_comInt(self, command, argument)


    def com2Bytes(self, command, high, low):
        """com2Bytes(ArRobot self, unsigned char command, char high, char low) -> bool"""
        return _AriaPy.ArRobot_com2Bytes(self, command, high, low)


    def comStr(self, command, argument):
        """comStr(ArRobot self, unsigned char command, char const * argument) -> bool"""
        return _AriaPy.ArRobot_comStr(self, command, argument)


    def comStrN(self, command, str, size):
        """comStrN(ArRobot self, unsigned char command, char const * str, int size) -> bool"""
        return _AriaPy.ArRobot_comStrN(self, command, str, size)


    def comDataN(self, command, data, size):
        """comDataN(ArRobot self, unsigned char command, char const * data, int size) -> bool"""
        return _AriaPy.ArRobot_comDataN(self, command, data, size)


    def getRobotName(self):
        """getRobotName(ArRobot self) -> char const *"""
        return _AriaPy.ArRobot_getRobotName(self)


    def getRobotType(self):
        """getRobotType(ArRobot self) -> char const *"""
        return _AriaPy.ArRobot_getRobotType(self)


    def getRobotSubType(self):
        """getRobotSubType(ArRobot self) -> char const *"""
        return _AriaPy.ArRobot_getRobotSubType(self)


    def getAbsoluteMaxTransVel(self):
        """getAbsoluteMaxTransVel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getAbsoluteMaxTransVel(self)


    def setAbsoluteMaxTransVel(self, maxVel):
        """setAbsoluteMaxTransVel(ArRobot self, double maxVel) -> bool"""
        return _AriaPy.ArRobot_setAbsoluteMaxTransVel(self, maxVel)


    def getAbsoluteMaxTransNegVel(self):
        """getAbsoluteMaxTransNegVel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getAbsoluteMaxTransNegVel(self)


    def setAbsoluteMaxTransNegVel(self, maxVel):
        """setAbsoluteMaxTransNegVel(ArRobot self, double maxVel) -> bool"""
        return _AriaPy.ArRobot_setAbsoluteMaxTransNegVel(self, maxVel)


    def getAbsoluteMaxTransAccel(self):
        """getAbsoluteMaxTransAccel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getAbsoluteMaxTransAccel(self)


    def setAbsoluteMaxTransAccel(self, maxAccel):
        """setAbsoluteMaxTransAccel(ArRobot self, double maxAccel) -> bool"""
        return _AriaPy.ArRobot_setAbsoluteMaxTransAccel(self, maxAccel)


    def getAbsoluteMaxTransDecel(self):
        """getAbsoluteMaxTransDecel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getAbsoluteMaxTransDecel(self)


    def setAbsoluteMaxTransDecel(self, maxDecel):
        """setAbsoluteMaxTransDecel(ArRobot self, double maxDecel) -> bool"""
        return _AriaPy.ArRobot_setAbsoluteMaxTransDecel(self, maxDecel)


    def getAbsoluteMaxRotVel(self):
        """getAbsoluteMaxRotVel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getAbsoluteMaxRotVel(self)


    def setAbsoluteMaxRotVel(self, maxVel):
        """setAbsoluteMaxRotVel(ArRobot self, double maxVel) -> bool"""
        return _AriaPy.ArRobot_setAbsoluteMaxRotVel(self, maxVel)


    def getAbsoluteMaxRotAccel(self):
        """getAbsoluteMaxRotAccel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getAbsoluteMaxRotAccel(self)


    def setAbsoluteMaxRotAccel(self, maxAccel):
        """setAbsoluteMaxRotAccel(ArRobot self, double maxAccel) -> bool"""
        return _AriaPy.ArRobot_setAbsoluteMaxRotAccel(self, maxAccel)


    def getAbsoluteMaxRotDecel(self):
        """getAbsoluteMaxRotDecel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getAbsoluteMaxRotDecel(self)


    def setAbsoluteMaxRotDecel(self, maxDecel):
        """setAbsoluteMaxRotDecel(ArRobot self, double maxDecel) -> bool"""
        return _AriaPy.ArRobot_setAbsoluteMaxRotDecel(self, maxDecel)


    def getAbsoluteMaxLatVel(self):
        """getAbsoluteMaxLatVel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getAbsoluteMaxLatVel(self)


    def setAbsoluteMaxLatVel(self, maxVel):
        """setAbsoluteMaxLatVel(ArRobot self, double maxVel) -> bool"""
        return _AriaPy.ArRobot_setAbsoluteMaxLatVel(self, maxVel)


    def getAbsoluteMaxLatAccel(self):
        """getAbsoluteMaxLatAccel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getAbsoluteMaxLatAccel(self)


    def setAbsoluteMaxLatAccel(self, maxAccel):
        """setAbsoluteMaxLatAccel(ArRobot self, double maxAccel) -> bool"""
        return _AriaPy.ArRobot_setAbsoluteMaxLatAccel(self, maxAccel)


    def getAbsoluteMaxLatDecel(self):
        """getAbsoluteMaxLatDecel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getAbsoluteMaxLatDecel(self)


    def setAbsoluteMaxLatDecel(self, maxDecel):
        """setAbsoluteMaxLatDecel(ArRobot self, double maxDecel) -> bool"""
        return _AriaPy.ArRobot_setAbsoluteMaxLatDecel(self, maxDecel)


    def getPose(self):
        """getPose(ArRobot self) -> ArPose"""
        return _AriaPy.ArRobot_getPose(self)


    def getX(self):
        """getX(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getX(self)


    def getY(self):
        """getY(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getY(self)


    def getTh(self):
        """getTh(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getTh(self)


    def findDistanceTo(self, pose):
        """findDistanceTo(ArRobot self, ArPose pose) -> double"""
        return _AriaPy.ArRobot_findDistanceTo(self, pose)


    def findAngleTo(self, pose):
        """findAngleTo(ArRobot self, ArPose pose) -> double"""
        return _AriaPy.ArRobot_findAngleTo(self, pose)


    def findDeltaHeadingTo(self, pose):
        """findDeltaHeadingTo(ArRobot self, ArPose pose) -> double"""
        return _AriaPy.ArRobot_findDeltaHeadingTo(self, pose)


    def getVel(self):
        """getVel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getVel(self)


    def getRotVel(self):
        """getRotVel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getRotVel(self)


    def getLatVel(self):
        """getLatVel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getLatVel(self)


    def hasLatVel(self):
        """hasLatVel(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_hasLatVel(self)


    def getRobotRadius(self):
        """getRobotRadius(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getRobotRadius(self)


    def getRobotWidth(self):
        """getRobotWidth(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getRobotWidth(self)


    def getRobotLength(self):
        """getRobotLength(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getRobotLength(self)


    def getRobotLengthFront(self):
        """getRobotLengthFront(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getRobotLengthFront(self)


    def getRobotLengthRear(self):
        """getRobotLengthRear(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getRobotLengthRear(self)


    def getRobotDiagonal(self):
        """getRobotDiagonal(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getRobotDiagonal(self)


    def getBatteryVoltage(self):
        """getBatteryVoltage(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getBatteryVoltage(self)


    def getBatteryVoltageNow(self):
        """getBatteryVoltageNow(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getBatteryVoltageNow(self)


    def getRealBatteryVoltage(self):
        """getRealBatteryVoltage(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getRealBatteryVoltage(self)


    def getRealBatteryVoltageNow(self):
        """getRealBatteryVoltageNow(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getRealBatteryVoltageNow(self)


    def haveStateOfCharge(self):
        """haveStateOfCharge(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_haveStateOfCharge(self)


    def hasStateOfCHarge(self):
        """hasStateOfCHarge(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_hasStateOfCHarge(self)


    def getStateOfCharge(self):
        """getStateOfCharge(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getStateOfCharge(self)


    def getStateOfChargeSetTime(self):
        """getStateOfChargeSetTime(ArRobot self) -> ArTime"""
        return _AriaPy.ArRobot_getStateOfChargeSetTime(self)


    def getStateOfChargeLow(self):
        """getStateOfChargeLow(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getStateOfChargeLow(self)


    def getStateOfChargeShutdown(self):
        """getStateOfChargeShutdown(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getStateOfChargeShutdown(self)


    def getLeftVel(self):
        """getLeftVel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getLeftVel(self)


    def getRightVel(self):
        """getRightVel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getRightVel(self)


    def getStallValue(self):
        """getStallValue(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getStallValue(self)


    def isLeftMotorStalled(self):
        """isLeftMotorStalled(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_isLeftMotorStalled(self)


    def isRightMotorStalled(self):
        """isRightMotorStalled(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_isRightMotorStalled(self)


    def getControl(self):
        """getControl(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getControl(self)


    def setKeepControlRaw(self, keepControlRaw):
        """setKeepControlRaw(ArRobot self, bool keepControlRaw)"""
        return _AriaPy.ArRobot_setKeepControlRaw(self, keepControlRaw)


    def getKeepControlRaw(self):
        """getKeepControlRaw(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_getKeepControlRaw(self)


    def getFlags(self):
        """getFlags(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getFlags(self)


    def getFaultFlags(self):
        """getFaultFlags(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getFaultFlags(self)


    def hasFaultFlags(self):
        """hasFaultFlags(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_hasFaultFlags(self)


    def areMotorsEnabled(self):
        """areMotorsEnabled(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_areMotorsEnabled(self)


    def areSonarsEnabled(self):
        """areSonarsEnabled(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_areSonarsEnabled(self)


    def areAutonomousDrivingSonarsEnabled(self):
        """areAutonomousDrivingSonarsEnabled(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_areAutonomousDrivingSonarsEnabled(self)


    def areSonarsEnabledLegacy(self):
        """areSonarsEnabledLegacy(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_areSonarsEnabledLegacy(self)


    def isEStopPressed(self):
        """isEStopPressed(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_isEStopPressed(self)


    def getEstop(self):
        """getEstop(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_getEstop(self)


    def getCompass(self):
        """getCompass(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getCompass(self)


    def getAnalogPortSelected(self):
        """getAnalogPortSelected(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getAnalogPortSelected(self)


    def getAnalog(self):
        """getAnalog(ArRobot self) -> unsigned char"""
        return _AriaPy.ArRobot_getAnalog(self)


    def getDigIn(self):
        """getDigIn(ArRobot self) -> unsigned char"""
        return _AriaPy.ArRobot_getDigIn(self)


    def getDigOut(self):
        """getDigOut(ArRobot self) -> unsigned char"""
        return _AriaPy.ArRobot_getDigOut(self)


    def getChargeState(self):
        """getChargeState(ArRobot self) -> ArRobot::ChargeState"""
        return _AriaPy.ArRobot_getChargeState(self)


    def isChargerPowerGood(self):
        """isChargerPowerGood(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_isChargerPowerGood(self)


    def getIOAnalogSize(self):
        """getIOAnalogSize(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getIOAnalogSize(self)


    def getIODigInSize(self):
        """getIODigInSize(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getIODigInSize(self)


    def getIODigOutSize(self):
        """getIODigOutSize(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getIODigOutSize(self)


    def getIOAnalog(self, num):
        """getIOAnalog(ArRobot self, int num) -> int"""
        return _AriaPy.ArRobot_getIOAnalog(self, num)


    def getIOAnalogVoltage(self, num):
        """getIOAnalogVoltage(ArRobot self, int num) -> double"""
        return _AriaPy.ArRobot_getIOAnalogVoltage(self, num)


    def getIODigIn(self, num):
        """getIODigIn(ArRobot self, int num) -> unsigned char"""
        return _AriaPy.ArRobot_getIODigIn(self, num)


    def getIODigOut(self, num):
        """getIODigOut(ArRobot self, int num) -> unsigned char"""
        return _AriaPy.ArRobot_getIODigOut(self, num)


    def hasTableSensingIR(self):
        """hasTableSensingIR(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_hasTableSensingIR(self)


    def isLeftTableSensingIRTriggered(self):
        """isLeftTableSensingIRTriggered(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_isLeftTableSensingIRTriggered(self)


    def isRightTableSensingIRTriggered(self):
        """isRightTableSensingIRTriggered(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_isRightTableSensingIRTriggered(self)


    def isLeftBreakBeamTriggered(self):
        """isLeftBreakBeamTriggered(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_isLeftBreakBeamTriggered(self)


    def isRightBreakBeamTriggered(self):
        """isRightBreakBeamTriggered(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_isRightBreakBeamTriggered(self)


    def getIOPacketTime(self):
        """getIOPacketTime(ArRobot self) -> ArTime"""
        return _AriaPy.ArRobot_getIOPacketTime(self)


    def hasFrontBumpers(self):
        """hasFrontBumpers(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_hasFrontBumpers(self)


    def getNumFrontBumpers(self):
        """getNumFrontBumpers(ArRobot self) -> unsigned int"""
        return _AriaPy.ArRobot_getNumFrontBumpers(self)


    def hasRearBumpers(self):
        """hasRearBumpers(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_hasRearBumpers(self)


    def getNumRearBumpers(self):
        """getNumRearBumpers(ArRobot self) -> unsigned int"""
        return _AriaPy.ArRobot_getNumRearBumpers(self)


    def getEncoderPose(self):
        """getEncoderPose(ArRobot self) -> ArPose"""
        return _AriaPy.ArRobot_getEncoderPose(self)


    def getEncoderX(self):
        """getEncoderX(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getEncoderX(self)


    def getEncoderY(self):
        """getEncoderY(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getEncoderY(self)


    def getEncoderTh(self):
        """getEncoderTh(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getEncoderTh(self)


    def isTryingToMove(self):
        """isTryingToMove(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_isTryingToMove(self)


    def forceTryingToMove(self):
        """forceTryingToMove(ArRobot self)"""
        return _AriaPy.ArRobot_forceTryingToMove(self)


    def getMotorPacCount(self):
        """getMotorPacCount(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getMotorPacCount(self)


    def getSonarPacCount(self):
        """getSonarPacCount(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getSonarPacCount(self)


    def getSonarRange(self, num):
        """getSonarRange(ArRobot self, int num) -> int"""
        return _AriaPy.ArRobot_getSonarRange(self, num)


    def isSonarNew(self, num):
        """isSonarNew(ArRobot self, int num) -> bool"""
        return _AriaPy.ArRobot_isSonarNew(self, num)


    def getNumSonar(self):
        """getNumSonar(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getNumSonar(self)


    def getSonarReading(self, num):
        """getSonarReading(ArRobot self, int num) -> ArSensorReading"""
        return _AriaPy.ArRobot_getSonarReading(self, num)


    def getClosestSonarRange(self, startAngle, endAngle):
        """getClosestSonarRange(ArRobot self, double startAngle, double endAngle) -> int"""
        return _AriaPy.ArRobot_getClosestSonarRange(self, startAngle, endAngle)


    def getClosestSonarNumber(self, startAngle, endAngle):
        """getClosestSonarNumber(ArRobot self, double startAngle, double endAngle) -> int"""
        return _AriaPy.ArRobot_getClosestSonarNumber(self, startAngle, endAngle)


    def getName(self):
        """getName(ArRobot self) -> char const *"""
        return _AriaPy.ArRobot_getName(self)


    def setName(self, name):
        """setName(ArRobot self, char const * name)"""
        return _AriaPy.ArRobot_setName(self, name)


    def moveTo(self, *args):
        """
        moveTo(ArRobot self, ArPose pose, bool doCumulative=True)
        moveTo(ArRobot self, ArPose pose)
        moveTo(ArRobot self, ArPose to, ArPose arg3, bool doCumulative=True)
        moveTo(ArRobot self, ArPose to, ArPose arg3)
        """
        return _AriaPy.ArRobot_moveTo(self, *args)


    def setStateOfCharge(self, stateOfCharge):
        """setStateOfCharge(ArRobot self, double stateOfCharge)"""
        return _AriaPy.ArRobot_setStateOfCharge(self, stateOfCharge)


    def setStateOfChargeLow(self, stateOfChargeLow):
        """setStateOfChargeLow(ArRobot self, double stateOfChargeLow)"""
        return _AriaPy.ArRobot_setStateOfChargeLow(self, stateOfChargeLow)


    def setStateOfChargeShutdown(self, stateOfChargeShutdown):
        """setStateOfChargeShutdown(ArRobot self, double stateOfChargeShutdown)"""
        return _AriaPy.ArRobot_setStateOfChargeShutdown(self, stateOfChargeShutdown)


    def setChargeState(self, chargeState):
        """setChargeState(ArRobot self, ArRobot::ChargeState chargeState)"""
        return _AriaPy.ArRobot_setChargeState(self, chargeState)


    def setIsChargerPowerGood(self, onCharger):
        """setIsChargerPowerGood(ArRobot self, bool onCharger)"""
        return _AriaPy.ArRobot_setIsChargerPowerGood(self, onCharger)


    def setIgnoreMicroControllerBatteryInfo(self, ignoreMicroControllerBatteryInfo):
        """setIgnoreMicroControllerBatteryInfo(ArRobot self, bool ignoreMicroControllerBatteryInfo)"""
        return _AriaPy.ArRobot_setIgnoreMicroControllerBatteryInfo(self, ignoreMicroControllerBatteryInfo)


    def setBatteryInfo(self, realBatteryVoltage, normalizedBatteryVoltage, haveStateOfCharge, stateOfCharge):
        """setBatteryInfo(ArRobot self, double realBatteryVoltage, double normalizedBatteryVoltage, bool haveStateOfCharge, double stateOfCharge)"""
        return _AriaPy.ArRobot_setBatteryInfo(self, realBatteryVoltage, normalizedBatteryVoltage, haveStateOfCharge, stateOfCharge)


    def getBatteryVoltageAverageOfNum(self):
        """getBatteryVoltageAverageOfNum(ArRobot self) -> size_t"""
        return _AriaPy.ArRobot_getBatteryVoltageAverageOfNum(self)


    def setBatteryVoltageAverageOfNum(self, numToAverage):
        """setBatteryVoltageAverageOfNum(ArRobot self, size_t numToAverage)"""
        return _AriaPy.ArRobot_setBatteryVoltageAverageOfNum(self, numToAverage)


    def getRealBatteryVoltageAverageOfNum(self):
        """getRealBatteryVoltageAverageOfNum(ArRobot self) -> size_t"""
        return _AriaPy.ArRobot_getRealBatteryVoltageAverageOfNum(self)


    def setRealBatteryVoltageAverageOfNum(self, numToAverage):
        """setRealBatteryVoltageAverageOfNum(ArRobot self, size_t numToAverage)"""
        return _AriaPy.ArRobot_setRealBatteryVoltageAverageOfNum(self, numToAverage)


    def hasTemperature(self):
        """hasTemperature(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_hasTemperature(self)


    def getTemperature(self):
        """getTemperature(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getTemperature(self)


    def requestEncoderPackets(self):
        """requestEncoderPackets(ArRobot self)"""
        return _AriaPy.ArRobot_requestEncoderPackets(self)


    def requestIOPackets(self):
        """requestIOPackets(ArRobot self)"""
        return _AriaPy.ArRobot_requestIOPackets(self)


    def stopEncoderPackets(self):
        """stopEncoderPackets(ArRobot self)"""
        return _AriaPy.ArRobot_stopEncoderPackets(self)


    def stopIOPackets(self):
        """stopIOPackets(ArRobot self)"""
        return _AriaPy.ArRobot_stopIOPackets(self)


    def haveRequestedEncoderPackets(self):
        """haveRequestedEncoderPackets(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_haveRequestedEncoderPackets(self)


    def haveRequestedIOPackets(self):
        """haveRequestedIOPackets(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_haveRequestedIOPackets(self)


    def getLeftEncoder(self):
        """getLeftEncoder(ArRobot self) -> long"""
        return _AriaPy.ArRobot_getLeftEncoder(self)


    def getRightEncoder(self):
        """getRightEncoder(ArRobot self) -> long"""
        return _AriaPy.ArRobot_getRightEncoder(self)


    def setEncoderTransform(self, *args):
        """
        setEncoderTransform(ArRobot self, ArPose deadReconPos, ArPose globalPos)
        setEncoderTransform(ArRobot self, ArPose transformPos)
        setEncoderTransform(ArRobot self, ArTransform transform)
        """
        return _AriaPy.ArRobot_setEncoderTransform(self, *args)


    def setEncoderPose(self, encoderPose):
        """setEncoderPose(ArRobot self, ArPose encoderPose)"""
        return _AriaPy.ArRobot_setEncoderPose(self, encoderPose)


    def setRawEncoderPose(self, rawEncoderPose):
        """setRawEncoderPose(ArRobot self, ArPose rawEncoderPose)"""
        return _AriaPy.ArRobot_setRawEncoderPose(self, rawEncoderPose)


    def addSetEncoderTransformCB(self, functor, position=50):
        """
        addSetEncoderTransformCB(ArRobot self, ArFunctor functor, int position=50)
        addSetEncoderTransformCB(ArRobot self, ArFunctor functor)
        """
        return _AriaPy.ArRobot_addSetEncoderTransformCB(self, functor, position)


    def remSetEncoderTransformCB(self, functor):
        """remSetEncoderTransformCB(ArRobot self, ArFunctor functor)"""
        return _AriaPy.ArRobot_remSetEncoderTransformCB(self, functor)


    def setMTXTimeUSecCB(self, functor):
        """setMTXTimeUSecCB(ArRobot self, ArRetFunctor1< bool,ArTypes::UByte4 * > * functor)"""
        return _AriaPy.ArRobot_setMTXTimeUSecCB(self, functor)


    def getEncoderTransform(self):
        """getEncoderTransform(ArRobot self) -> ArTransform"""
        return _AriaPy.ArRobot_getEncoderTransform(self)


    def getToGlobalTransform(self):
        """getToGlobalTransform(ArRobot self) -> ArTransform"""
        return _AriaPy.ArRobot_getToGlobalTransform(self)


    def getToLocalTransform(self):
        """getToLocalTransform(ArRobot self) -> ArTransform"""
        return _AriaPy.ArRobot_getToLocalTransform(self)


    def applyTransform(self, trans, doCumulative=True):
        """
        applyTransform(ArRobot self, ArTransform trans, bool doCumulative=True)
        applyTransform(ArRobot self, ArTransform trans)
        """
        return _AriaPy.ArRobot_applyTransform(self, trans, doCumulative)


    def setDeadReconPose(self, pose):
        """setDeadReconPose(ArRobot self, ArPose pose)"""
        return _AriaPy.ArRobot_setDeadReconPose(self, pose)


    def getTripOdometerDistance(self):
        """getTripOdometerDistance(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getTripOdometerDistance(self)


    def getTripOdometerDegrees(self):
        """getTripOdometerDegrees(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getTripOdometerDegrees(self)


    def getTripOdometerTime(self):
        """getTripOdometerTime(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getTripOdometerTime(self)


    def resetTripOdometer(self):
        """resetTripOdometer(ArRobot self)"""
        return _AriaPy.ArRobot_resetTripOdometer(self)


    def getOdometerDistance(self):
        """getOdometerDistance(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getOdometerDistance(self)


    def getOdometerDegrees(self):
        """getOdometerDegrees(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getOdometerDegrees(self)


    def getOdometerTime(self):
        """getOdometerTime(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getOdometerTime(self)


    def addRangeDevice(self, device):
        """addRangeDevice(ArRobot self, ArRangeDevice device)"""
        return _AriaPy.ArRobot_addRangeDevice(self, device)


    def remRangeDevice(self, *args):
        """
        remRangeDevice(ArRobot self, char const * name)
        remRangeDevice(ArRobot self, ArRangeDevice device)
        """
        return _AriaPy.ArRobot_remRangeDevice(self, *args)


    def findRangeDevice(self, *args):
        """
        findRangeDevice(ArRobot self, char const * name, bool ignoreCase=False) -> ArRangeDevice
        findRangeDevice(ArRobot self, char const * name) -> ArRangeDevice
        findRangeDevice(ArRobot self, char const * name, bool ignoreCase=False) -> ArRangeDevice
        findRangeDevice(ArRobot self, char const * name) -> ArRangeDevice
        """
        return _AriaPy.ArRobot_findRangeDevice(self, *args)


    def getRangeDeviceList(self):
        """getRangeDeviceList(ArRobot self) -> ArRangeDevicePtrList"""
        return _AriaPy.ArRobot_getRangeDeviceList(self)


    def hasRangeDevice(self, device):
        """hasRangeDevice(ArRobot self, ArRangeDevice device) -> bool"""
        return _AriaPy.ArRobot_hasRangeDevice(self, device)


    def checkRangeDevicesCurrentPolar(self, startAngle, endAngle, angle=None, rangeDevice=None, useLocationDependentDevices=True):
        """
        checkRangeDevicesCurrentPolar(ArRobot self, double startAngle, double endAngle, double * angle=None, ArRangeDevice const ** rangeDevice=None, bool useLocationDependentDevices=True) -> double
        checkRangeDevicesCurrentPolar(ArRobot self, double startAngle, double endAngle, double * angle=None, ArRangeDevice const ** rangeDevice=None) -> double
        checkRangeDevicesCurrentPolar(ArRobot self, double startAngle, double endAngle, double * angle=None) -> double
        checkRangeDevicesCurrentPolar(ArRobot self, double startAngle, double endAngle) -> double
        """
        return _AriaPy.ArRobot_checkRangeDevicesCurrentPolar(self, startAngle, endAngle, angle, rangeDevice, useLocationDependentDevices)


    def checkRangeDevicesCumulativePolar(self, startAngle, endAngle, angle=None, rangeDevice=None, useLocationDependentDevices=True):
        """
        checkRangeDevicesCumulativePolar(ArRobot self, double startAngle, double endAngle, double * angle=None, ArRangeDevice const ** rangeDevice=None, bool useLocationDependentDevices=True) -> double
        checkRangeDevicesCumulativePolar(ArRobot self, double startAngle, double endAngle, double * angle=None, ArRangeDevice const ** rangeDevice=None) -> double
        checkRangeDevicesCumulativePolar(ArRobot self, double startAngle, double endAngle, double * angle=None) -> double
        checkRangeDevicesCumulativePolar(ArRobot self, double startAngle, double endAngle) -> double
        """
        return _AriaPy.ArRobot_checkRangeDevicesCumulativePolar(self, startAngle, endAngle, angle, rangeDevice, useLocationDependentDevices)


    def checkRangeDevicesCurrentBox(self, x1, y1, x2, y2, readingPos=None, rangeDevice=None, useLocationDependentDevices=True):
        """
        checkRangeDevicesCurrentBox(ArRobot self, double x1, double y1, double x2, double y2, ArPose readingPos=None, ArRangeDevice const ** rangeDevice=None, bool useLocationDependentDevices=True) -> double
        checkRangeDevicesCurrentBox(ArRobot self, double x1, double y1, double x2, double y2, ArPose readingPos=None, ArRangeDevice const ** rangeDevice=None) -> double
        checkRangeDevicesCurrentBox(ArRobot self, double x1, double y1, double x2, double y2, ArPose readingPos=None) -> double
        checkRangeDevicesCurrentBox(ArRobot self, double x1, double y1, double x2, double y2) -> double
        """
        return _AriaPy.ArRobot_checkRangeDevicesCurrentBox(self, x1, y1, x2, y2, readingPos, rangeDevice, useLocationDependentDevices)


    def checkRangeDevicesCumulativeBox(self, x1, y1, x2, y2, readingPos=None, rangeDevice=None, useLocationDependentDevices=True):
        """
        checkRangeDevicesCumulativeBox(ArRobot self, double x1, double y1, double x2, double y2, ArPose readingPos=None, ArRangeDevice const ** rangeDevice=None, bool useLocationDependentDevices=True) -> double
        checkRangeDevicesCumulativeBox(ArRobot self, double x1, double y1, double x2, double y2, ArPose readingPos=None, ArRangeDevice const ** rangeDevice=None) -> double
        checkRangeDevicesCumulativeBox(ArRobot self, double x1, double y1, double x2, double y2, ArPose readingPos=None) -> double
        checkRangeDevicesCumulativeBox(ArRobot self, double x1, double y1, double x2, double y2) -> double
        """
        return _AriaPy.ArRobot_checkRangeDevicesCumulativeBox(self, x1, y1, x2, y2, readingPos, rangeDevice, useLocationDependentDevices)


    def addLaser(self, laser, laserNumber, addAsRangeDevice=True):
        """
        addLaser(ArRobot self, ArLaser laser, int laserNumber, bool addAsRangeDevice=True) -> bool
        addLaser(ArRobot self, ArLaser laser, int laserNumber) -> bool
        """
        return _AriaPy.ArRobot_addLaser(self, laser, laserNumber, addAsRangeDevice)


    def remLaser(self, *args):
        """
        remLaser(ArRobot self, ArLaser laser, bool removeAsRangeDevice=True) -> bool
        remLaser(ArRobot self, ArLaser laser) -> bool
        remLaser(ArRobot self, int laserNumber, bool removeAsRangeDevice=True) -> bool
        remLaser(ArRobot self, int laserNumber) -> bool
        """
        return _AriaPy.ArRobot_remLaser(self, *args)


    def findLaser(self, *args):
        """
        findLaser(ArRobot self, int laserNumber) -> ArLaser
        findLaser(ArRobot self, int laserNumber) -> ArLaser
        """
        return _AriaPy.ArRobot_findLaser(self, *args)


    def getLaserMap(self, *args):
        """
        getLaserMap(ArRobot self) -> std::map< int,ArLaser *,std::less< int >,std::allocator< std::pair< int const,ArLaser * > > > const
        getLaserMap(ArRobot self) -> std::map< int,ArLaser *,std::less< int >,std::allocator< std::pair< int const,ArLaser * > > > *
        """
        return _AriaPy.ArRobot_getLaserMap(self, *args)


    def hasLaser(self, device):
        """hasLaser(ArRobot self, ArLaser device) -> bool"""
        return _AriaPy.ArRobot_hasLaser(self, device)


    def addBattery(self, battery, batteryNumber):
        """addBattery(ArRobot self, ArBatteryMTX * battery, int batteryNumber) -> bool"""
        return _AriaPy.ArRobot_addBattery(self, battery, batteryNumber)


    def remBattery(self, *args):
        """
        remBattery(ArRobot self, ArBatteryMTX * battery) -> bool
        remBattery(ArRobot self, int batteryNumber) -> bool
        """
        return _AriaPy.ArRobot_remBattery(self, *args)


    def findBattery(self, *args):
        """
        findBattery(ArRobot self, int batteryNumber) -> ArBatteryMTX const
        findBattery(ArRobot self, int batteryNumber) -> ArBatteryMTX *
        """
        return _AriaPy.ArRobot_findBattery(self, *args)


    def getBatteryMap(self, *args):
        """
        getBatteryMap(ArRobot self) -> std::map< int,ArBatteryMTX *,std::less< int >,std::allocator< std::pair< int const,ArBatteryMTX * > > > const
        getBatteryMap(ArRobot self) -> std::map< int,ArBatteryMTX *,std::less< int >,std::allocator< std::pair< int const,ArBatteryMTX * > > > *
        """
        return _AriaPy.ArRobot_getBatteryMap(self, *args)


    def hasBattery(self, device):
        """hasBattery(ArRobot self, ArBatteryMTX * device) -> bool"""
        return _AriaPy.ArRobot_hasBattery(self, device)


    def addLCD(self, lcd, lcdNumber):
        """addLCD(ArRobot self, ArLCDMTX * lcd, int lcdNumber) -> bool"""
        return _AriaPy.ArRobot_addLCD(self, lcd, lcdNumber)


    def remLCD(self, *args):
        """
        remLCD(ArRobot self, ArLCDMTX * lcd) -> bool
        remLCD(ArRobot self, int lcdNumber) -> bool
        """
        return _AriaPy.ArRobot_remLCD(self, *args)


    def findLCD(self, *args):
        """
        findLCD(ArRobot self, int lcdNumber=1) -> ArLCDMTX const
        findLCD(ArRobot self) -> ArLCDMTX const
        findLCD(ArRobot self, int lcdNumber=1) -> ArLCDMTX
        findLCD(ArRobot self) -> ArLCDMTX *
        """
        return _AriaPy.ArRobot_findLCD(self, *args)


    def getLCDMap(self, *args):
        """
        getLCDMap(ArRobot self) -> std::map< int,ArLCDMTX *,std::less< int >,std::allocator< std::pair< int const,ArLCDMTX * > > > const
        getLCDMap(ArRobot self) -> std::map< int,ArLCDMTX *,std::less< int >,std::allocator< std::pair< int const,ArLCDMTX * > > > *
        """
        return _AriaPy.ArRobot_getLCDMap(self, *args)


    def hasLCD(self, device):
        """hasLCD(ArRobot self, ArLCDMTX * device) -> bool"""
        return _AriaPy.ArRobot_hasLCD(self, device)


    def addSonar(self, sonar, sonarNumber):
        """addSonar(ArRobot self, ArSonarMTX * sonar, int sonarNumber) -> bool"""
        return _AriaPy.ArRobot_addSonar(self, sonar, sonarNumber)


    def remSonar(self, *args):
        """
        remSonar(ArRobot self, ArSonarMTX * sonar) -> bool
        remSonar(ArRobot self, int sonarNumber) -> bool
        """
        return _AriaPy.ArRobot_remSonar(self, *args)


    def findSonar(self, *args):
        """
        findSonar(ArRobot self, int sonarNumber) -> ArSonarMTX const
        findSonar(ArRobot self, int sonarNumber) -> ArSonarMTX *
        """
        return _AriaPy.ArRobot_findSonar(self, *args)


    def getSonarMap(self, *args):
        """
        getSonarMap(ArRobot self) -> std::map< int,ArSonarMTX *,std::less< int >,std::allocator< std::pair< int const,ArSonarMTX * > > > const
        getSonarMap(ArRobot self) -> std::map< int,ArSonarMTX *,std::less< int >,std::allocator< std::pair< int const,ArSonarMTX * > > > *
        """
        return _AriaPy.ArRobot_getSonarMap(self, *args)


    def hasSonar(self, device):
        """hasSonar(ArRobot self, ArSonarMTX * device) -> bool"""
        return _AriaPy.ArRobot_hasSonar(self, device)


    def setPTZ(self, ptz):
        """setPTZ(ArRobot self, ArPTZ ptz)"""
        return _AriaPy.ArRobot_setPTZ(self, ptz)


    def getPTZ(self):
        """getPTZ(ArRobot self) -> ArPTZ"""
        return _AriaPy.ArRobot_getPTZ(self)


    def setStateReflectionRefreshTime(self, msec):
        """setStateReflectionRefreshTime(ArRobot self, int msec)"""
        return _AriaPy.ArRobot_setStateReflectionRefreshTime(self, msec)


    def getStateReflectionRefreshTime(self):
        """getStateReflectionRefreshTime(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getStateReflectionRefreshTime(self)


    def addPacketHandler(self, *args):
        """
        addPacketHandler(ArRobot self, ArRetFunctor1_Bool_ArRobotPacketP functor, ArListPos::Pos position)
        addPacketHandler(ArRobot self, ArRetFunctor1_Bool_ArRobotPacketP functor)
        """
        return _AriaPy.ArRobot_addPacketHandler(self, *args)


    def remPacketHandler(self, functor):
        """remPacketHandler(ArRobot self, ArRetFunctor1_Bool_ArRobotPacketP functor)"""
        return _AriaPy.ArRobot_remPacketHandler(self, functor)


    def addConnectCB(self, *args):
        """
        addConnectCB(ArRobot self, ArFunctor functor, ArListPos::Pos position)
        addConnectCB(ArRobot self, ArFunctor functor)
        """
        return _AriaPy.ArRobot_addConnectCB(self, *args)


    def remConnectCB(self, functor):
        """remConnectCB(ArRobot self, ArFunctor functor)"""
        return _AriaPy.ArRobot_remConnectCB(self, functor)


    def addFailedConnectCB(self, *args):
        """
        addFailedConnectCB(ArRobot self, ArFunctor functor, ArListPos::Pos position)
        addFailedConnectCB(ArRobot self, ArFunctor functor)
        """
        return _AriaPy.ArRobot_addFailedConnectCB(self, *args)


    def remFailedConnectCB(self, functor):
        """remFailedConnectCB(ArRobot self, ArFunctor functor)"""
        return _AriaPy.ArRobot_remFailedConnectCB(self, functor)


    def addDisconnectNormallyCB(self, *args):
        """
        addDisconnectNormallyCB(ArRobot self, ArFunctor functor, ArListPos::Pos position)
        addDisconnectNormallyCB(ArRobot self, ArFunctor functor)
        """
        return _AriaPy.ArRobot_addDisconnectNormallyCB(self, *args)


    def remDisconnectNormallyCB(self, functor):
        """remDisconnectNormallyCB(ArRobot self, ArFunctor functor)"""
        return _AriaPy.ArRobot_remDisconnectNormallyCB(self, functor)


    def addDisconnectOnErrorCB(self, *args):
        """
        addDisconnectOnErrorCB(ArRobot self, ArFunctor functor, ArListPos::Pos position)
        addDisconnectOnErrorCB(ArRobot self, ArFunctor functor)
        """
        return _AriaPy.ArRobot_addDisconnectOnErrorCB(self, *args)


    def remDisconnectOnErrorCB(self, functor):
        """remDisconnectOnErrorCB(ArRobot self, ArFunctor functor)"""
        return _AriaPy.ArRobot_remDisconnectOnErrorCB(self, functor)


    def addRunExitCB(self, *args):
        """
        addRunExitCB(ArRobot self, ArFunctor functor, ArListPos::Pos position)
        addRunExitCB(ArRobot self, ArFunctor functor)
        """
        return _AriaPy.ArRobot_addRunExitCB(self, *args)


    def remRunExitCB(self, functor):
        """remRunExitCB(ArRobot self, ArFunctor functor)"""
        return _AriaPy.ArRobot_remRunExitCB(self, functor)


    def waitForConnect(self, msecs=0):
        """
        waitForConnect(ArRobot self, unsigned int msecs=0) -> ArRobot::WaitState
        waitForConnect(ArRobot self) -> ArRobot::WaitState
        """
        return _AriaPy.ArRobot_waitForConnect(self, msecs)


    def waitForConnectOrConnFail(self, msecs=0):
        """
        waitForConnectOrConnFail(ArRobot self, unsigned int msecs=0) -> ArRobot::WaitState
        waitForConnectOrConnFail(ArRobot self) -> ArRobot::WaitState
        """
        return _AriaPy.ArRobot_waitForConnectOrConnFail(self, msecs)


    def waitForRunExit(self, msecs=0):
        """
        waitForRunExit(ArRobot self, unsigned int msecs=0) -> ArRobot::WaitState
        waitForRunExit(ArRobot self) -> ArRobot::WaitState
        """
        return _AriaPy.ArRobot_waitForRunExit(self, msecs)


    def wakeAllWaitingThreads(self):
        """wakeAllWaitingThreads(ArRobot self)"""
        return _AriaPy.ArRobot_wakeAllWaitingThreads(self)


    def wakeAllConnWaitingThreads(self):
        """wakeAllConnWaitingThreads(ArRobot self)"""
        return _AriaPy.ArRobot_wakeAllConnWaitingThreads(self)


    def wakeAllConnOrFailWaitingThreads(self):
        """wakeAllConnOrFailWaitingThreads(ArRobot self)"""
        return _AriaPy.ArRobot_wakeAllConnOrFailWaitingThreads(self)


    def wakeAllRunExitWaitingThreads(self):
        """wakeAllRunExitWaitingThreads(ArRobot self)"""
        return _AriaPy.ArRobot_wakeAllRunExitWaitingThreads(self)


    def addUserTask(self, name, position, functor, state=None):
        """
        addUserTask(ArRobot self, char const * name, int position, ArFunctor functor, ArTaskState::State * state=None) -> bool
        addUserTask(ArRobot self, char const * name, int position, ArFunctor functor) -> bool
        """
        return _AriaPy.ArRobot_addUserTask(self, name, position, functor, state)


    def remUserTask(self, *args):
        """
        remUserTask(ArRobot self, char const * name)
        remUserTask(ArRobot self, ArFunctor functor)
        """
        return _AriaPy.ArRobot_remUserTask(self, *args)


    def findUserTask(self, *args):
        """
        findUserTask(ArRobot self, char const * name) -> ArSyncTask
        findUserTask(ArRobot self, ArFunctor functor) -> ArSyncTask
        """
        return _AriaPy.ArRobot_findUserTask(self, *args)


    def logUserTasks(self):
        """logUserTasks(ArRobot self)"""
        return _AriaPy.ArRobot_logUserTasks(self)


    def logAllTasks(self):
        """logAllTasks(ArRobot self)"""
        return _AriaPy.ArRobot_logAllTasks(self)


    def addSensorInterpTask(self, name, position, functor, state=None):
        """
        addSensorInterpTask(ArRobot self, char const * name, int position, ArFunctor functor, ArTaskState::State * state=None) -> bool
        addSensorInterpTask(ArRobot self, char const * name, int position, ArFunctor functor) -> bool
        """
        return _AriaPy.ArRobot_addSensorInterpTask(self, name, position, functor, state)


    def remSensorInterpTask(self, *args):
        """
        remSensorInterpTask(ArRobot self, char const * name)
        remSensorInterpTask(ArRobot self, ArFunctor functor)
        """
        return _AriaPy.ArRobot_remSensorInterpTask(self, *args)


    def findTask(self, *args):
        """
        findTask(ArRobot self, char const * name) -> ArSyncTask
        findTask(ArRobot self, ArFunctor functor) -> ArSyncTask
        """
        return _AriaPy.ArRobot_findTask(self, *args)


    def addAction(self, action, priority):
        """addAction(ArRobot self, ArAction action, int priority) -> bool"""
        return _AriaPy.ArRobot_addAction(self, action, priority)


    def remAction(self, *args):
        """
        remAction(ArRobot self, ArAction action) -> bool
        remAction(ArRobot self, char const * actionName) -> bool
        """
        return _AriaPy.ArRobot_remAction(self, *args)


    def findAction(self, actionName):
        """findAction(ArRobot self, char const * actionName) -> ArAction"""
        return _AriaPy.ArRobot_findAction(self, actionName)


    def getActionMap(self):
        """getActionMap(ArRobot self) -> ArResolver::ActionMap *"""
        return _AriaPy.ArRobot_getActionMap(self)


    def deactivateActions(self):
        """deactivateActions(ArRobot self)"""
        return _AriaPy.ArRobot_deactivateActions(self)


    def logActions(self, logDeactivated=False):
        """
        logActions(ArRobot self, bool logDeactivated=False)
        logActions(ArRobot self)
        """
        return _AriaPy.ArRobot_logActions(self, logDeactivated)


    def getResolver(self):
        """getResolver(ArRobot self) -> ArResolver"""
        return _AriaPy.ArRobot_getResolver(self)


    def setResolver(self, resolver):
        """setResolver(ArRobot self, ArResolver resolver)"""
        return _AriaPy.ArRobot_setResolver(self, resolver)


    def setEncoderCorrectionCallback(self, functor):
        """setEncoderCorrectionCallback(ArRobot self, ArRetFunctor1_Double_ArPoseWithTime functor)"""
        return _AriaPy.ArRobot_setEncoderCorrectionCallback(self, functor)


    def getEncoderCorrectionCallback(self):
        """getEncoderCorrectionCallback(ArRobot self) -> ArRetFunctor1_Double_ArPoseWithTime"""
        return _AriaPy.ArRobot_getEncoderCorrectionCallback(self)


    def getConnectionOpenedTime(self):
        """getConnectionOpenedTime(ArRobot self) -> ArTime"""
        return _AriaPy.ArRobot_getConnectionOpenedTime(self)


    def setCycleTime(self, ms):
        """setCycleTime(ArRobot self, unsigned int ms)"""
        return _AriaPy.ArRobot_setCycleTime(self, ms)


    def getCycleTime(self):
        """getCycleTime(ArRobot self) -> unsigned int"""
        return _AriaPy.ArRobot_getCycleTime(self)


    def setCycleWarningTime(self, ms):
        """setCycleWarningTime(ArRobot self, unsigned int ms)"""
        return _AriaPy.ArRobot_setCycleWarningTime(self, ms)


    def getCycleWarningTime(self, *args):
        """
        getCycleWarningTime(ArRobot self) -> unsigned int
        getCycleWarningTime(ArRobot self) -> unsigned int
        """
        return _AriaPy.ArRobot_getCycleWarningTime(self, *args)


    def setConnectionCycleMultiplier(self, multiplier):
        """setConnectionCycleMultiplier(ArRobot self, unsigned int multiplier)"""
        return _AriaPy.ArRobot_setConnectionCycleMultiplier(self, multiplier)


    def getConnectionCycleMultiplier(self):
        """getConnectionCycleMultiplier(ArRobot self) -> unsigned int"""
        return _AriaPy.ArRobot_getConnectionCycleMultiplier(self)


    def setCycleChained(self, cycleChained):
        """setCycleChained(ArRobot self, bool cycleChained)"""
        return _AriaPy.ArRobot_setCycleChained(self, cycleChained)


    def isCycleChained(self):
        """isCycleChained(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_isCycleChained(self)


    def setConnectionTimeoutTime(self, mSecs):
        """setConnectionTimeoutTime(ArRobot self, int mSecs)"""
        return _AriaPy.ArRobot_setConnectionTimeoutTime(self, mSecs)


    def getConnectionTimeoutTime(self):
        """getConnectionTimeoutTime(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getConnectionTimeoutTime(self)


    def getLastPacketTime(self):
        """getLastPacketTime(ArRobot self) -> ArTime"""
        return _AriaPy.ArRobot_getLastPacketTime(self)


    def getLastOdometryTime(self):
        """getLastOdometryTime(ArRobot self) -> ArTime"""
        return _AriaPy.ArRobot_getLastOdometryTime(self)


    def setPoseInterpNumReadings(self, numReadings):
        """setPoseInterpNumReadings(ArRobot self, size_t numReadings)"""
        return _AriaPy.ArRobot_setPoseInterpNumReadings(self, numReadings)


    def getPoseInterpNumReadings(self):
        """getPoseInterpNumReadings(ArRobot self) -> size_t"""
        return _AriaPy.ArRobot_getPoseInterpNumReadings(self)


    def getPoseInterpPosition(self, timeStamp, position, mostRecent=None):
        """
        getPoseInterpPosition(ArRobot self, ArTime timeStamp, ArPose position, ArPoseWithTime mostRecent=None) -> int
        getPoseInterpPosition(ArRobot self, ArTime timeStamp, ArPose position) -> int
        """
        return _AriaPy.ArRobot_getPoseInterpPosition(self, timeStamp, position, mostRecent)


    def getPoseInterpolation(self):
        """getPoseInterpolation(ArRobot self) -> ArInterpolation"""
        return _AriaPy.ArRobot_getPoseInterpolation(self)


    def getPoseInterpPositionCallback(self):
        """getPoseInterpPositionCallback(ArRobot self) -> ArRetFunctor3< int,ArTime,ArPose *,ArPoseWithTime * > *"""
        return _AriaPy.ArRobot_getPoseInterpPositionCallback(self)


    def setEncoderPoseInterpNumReadings(self, numReadings):
        """setEncoderPoseInterpNumReadings(ArRobot self, size_t numReadings)"""
        return _AriaPy.ArRobot_setEncoderPoseInterpNumReadings(self, numReadings)


    def getEncoderPoseInterpNumReadings(self):
        """getEncoderPoseInterpNumReadings(ArRobot self) -> size_t"""
        return _AriaPy.ArRobot_getEncoderPoseInterpNumReadings(self)


    def getEncoderPoseInterpPosition(self, timeStamp, position, mostRecent=None):
        """
        getEncoderPoseInterpPosition(ArRobot self, ArTime timeStamp, ArPose position, ArPoseWithTime mostRecent=None) -> int
        getEncoderPoseInterpPosition(ArRobot self, ArTime timeStamp, ArPose position) -> int
        """
        return _AriaPy.ArRobot_getEncoderPoseInterpPosition(self, timeStamp, position, mostRecent)


    def getEncoderPoseInterpolation(self):
        """getEncoderPoseInterpolation(ArRobot self) -> ArInterpolation"""
        return _AriaPy.ArRobot_getEncoderPoseInterpolation(self)


    def getEncoderPoseInterpPositionCallback(self):
        """getEncoderPoseInterpPositionCallback(ArRobot self) -> ArRetFunctor3< int,ArTime,ArPose *,ArPoseWithTime * > *"""
        return _AriaPy.ArRobot_getEncoderPoseInterpPositionCallback(self)


    def applyEncoderOffset(self, arg2, to, result):
        """applyEncoderOffset(ArRobot self, ArPoseWithTime arg2, ArTime to, ArPose result) -> int"""
        return _AriaPy.ArRobot_applyEncoderOffset(self, arg2, to, result)


    def getCounter(self):
        """getCounter(ArRobot self) -> unsigned int"""
        return _AriaPy.ArRobot_getCounter(self)


    def getRobotParams(self):
        """getRobotParams(ArRobot self) -> ArRobotParams"""
        return _AriaPy.ArRobot_getRobotParams(self)


    def setRequireConfigPacket(self, requireConfigPacket):
        """setRequireConfigPacket(ArRobot self, bool requireConfigPacket)"""
        return _AriaPy.ArRobot_setRequireConfigPacket(self, requireConfigPacket)


    def getOrigRobotConfig(self):
        """getOrigRobotConfig(ArRobot self) -> ArRobotConfigPacketReader"""
        return _AriaPy.ArRobot_getOrigRobotConfig(self)


    def getBatteryPacketReader(self):
        """getBatteryPacketReader(ArRobot self) -> ArRobotBatteryPacketReader *"""
        return _AriaPy.ArRobot_getBatteryPacketReader(self)


    def setTransVelMax(self, vel):
        """setTransVelMax(ArRobot self, double vel)"""
        return _AriaPy.ArRobot_setTransVelMax(self, vel)


    def setTransNegVelMax(self, negVel):
        """setTransNegVelMax(ArRobot self, double negVel)"""
        return _AriaPy.ArRobot_setTransNegVelMax(self, negVel)


    def setTransAccel(self, acc):
        """setTransAccel(ArRobot self, double acc)"""
        return _AriaPy.ArRobot_setTransAccel(self, acc)


    def setTransDecel(self, decel):
        """setTransDecel(ArRobot self, double decel)"""
        return _AriaPy.ArRobot_setTransDecel(self, decel)


    def setRotVelMax(self, vel):
        """setRotVelMax(ArRobot self, double vel)"""
        return _AriaPy.ArRobot_setRotVelMax(self, vel)


    def setRotAccel(self, acc):
        """setRotAccel(ArRobot self, double acc)"""
        return _AriaPy.ArRobot_setRotAccel(self, acc)


    def setRotDecel(self, decel):
        """setRotDecel(ArRobot self, double decel)"""
        return _AriaPy.ArRobot_setRotDecel(self, decel)


    def setLatVelMax(self, vel):
        """setLatVelMax(ArRobot self, double vel)"""
        return _AriaPy.ArRobot_setLatVelMax(self, vel)


    def setLatAccel(self, acc):
        """setLatAccel(ArRobot self, double acc)"""
        return _AriaPy.ArRobot_setLatAccel(self, acc)


    def setLatDecel(self, decel):
        """setLatDecel(ArRobot self, double decel)"""
        return _AriaPy.ArRobot_setLatDecel(self, decel)


    def hasSettableVelMaxes(self):
        """hasSettableVelMaxes(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_hasSettableVelMaxes(self)


    def getTransVelMax(self):
        """getTransVelMax(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getTransVelMax(self)


    def getTransNegVelMax(self):
        """getTransNegVelMax(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getTransNegVelMax(self)


    def getRotVelMax(self):
        """getRotVelMax(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getRotVelMax(self)


    def hasSettableAccsDecs(self):
        """hasSettableAccsDecs(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_hasSettableAccsDecs(self)


    def getTransAccel(self):
        """getTransAccel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getTransAccel(self)


    def getTransDecel(self):
        """getTransDecel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getTransDecel(self)


    def getRotAccel(self):
        """getRotAccel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getRotAccel(self)


    def getRotDecel(self):
        """getRotDecel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getRotDecel(self)


    def getLatVelMax(self):
        """getLatVelMax(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getLatVelMax(self)


    def getLatAccel(self):
        """getLatAccel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getLatAccel(self)


    def getLatDecel(self):
        """getLatDecel(ArRobot self) -> double"""
        return _AriaPy.ArRobot_getLatDecel(self)


    def loadParamFile(self, file):
        """loadParamFile(ArRobot self, char const * file) -> bool"""
        return _AriaPy.ArRobot_loadParamFile(self, file)


    def setRobotParams(self, params):
        """setRobotParams(ArRobot self, ArRobotParams params)"""
        return _AriaPy.ArRobot_setRobotParams(self, params)


    def attachKeyHandler(self, keyHandler, exitOnEscape=True, useExitNotShutdown=True):
        """
        attachKeyHandler(ArRobot self, ArKeyHandler keyHandler, bool exitOnEscape=True, bool useExitNotShutdown=True)
        attachKeyHandler(ArRobot self, ArKeyHandler keyHandler, bool exitOnEscape=True)
        attachKeyHandler(ArRobot self, ArKeyHandler keyHandler)
        """
        return _AriaPy.ArRobot_attachKeyHandler(self, keyHandler, exitOnEscape, useExitNotShutdown)


    def getKeyHandler(self):
        """getKeyHandler(ArRobot self) -> ArKeyHandler"""
        return _AriaPy.ArRobot_getKeyHandler(self)


    def lock(self):
        """lock(ArRobot self) -> int"""
        return _AriaPy.ArRobot_lock(self)


    def tryLock(self):
        """tryLock(ArRobot self) -> int"""
        return _AriaPy.ArRobot_tryLock(self)


    def unlock(self):
        """unlock(ArRobot self) -> int"""
        return _AriaPy.ArRobot_unlock(self)


    def setMutexLogging(self, v):
        """setMutexLogging(ArRobot self, bool v)"""
        return _AriaPy.ArRobot_setMutexLogging(self, v)


    def setMutexLockWarningTime(self, sec):
        """setMutexLockWarningTime(ArRobot self, double sec)"""
        return _AriaPy.ArRobot_setMutexLockWarningTime(self, sec)


    def setMutexUnlockWarningTime(self, sec):
        """setMutexUnlockWarningTime(ArRobot self, double sec)"""
        return _AriaPy.ArRobot_setMutexUnlockWarningTime(self, sec)


    def isStabilizing(self):
        """isStabilizing(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_isStabilizing(self)


    def setStabilizingTime(self, mSecs):
        """setStabilizingTime(ArRobot self, int mSecs)"""
        return _AriaPy.ArRobot_setStabilizingTime(self, mSecs)


    def getStabilizingTime(self):
        """getStabilizingTime(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getStabilizingTime(self)


    def addStabilizingCB(self, *args):
        """
        addStabilizingCB(ArRobot self, ArFunctor functor, ArListPos::Pos position)
        addStabilizingCB(ArRobot self, ArFunctor functor)
        """
        return _AriaPy.ArRobot_addStabilizingCB(self, *args)


    def remStabilizingCB(self, functor):
        """remStabilizingCB(ArRobot self, ArFunctor functor)"""
        return _AriaPy.ArRobot_remStabilizingCB(self, functor)


    def getSyncTaskRoot(self):
        """getSyncTaskRoot(ArRobot self) -> ArSyncTask"""
        return _AriaPy.ArRobot_getSyncTaskRoot(self)


    def loopOnce(self):
        """loopOnce(ArRobot self)"""
        return _AriaPy.ArRobot_loopOnce(self)


    def setOdometryDelay(self, msec):
        """setOdometryDelay(ArRobot self, int msec)"""
        return _AriaPy.ArRobot_setOdometryDelay(self, msec)


    def getOdometryDelay(self):
        """getOdometryDelay(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getOdometryDelay(self)


    def getLogMovementSent(self):
        """getLogMovementSent(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_getLogMovementSent(self)


    def setLogMovementSent(self, logMovementSent):
        """setLogMovementSent(ArRobot self, bool logMovementSent)"""
        return _AriaPy.ArRobot_setLogMovementSent(self, logMovementSent)


    def getLogMovementReceived(self):
        """getLogMovementReceived(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_getLogMovementReceived(self)


    def setLogMovementReceived(self, logMovementReceived):
        """setLogMovementReceived(ArRobot self, bool logMovementReceived)"""
        return _AriaPy.ArRobot_setLogMovementReceived(self, logMovementReceived)


    def getLogVelocitiesReceived(self):
        """getLogVelocitiesReceived(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_getLogVelocitiesReceived(self)


    def setLogVelocitiesReceived(self, logVelocitiesReceived):
        """setLogVelocitiesReceived(ArRobot self, bool logVelocitiesReceived)"""
        return _AriaPy.ArRobot_setLogVelocitiesReceived(self, logVelocitiesReceived)


    def getPacketsReceivedTracking(self):
        """getPacketsReceivedTracking(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_getPacketsReceivedTracking(self)


    def setPacketsReceivedTracking(self, packetsReceivedTracking):
        """setPacketsReceivedTracking(ArRobot self, bool packetsReceivedTracking)"""
        return _AriaPy.ArRobot_setPacketsReceivedTracking(self, packetsReceivedTracking)


    def getLogSIPContents(self):
        """getLogSIPContents(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_getLogSIPContents(self)


    def setLogSIPContents(self, logSIP):
        """setLogSIPContents(ArRobot self, bool logSIP)"""
        return _AriaPy.ArRobot_setLogSIPContents(self, logSIP)


    def getPacketsSentTracking(self):
        """getPacketsSentTracking(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_getPacketsSentTracking(self)


    def setPacketsSentTracking(self, packetsSentTracking):
        """setPacketsSentTracking(ArRobot self, bool packetsSentTracking)"""
        return _AriaPy.ArRobot_setPacketsSentTracking(self, packetsSentTracking)


    def getLogActions(self):
        """getLogActions(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_getLogActions(self)


    def setLogActions(self, logActions):
        """setLogActions(ArRobot self, bool logActions)"""
        return _AriaPy.ArRobot_setLogActions(self, logActions)


    def setDoNotSwitchBaud(self, doNotSwitchBaud):
        """setDoNotSwitchBaud(ArRobot self, bool doNotSwitchBaud)"""
        return _AriaPy.ArRobot_setDoNotSwitchBaud(self, doNotSwitchBaud)


    def getDoNotSwitchBaud(self):
        """getDoNotSwitchBaud(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_getDoNotSwitchBaud(self)


    def incCounter(self):
        """incCounter(ArRobot self)"""
        return _AriaPy.ArRobot_incCounter(self)


    def packetHandler(self):
        """packetHandler(ArRobot self)"""
        return _AriaPy.ArRobot_packetHandler(self)


    def actionHandler(self):
        """actionHandler(ArRobot self)"""
        return _AriaPy.ArRobot_actionHandler(self)


    def stateReflector(self):
        """stateReflector(ArRobot self)"""
        return _AriaPy.ArRobot_stateReflector(self)


    def robotLocker(self):
        """robotLocker(ArRobot self)"""
        return _AriaPy.ArRobot_robotLocker(self)


    def robotUnlocker(self):
        """robotUnlocker(ArRobot self)"""
        return _AriaPy.ArRobot_robotUnlocker(self)


    def packetHandlerNonThreaded(self):
        """packetHandlerNonThreaded(ArRobot self)"""
        return _AriaPy.ArRobot_packetHandlerNonThreaded(self)


    def packetHandlerThreadedProcessor(self):
        """packetHandlerThreadedProcessor(ArRobot self)"""
        return _AriaPy.ArRobot_packetHandlerThreadedProcessor(self)


    def packetHandlerThreadedReader(self):
        """packetHandlerThreadedReader(ArRobot self)"""
        return _AriaPy.ArRobot_packetHandlerThreadedReader(self)


    def keyHandlerExit(self):
        """keyHandlerExit(ArRobot self)"""
        return _AriaPy.ArRobot_keyHandlerExit(self)


    def processMotorPacket(self, packet):
        """processMotorPacket(ArRobot self, ArRobotPacket packet) -> bool"""
        return _AriaPy.ArRobot_processMotorPacket(self, packet)


    def processNewSonar(self, number, range, timeReceived):
        """processNewSonar(ArRobot self, char number, int range, ArTime timeReceived)"""
        return _AriaPy.ArRobot_processNewSonar(self, number, range, timeReceived)


    def processEncoderPacket(self, packet):
        """processEncoderPacket(ArRobot self, ArRobotPacket packet) -> bool"""
        return _AriaPy.ArRobot_processEncoderPacket(self, packet)


    def processIOPacket(self, packet):
        """processIOPacket(ArRobot self, ArRobotPacket packet) -> bool"""
        return _AriaPy.ArRobot_processIOPacket(self, packet)


    def init(self):
        """init(ArRobot self)"""
        return _AriaPy.ArRobot_init(self)


    def setUpSyncList(self):
        """setUpSyncList(ArRobot self)"""
        return _AriaPy.ArRobot_setUpSyncList(self)


    def setUpPacketHandlers(self):
        """setUpPacketHandlers(ArRobot self)"""
        return _AriaPy.ArRobot_setUpPacketHandlers(self)

    myMotorPacketCB = _swig_property(_AriaPy.ArRobot_myMotorPacketCB_get, _AriaPy.ArRobot_myMotorPacketCB_set)
    myEncoderPacketCB = _swig_property(_AriaPy.ArRobot_myEncoderPacketCB_get, _AriaPy.ArRobot_myEncoderPacketCB_set)
    myIOPacketCB = _swig_property(_AriaPy.ArRobot_myIOPacketCB_get, _AriaPy.ArRobot_myIOPacketCB_set)
    myPacketHandlerCB = _swig_property(_AriaPy.ArRobot_myPacketHandlerCB_get, _AriaPy.ArRobot_myPacketHandlerCB_set)
    myActionHandlerCB = _swig_property(_AriaPy.ArRobot_myActionHandlerCB_get, _AriaPy.ArRobot_myActionHandlerCB_set)
    myStateReflectorCB = _swig_property(_AriaPy.ArRobot_myStateReflectorCB_get, _AriaPy.ArRobot_myStateReflectorCB_set)
    myRobotLockerCB = _swig_property(_AriaPy.ArRobot_myRobotLockerCB_get, _AriaPy.ArRobot_myRobotLockerCB_set)
    myRobotUnlockerCB = _swig_property(_AriaPy.ArRobot_myRobotUnlockerCB_get, _AriaPy.ArRobot_myRobotUnlockerCB_set)
    myKeyHandlerExitCB = _swig_property(_AriaPy.ArRobot_myKeyHandlerExitCB_get, _AriaPy.ArRobot_myKeyHandlerExitCB_set)
    myKeyHandlerCB = _swig_property(_AriaPy.ArRobot_myKeyHandlerCB_get, _AriaPy.ArRobot_myKeyHandlerCB_set)

    def asyncConnectHandler(self, tryHarderToConnect):
        """asyncConnectHandler(ArRobot self, bool tryHarderToConnect) -> int"""
        return _AriaPy.ArRobot_asyncConnectHandler(self, tryHarderToConnect)


    def dropConnection(self, *args):
        """
        dropConnection(ArRobot self, char const * reason)
        dropConnection(ArRobot self)
        """
        return _AriaPy.ArRobot_dropConnection(self, *args)


    def getDropConnectionReason(self):
        """getDropConnectionReason(ArRobot self) -> char const *"""
        return _AriaPy.ArRobot_getDropConnectionReason(self)


    def failedConnect(self):
        """failedConnect(ArRobot self)"""
        return _AriaPy.ArRobot_failedConnect(self)


    def madeConnection(self, resetConnectionTime=True):
        """
        madeConnection(ArRobot self, bool resetConnectionTime=True) -> bool
        madeConnection(ArRobot self) -> bool
        """
        return _AriaPy.ArRobot_madeConnection(self, resetConnectionTime)


    def startStabilization(self):
        """startStabilization(ArRobot self)"""
        return _AriaPy.ArRobot_startStabilization(self)


    def finishedConnection(self):
        """finishedConnection(ArRobot self)"""
        return _AriaPy.ArRobot_finishedConnection(self)


    def cancelConnection(self):
        """cancelConnection(ArRobot self)"""
        return _AriaPy.ArRobot_cancelConnection(self)


    def handlePacket(self, packet):
        """handlePacket(ArRobot self, ArRobotPacket packet) -> bool"""
        return _AriaPy.ArRobot_handlePacket(self, packet)


    def getRunExitListCopy(self):
        """getRunExitListCopy(ArRobot self) -> ArFunctorPtrList"""
        return _AriaPy.ArRobot_getRunExitListCopy(self)


    def processParamFile(self):
        """processParamFile(ArRobot self)"""
        return _AriaPy.ArRobot_processParamFile(self)


    def getRawEncoderPose(self):
        """getRawEncoderPose(ArRobot self) -> ArPose"""
        return _AriaPy.ArRobot_getRawEncoderPose(self)


    def getNoTimeWarningThisCycle(self):
        """getNoTimeWarningThisCycle(ArRobot self) -> bool"""
        return _AriaPy.ArRobot_getNoTimeWarningThisCycle(self)


    def setNoTimeWarningThisCycle(self, noTimeWarningThisCycle):
        """setNoTimeWarningThisCycle(ArRobot self, bool noTimeWarningThisCycle)"""
        return _AriaPy.ArRobot_setNoTimeWarningThisCycle(self, noTimeWarningThisCycle)

    myGetCycleWarningTimeCB = _swig_property(_AriaPy.ArRobot_myGetCycleWarningTimeCB_get, _AriaPy.ArRobot_myGetCycleWarningTimeCB_set)
    myGetNoTimeWarningThisCycleCB = _swig_property(_AriaPy.ArRobot_myGetNoTimeWarningThisCycleCB_get, _AriaPy.ArRobot_myGetNoTimeWarningThisCycleCB_set)

    def ariaExitCallback(self):
        """ariaExitCallback(ArRobot self)"""
        return _AriaPy.ArRobot_ariaExitCallback(self)


    def setConnectWithNoParams(self, connectWithNoParams):
        """setConnectWithNoParams(ArRobot self, bool connectWithNoParams)"""
        return _AriaPy.ArRobot_setConnectWithNoParams(self, connectWithNoParams)


    def getOSThread(self):
        """getOSThread(ArRobot self) -> ArThread::ThreadType"""
        return _AriaPy.ArRobot_getOSThread(self)


    def getAsyncConnectState(self):
        """getAsyncConnectState(ArRobot self) -> int"""
        return _AriaPy.ArRobot_getAsyncConnectState(self)


    def getPacketSender(self):
        """getPacketSender(ArRobot self) -> ArRobotPacketSender"""
        return _AriaPy.ArRobot_getPacketSender(self)


    def getPacketReceiver(self):
        """getPacketReceiver(ArRobot self) -> ArRobotPacketReceiver"""
        return _AriaPy.ArRobot_getPacketReceiver(self)


    def getRobotParamsInternal(self):
        """getRobotParamsInternal(ArRobot self) -> ArRobotParams"""
        return _AriaPy.ArRobot_getRobotParamsInternal(self)


    def internalSetFakeFirstEncoderPose(self, fakeFirstEncoderPose):
        """internalSetFakeFirstEncoderPose(ArRobot self, bool fakeFirstEncoderPose)"""
        return _AriaPy.ArRobot_internalSetFakeFirstEncoderPose(self, fakeFirstEncoderPose)


    def internalIgnoreNextPacket(self):
        """internalIgnoreNextPacket(ArRobot self)"""
        return _AriaPy.ArRobot_internalIgnoreNextPacket(self)

ArRobot_swigregister = _AriaPy.ArRobot_swigregister
ArRobot_swigregister(ArRobot)

class ArRobotConfig(object):
    """Proxy of C++ ArRobotConfig 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, robot):
        """__init__(ArRobotConfig self, ArRobot robot) -> ArRobotConfig"""
        this = _AriaPy.new_ArRobotConfig(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotConfig
    __del__ = lambda self: None

    def addAnalogGyro(self, gyro):
        """addAnalogGyro(ArRobotConfig self, ArAnalogGyro gyro)"""
        return _AriaPy.ArRobotConfig_addAnalogGyro(self, gyro)


    def processFile(self):
        """processFile(ArRobotConfig self) -> bool"""
        return _AriaPy.ArRobotConfig_processFile(self)


    def connectCallback(self):
        """connectCallback(ArRobotConfig self)"""
        return _AriaPy.ArRobotConfig_connectCallback(self)

ArRobotConfig_swigregister = _AriaPy.ArRobotConfig_swigregister
ArRobotConfig_swigregister(ArRobotConfig)

class ArRobotConfigPacketReader(object):
    """Proxy of C++ ArRobotConfigPacketReader 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, robot, onlyOneRequest=False, packetedArrivedCB=None):
        """
        __init__(ArRobotConfigPacketReader self, ArRobot robot, bool onlyOneRequest=False, ArFunctor packetedArrivedCB=None) -> ArRobotConfigPacketReader
        __init__(ArRobotConfigPacketReader self, ArRobot robot, bool onlyOneRequest=False) -> ArRobotConfigPacketReader
        __init__(ArRobotConfigPacketReader self, ArRobot robot) -> ArRobotConfigPacketReader
        """
        this = _AriaPy.new_ArRobotConfigPacketReader(robot, onlyOneRequest, packetedArrivedCB)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotConfigPacketReader
    __del__ = lambda self: None

    def requestPacket(self):
        """requestPacket(ArRobotConfigPacketReader self) -> bool"""
        return _AriaPy.ArRobotConfigPacketReader_requestPacket(self)


    def hasPacketBeenRequested(self):
        """hasPacketBeenRequested(ArRobotConfigPacketReader self) -> bool"""
        return _AriaPy.ArRobotConfigPacketReader_hasPacketBeenRequested(self)


    def hasPacketArrived(self):
        """hasPacketArrived(ArRobotConfigPacketReader self) -> bool"""
        return _AriaPy.ArRobotConfigPacketReader_hasPacketArrived(self)


    def getRobotPacket(self):
        """getRobotPacket(ArRobotConfigPacketReader self) -> ArRobotPacket"""
        return _AriaPy.ArRobotConfigPacketReader_getRobotPacket(self)


    def log(self):
        """log(ArRobotConfigPacketReader self)"""
        return _AriaPy.ArRobotConfigPacketReader_log(self)


    def logMovement(self):
        """logMovement(ArRobotConfigPacketReader self)"""
        return _AriaPy.ArRobotConfigPacketReader_logMovement(self)


    def buildString(self):
        """buildString(ArRobotConfigPacketReader self) -> std::string"""
        return _AriaPy.ArRobotConfigPacketReader_buildString(self)


    def buildStringMovement(self):
        """buildStringMovement(ArRobotConfigPacketReader self) -> std::string"""
        return _AriaPy.ArRobotConfigPacketReader_buildStringMovement(self)


    def getType(self):
        """getType(ArRobotConfigPacketReader self) -> char const *"""
        return _AriaPy.ArRobotConfigPacketReader_getType(self)


    def getSubType(self):
        """getSubType(ArRobotConfigPacketReader self) -> char const *"""
        return _AriaPy.ArRobotConfigPacketReader_getSubType(self)


    def getSerialNumber(self):
        """getSerialNumber(ArRobotConfigPacketReader self) -> char const *"""
        return _AriaPy.ArRobotConfigPacketReader_getSerialNumber(self)


    def getRotVelTop(self):
        """getRotVelTop(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getRotVelTop(self)


    def getTransVelTop(self):
        """getTransVelTop(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getTransVelTop(self)


    def getRotAccelTop(self):
        """getRotAccelTop(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getRotAccelTop(self)


    def getTransAccelTop(self):
        """getTransAccelTop(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getTransAccelTop(self)


    def getPwmMax(self):
        """getPwmMax(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getPwmMax(self)


    def getName(self):
        """getName(ArRobotConfigPacketReader self) -> char const *"""
        return _AriaPy.ArRobotConfigPacketReader_getName(self)


    def getSipCycleTime(self):
        """getSipCycleTime(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getSipCycleTime(self)


    def getHostBaud(self):
        """getHostBaud(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getHostBaud(self)


    def getAux1Baud(self):
        """getAux1Baud(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getAux1Baud(self)


    def getHasGripper(self):
        """getHasGripper(ArRobotConfigPacketReader self) -> bool"""
        return _AriaPy.ArRobotConfigPacketReader_getHasGripper(self)


    def getFrontSonar(self):
        """getFrontSonar(ArRobotConfigPacketReader self) -> bool"""
        return _AriaPy.ArRobotConfigPacketReader_getFrontSonar(self)


    def getRearSonar(self):
        """getRearSonar(ArRobotConfigPacketReader self) -> bool"""
        return _AriaPy.ArRobotConfigPacketReader_getRearSonar(self)


    def getLowBattery(self):
        """getLowBattery(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getLowBattery(self)


    def getRevCount(self):
        """getRevCount(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getRevCount(self)


    def getWatchdog(self):
        """getWatchdog(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getWatchdog(self)


    def getNormalMPacs(self):
        """getNormalMPacs(ArRobotConfigPacketReader self) -> bool"""
        return _AriaPy.ArRobotConfigPacketReader_getNormalMPacs(self)


    def getStallVal(self):
        """getStallVal(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getStallVal(self)


    def getStallCount(self):
        """getStallCount(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getStallCount(self)


    def getJoyVel(self):
        """getJoyVel(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getJoyVel(self)


    def getJoyRotVel(self):
        """getJoyRotVel(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getJoyRotVel(self)


    def getRotVelMax(self):
        """getRotVelMax(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getRotVelMax(self)


    def getTransVelMax(self):
        """getTransVelMax(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getTransVelMax(self)


    def getRotAccel(self):
        """getRotAccel(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getRotAccel(self)


    def getRotDecel(self):
        """getRotDecel(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getRotDecel(self)


    def getRotKP(self):
        """getRotKP(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getRotKP(self)


    def getRotKV(self):
        """getRotKV(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getRotKV(self)


    def getRotKI(self):
        """getRotKI(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getRotKI(self)


    def getTransAccel(self):
        """getTransAccel(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getTransAccel(self)


    def getTransDecel(self):
        """getTransDecel(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getTransDecel(self)


    def getTransKP(self):
        """getTransKP(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getTransKP(self)


    def getTransKV(self):
        """getTransKV(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getTransKV(self)


    def getTransKI(self):
        """getTransKI(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getTransKI(self)


    def getFrontBumps(self):
        """getFrontBumps(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getFrontBumps(self)


    def getRearBumps(self):
        """getRearBumps(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getRearBumps(self)


    def getHasCharger(self):
        """getHasCharger(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getHasCharger(self)


    def getSonarCycle(self):
        """getSonarCycle(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getSonarCycle(self)


    def getResetBaud(self):
        """getResetBaud(ArRobotConfigPacketReader self) -> bool"""
        return _AriaPy.ArRobotConfigPacketReader_getResetBaud(self)


    def getHasGyro(self):
        """getHasGyro(ArRobotConfigPacketReader self) -> bool"""
        return _AriaPy.ArRobotConfigPacketReader_getHasGyro(self)


    def getGyroType(self):
        """getGyroType(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getGyroType(self)


    def getDriftFactor(self):
        """getDriftFactor(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getDriftFactor(self)


    def getAux2Baud(self):
        """getAux2Baud(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getAux2Baud(self)


    def getAux3Baud(self):
        """getAux3Baud(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getAux3Baud(self)


    def getTicksMM(self):
        """getTicksMM(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getTicksMM(self)


    def getShutdownVoltage(self):
        """getShutdownVoltage(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getShutdownVoltage(self)


    def getFirmwareVersion(self):
        """getFirmwareVersion(ArRobotConfigPacketReader self) -> char const *"""
        return _AriaPy.ArRobotConfigPacketReader_getFirmwareVersion(self)


    def getGyroCW(self):
        """getGyroCW(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getGyroCW(self)


    def getGyroCCW(self):
        """getGyroCCW(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getGyroCCW(self)


    def getKinematicsDelay(self):
        """getKinematicsDelay(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getKinematicsDelay(self)


    def getLatVelTop(self):
        """getLatVelTop(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getLatVelTop(self)


    def getLatAccelTop(self):
        """getLatAccelTop(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getLatAccelTop(self)


    def getLatVelMax(self):
        """getLatVelMax(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getLatVelMax(self)


    def getLatAccel(self):
        """getLatAccel(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getLatAccel(self)


    def getLatDecel(self):
        """getLatDecel(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getLatDecel(self)


    def getPowerbotChargeThreshold(self):
        """getPowerbotChargeThreshold(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getPowerbotChargeThreshold(self)


    def getPDBPort(self):
        """getPDBPort(ArRobotConfigPacketReader self) -> unsigned char"""
        return _AriaPy.ArRobotConfigPacketReader_getPDBPort(self)


    def getGyroRateLimit(self):
        """getGyroRateLimit(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getGyroRateLimit(self)


    def getHighTemperatureShutdown(self):
        """getHighTemperatureShutdown(ArRobotConfigPacketReader self) -> char"""
        return _AriaPy.ArRobotConfigPacketReader_getHighTemperatureShutdown(self)


    def getPowerBits(self):
        """getPowerBits(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getPowerBits(self)


    def getBatteryType(self):
        """getBatteryType(ArRobotConfigPacketReader self) -> unsigned char"""
        return _AriaPy.ArRobotConfigPacketReader_getBatteryType(self)


    def getStateOfChargeLow(self):
        """getStateOfChargeLow(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getStateOfChargeLow(self)


    def getStateOfChargeShutdown(self):
        """getStateOfChargeShutdown(ArRobotConfigPacketReader self) -> int"""
        return _AriaPy.ArRobotConfigPacketReader_getStateOfChargeShutdown(self)


    def packetHandler(self, packet):
        """packetHandler(ArRobotConfigPacketReader self, ArRobotPacket packet) -> bool"""
        return _AriaPy.ArRobotConfigPacketReader_packetHandler(self, packet)


    def connected(self):
        """connected(ArRobotConfigPacketReader self)"""
        return _AriaPy.ArRobotConfigPacketReader_connected(self)

ArRobotConfigPacketReader_swigregister = _AriaPy.ArRobotConfigPacketReader_swigregister
ArRobotConfigPacketReader_swigregister(ArRobotConfigPacketReader)

class ArRobotConnector(object):
    """Proxy of C++ ArRobotConnector 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, parser, robot, autoParseArgs=True, connectAllComponents=True):
        """
        __init__(ArRobotConnector self, ArArgumentParser parser, ArRobot robot, bool autoParseArgs=True, bool connectAllComponents=True) -> ArRobotConnector
        __init__(ArRobotConnector self, ArArgumentParser parser, ArRobot robot, bool autoParseArgs=True) -> ArRobotConnector
        __init__(ArRobotConnector self, ArArgumentParser parser, ArRobot robot) -> ArRobotConnector
        """
        this = _AriaPy.new_ArRobotConnector(parser, robot, autoParseArgs, connectAllComponents)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotConnector
    __del__ = lambda self: None

    def setupRobot(self, *args):
        """
        setupRobot(ArRobotConnector self) -> bool
        setupRobot(ArRobotConnector self, ArRobot robot) -> bool
        """
        return _AriaPy.ArRobotConnector_setupRobot(self, *args)


    def connectRobot(self, *args):
        """
        connectRobot(ArRobotConnector self) -> bool
        connectRobot(ArRobotConnector self, ArRobot robot) -> bool
        """
        return _AriaPy.ArRobotConnector_connectRobot(self, *args)


    def parseArgs(self, *args):
        """
        parseArgs(ArRobotConnector self) -> bool
        parseArgs(ArRobotConnector self, ArArgumentParser parser) -> bool
        """
        return _AriaPy.ArRobotConnector_parseArgs(self, *args)


    def logOptions(self):
        """logOptions(ArRobotConnector self)"""
        return _AriaPy.ArRobotConnector_logOptions(self)


    def getRemoteHost(self):
        """getRemoteHost(ArRobotConnector self) -> char const *"""
        return _AriaPy.ArRobotConnector_getRemoteHost(self)


    def getRemoteIsSim(self):
        """getRemoteIsSim(ArRobotConnector self) -> bool"""
        return _AriaPy.ArRobotConnector_getRemoteIsSim(self)


    def setRemoteIsSim(self, remoteIsSim):
        """setRemoteIsSim(ArRobotConnector self, bool remoteIsSim)"""
        return _AriaPy.ArRobotConnector_setRemoteIsSim(self, remoteIsSim)


    def getRobot(self):
        """getRobot(ArRobotConnector self) -> ArRobot"""
        return _AriaPy.ArRobotConnector_getRobot(self)

ArRobotConnector_swigregister = _AriaPy.ArRobotConnector_swigregister
ArRobotConnector_swigregister(ArRobotConnector)

class ArRobotJoyHandler(object):
    """Proxy of C++ ArRobotJoyHandler 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, robot):
        """__init__(ArRobotJoyHandler self, ArRobot robot) -> ArRobotJoyHandler"""
        this = _AriaPy.new_ArRobotJoyHandler(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotJoyHandler
    __del__ = lambda self: None

    def getDoubles(self):
        """getDoubles(ArRobotJoyHandler self)"""
        return _AriaPy.ArRobotJoyHandler_getDoubles(self)


    def getButton1(self):
        """getButton1(ArRobotJoyHandler self) -> bool"""
        return _AriaPy.ArRobotJoyHandler_getButton1(self)


    def getButton2(self):
        """getButton2(ArRobotJoyHandler self) -> bool"""
        return _AriaPy.ArRobotJoyHandler_getButton2(self)


    def getDataReceivedTime(self):
        """getDataReceivedTime(ArRobotJoyHandler self) -> ArTime"""
        return _AriaPy.ArRobotJoyHandler_getDataReceivedTime(self)


    def gotData(self):
        """gotData(ArRobotJoyHandler self) -> bool"""
        return _AriaPy.ArRobotJoyHandler_gotData(self)


    def addToConfig(self, config, section):
        """addToConfig(ArRobotJoyHandler self, ArConfig config, char const * section)"""
        return _AriaPy.ArRobotJoyHandler_addToConfig(self, config, section)


    def getRawX(self):
        """getRawX(ArRobotJoyHandler self) -> int"""
        return _AriaPy.ArRobotJoyHandler_getRawX(self)


    def getRawY(self):
        """getRawY(ArRobotJoyHandler self) -> int"""
        return _AriaPy.ArRobotJoyHandler_getRawY(self)


    def getRawThrottle(self):
        """getRawThrottle(ArRobotJoyHandler self) -> int"""
        return _AriaPy.ArRobotJoyHandler_getRawThrottle(self)

ArRobotJoyHandler_swigregister = _AriaPy.ArRobotJoyHandler_swigregister
ArRobotJoyHandler_swigregister(ArRobotJoyHandler)

class ArRobotPacket(ArBasePacket):
    """Proxy of C++ ArRobotPacket 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, sync1=0xfa, sync2=0xfb):
        """
        __init__(ArRobotPacket self, unsigned char sync1=0xfa, unsigned char sync2=0xfb) -> ArRobotPacket
        __init__(ArRobotPacket self, unsigned char sync1=0xfa) -> ArRobotPacket
        __init__(ArRobotPacket self) -> ArRobotPacket
        """
        this = _AriaPy.new_ArRobotPacket(sync1, sync2)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotPacket
    __del__ = lambda self: None

    def verifyCheckSum(self):
        """verifyCheckSum(ArRobotPacket self) -> bool"""
        return _AriaPy.ArRobotPacket_verifyCheckSum(self)


    def getID(self):
        """getID(ArRobotPacket self) -> ArTypes::UByte"""
        return _AriaPy.ArRobotPacket_getID(self)


    def setID(self, id):
        """setID(ArRobotPacket self, ArTypes::UByte id)"""
        return _AriaPy.ArRobotPacket_setID(self, id)


    def calcCheckSum(self):
        """calcCheckSum(ArRobotPacket self) -> ArTypes::Byte2"""
        return _AriaPy.ArRobotPacket_calcCheckSum(self)


    def finalizePacket(self):
        """finalizePacket(ArRobotPacket self)"""
        return _AriaPy.ArRobotPacket_finalizePacket(self)


    def getTimeReceived(self):
        """getTimeReceived(ArRobotPacket self) -> ArTime"""
        return _AriaPy.ArRobotPacket_getTimeReceived(self)


    def setTimeReceived(self, timeReceived):
        """setTimeReceived(ArRobotPacket self, ArTime timeReceived)"""
        return _AriaPy.ArRobotPacket_setTimeReceived(self, timeReceived)


    def log(self):
        """log(ArRobotPacket self)"""
        return _AriaPy.ArRobotPacket_log(self)

ArRobotPacket_swigregister = _AriaPy.ArRobotPacket_swigregister
ArRobotPacket_swigregister(ArRobotPacket)

class ArRobotPacketReceiver(object):
    """Proxy of C++ ArRobotPacketReceiver 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__(ArRobotPacketReceiver self, bool allocatePackets=False, unsigned char sync1=0xfa, unsigned char sync2=0xfb) -> ArRobotPacketReceiver
        __init__(ArRobotPacketReceiver self, bool allocatePackets=False, unsigned char sync1=0xfa) -> ArRobotPacketReceiver
        __init__(ArRobotPacketReceiver self, bool allocatePackets=False) -> ArRobotPacketReceiver
        __init__(ArRobotPacketReceiver self) -> ArRobotPacketReceiver
        __init__(ArRobotPacketReceiver self, ArDeviceConnection deviceConnection, bool allocatePackets=False, unsigned char sync1=0xfa, unsigned char sync2=0xfb) -> ArRobotPacketReceiver
        __init__(ArRobotPacketReceiver self, ArDeviceConnection deviceConnection, bool allocatePackets=False, unsigned char sync1=0xfa) -> ArRobotPacketReceiver
        __init__(ArRobotPacketReceiver self, ArDeviceConnection deviceConnection, bool allocatePackets=False) -> ArRobotPacketReceiver
        __init__(ArRobotPacketReceiver self, ArDeviceConnection deviceConnection) -> ArRobotPacketReceiver
        __init__(ArRobotPacketReceiver self, ArDeviceConnection deviceConnection, bool allocatePackets, unsigned char sync1, unsigned char sync2, bool tracking, char const * trackingLogName) -> ArRobotPacketReceiver
        """
        this = _AriaPy.new_ArRobotPacketReceiver(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotPacketReceiver
    __del__ = lambda self: None

    def receivePacket(self, msWait=0):
        """
        receivePacket(ArRobotPacketReceiver self, unsigned int msWait=0) -> ArRobotPacket
        receivePacket(ArRobotPacketReceiver self) -> ArRobotPacket
        """
        return _AriaPy.ArRobotPacketReceiver_receivePacket(self, msWait)


    def setDeviceConnection(self, deviceConnection):
        """setDeviceConnection(ArRobotPacketReceiver self, ArDeviceConnection deviceConnection)"""
        return _AriaPy.ArRobotPacketReceiver_setDeviceConnection(self, deviceConnection)


    def getDeviceConnection(self):
        """getDeviceConnection(ArRobotPacketReceiver self) -> ArDeviceConnection"""
        return _AriaPy.ArRobotPacketReceiver_getDeviceConnection(self)


    def isAllocatingPackets(self):
        """isAllocatingPackets(ArRobotPacketReceiver self) -> bool"""
        return _AriaPy.ArRobotPacketReceiver_isAllocatingPackets(self)


    def setAllocatingPackets(self, allocatePackets):
        """setAllocatingPackets(ArRobotPacketReceiver self, bool allocatePackets)"""
        return _AriaPy.ArRobotPacketReceiver_setAllocatingPackets(self, allocatePackets)


    def setTracking(self, tracking):
        """setTracking(ArRobotPacketReceiver self, bool tracking)"""
        return _AriaPy.ArRobotPacketReceiver_setTracking(self, tracking)


    def setTrackingLogName(self, trackingLogName):
        """setTrackingLogName(ArRobotPacketReceiver self, char const * trackingLogName)"""
        return _AriaPy.ArRobotPacketReceiver_setTrackingLogName(self, trackingLogName)


    def setPacketReceivedCallback(self, functor):
        """setPacketReceivedCallback(ArRobotPacketReceiver self, ArFunctor1_ArRobotPacketP functor)"""
        return _AriaPy.ArRobotPacketReceiver_setPacketReceivedCallback(self, functor)

ArRobotPacketReceiver_swigregister = _AriaPy.ArRobotPacketReceiver_swigregister
ArRobotPacketReceiver_swigregister(ArRobotPacketReceiver)

class ArRobotPacketSender(object):
    """Proxy of C++ ArRobotPacketSender 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__(ArRobotPacketSender self, unsigned char sync1=0xfa, unsigned char sync2=0xfb) -> ArRobotPacketSender
        __init__(ArRobotPacketSender self, unsigned char sync1=0xfa) -> ArRobotPacketSender
        __init__(ArRobotPacketSender self) -> ArRobotPacketSender
        __init__(ArRobotPacketSender self, ArDeviceConnection deviceConnection, unsigned char sync1=0xfa, unsigned char sync2=0xfb) -> ArRobotPacketSender
        __init__(ArRobotPacketSender self, ArDeviceConnection deviceConnection, unsigned char sync1=0xfa) -> ArRobotPacketSender
        __init__(ArRobotPacketSender self, ArDeviceConnection deviceConnection) -> ArRobotPacketSender
        __init__(ArRobotPacketSender self, ArDeviceConnection deviceConnection, unsigned char sync1, unsigned char sync2, bool tracking, char const * trackingLogName) -> ArRobotPacketSender
        """
        this = _AriaPy.new_ArRobotPacketSender(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotPacketSender
    __del__ = lambda self: None

    def com(self, command):
        """com(ArRobotPacketSender self, unsigned char command) -> bool"""
        return _AriaPy.ArRobotPacketSender_com(self, command)


    def comInt(self, command, argument):
        """comInt(ArRobotPacketSender self, unsigned char command, short argument) -> bool"""
        return _AriaPy.ArRobotPacketSender_comInt(self, command, argument)


    def com2Bytes(self, command, high, low):
        """com2Bytes(ArRobotPacketSender self, unsigned char command, char high, char low) -> bool"""
        return _AriaPy.ArRobotPacketSender_com2Bytes(self, command, high, low)


    def comStr(self, command, argument):
        """comStr(ArRobotPacketSender self, unsigned char command, char const * argument) -> bool"""
        return _AriaPy.ArRobotPacketSender_comStr(self, command, argument)


    def comStrN(self, command, str, size):
        """comStrN(ArRobotPacketSender self, unsigned char command, char const * str, int size) -> bool"""
        return _AriaPy.ArRobotPacketSender_comStrN(self, command, str, size)


    def comDataN(self, command, data, size):
        """comDataN(ArRobotPacketSender self, unsigned char command, char const * data, int size) -> bool"""
        return _AriaPy.ArRobotPacketSender_comDataN(self, command, data, size)


    def sendPacket(self, packet):
        """sendPacket(ArRobotPacketSender self, ArRobotPacket packet) -> bool"""
        return _AriaPy.ArRobotPacketSender_sendPacket(self, packet)


    def setDeviceConnection(self, deviceConnection):
        """setDeviceConnection(ArRobotPacketSender self, ArDeviceConnection deviceConnection)"""
        return _AriaPy.ArRobotPacketSender_setDeviceConnection(self, deviceConnection)


    def getDeviceConnection(self):
        """getDeviceConnection(ArRobotPacketSender self) -> ArDeviceConnection"""
        return _AriaPy.ArRobotPacketSender_getDeviceConnection(self)


    def setPacketSentCallback(self, functor):
        """setPacketSentCallback(ArRobotPacketSender self, ArFunctor1_ArRobotPacketP functor)"""
        return _AriaPy.ArRobotPacketSender_setPacketSentCallback(self, functor)

ArRobotPacketSender_swigregister = _AriaPy.ArRobotPacketSender_swigregister
ArRobotPacketSender_swigregister(ArRobotPacketSender)

class ArRobotParams(ArConfig):
    """Proxy of C++ ArRobotParams 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):
        """__init__(ArRobotParams self) -> ArRobotParams"""
        this = _AriaPy.new_ArRobotParams()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotParams
    __del__ = lambda self: None

    def getClassName(self):
        """getClassName(ArRobotParams self) -> char const *"""
        return _AriaPy.ArRobotParams_getClassName(self)


    def getSubClassName(self):
        """getSubClassName(ArRobotParams self) -> char const *"""
        return _AriaPy.ArRobotParams_getSubClassName(self)


    def getRobotRadius(self):
        """getRobotRadius(ArRobotParams self) -> double"""
        return _AriaPy.ArRobotParams_getRobotRadius(self)


    def getRobotDiagonal(self):
        """getRobotDiagonal(ArRobotParams self) -> double"""
        return _AriaPy.ArRobotParams_getRobotDiagonal(self)


    def getRobotWidth(self):
        """getRobotWidth(ArRobotParams self) -> double"""
        return _AriaPy.ArRobotParams_getRobotWidth(self)


    def getRobotLength(self):
        """getRobotLength(ArRobotParams self) -> double"""
        return _AriaPy.ArRobotParams_getRobotLength(self)


    def getRobotLengthFront(self):
        """getRobotLengthFront(ArRobotParams self) -> double"""
        return _AriaPy.ArRobotParams_getRobotLengthFront(self)


    def getRobotLengthRear(self):
        """getRobotLengthRear(ArRobotParams self) -> double"""
        return _AriaPy.ArRobotParams_getRobotLengthRear(self)


    def isHolonomic(self):
        """isHolonomic(ArRobotParams self) -> bool"""
        return _AriaPy.ArRobotParams_isHolonomic(self)


    def hasMoveCommand(self):
        """hasMoveCommand(ArRobotParams self) -> bool"""
        return _AriaPy.ArRobotParams_hasMoveCommand(self)


    def getAbsoluteMaxVelocity(self):
        """getAbsoluteMaxVelocity(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getAbsoluteMaxVelocity(self)


    def getAbsoluteMaxRotVelocity(self):
        """getAbsoluteMaxRotVelocity(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getAbsoluteMaxRotVelocity(self)


    def getAbsoluteMaxLatVelocity(self):
        """getAbsoluteMaxLatVelocity(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getAbsoluteMaxLatVelocity(self)


    def getRequestIOPackets(self):
        """getRequestIOPackets(ArRobotParams self) -> bool"""
        return _AriaPy.ArRobotParams_getRequestIOPackets(self)


    def getRequestEncoderPackets(self):
        """getRequestEncoderPackets(ArRobotParams self) -> bool"""
        return _AriaPy.ArRobotParams_getRequestEncoderPackets(self)


    def getSwitchToBaudRate(self):
        """getSwitchToBaudRate(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getSwitchToBaudRate(self)


    def getAngleConvFactor(self):
        """getAngleConvFactor(ArRobotParams self) -> double"""
        return _AriaPy.ArRobotParams_getAngleConvFactor(self)


    def getDistConvFactor(self):
        """getDistConvFactor(ArRobotParams self) -> double"""
        return _AriaPy.ArRobotParams_getDistConvFactor(self)


    def getVelConvFactor(self):
        """getVelConvFactor(ArRobotParams self) -> double"""
        return _AriaPy.ArRobotParams_getVelConvFactor(self)


    def getRangeConvFactor(self):
        """getRangeConvFactor(ArRobotParams self) -> double"""
        return _AriaPy.ArRobotParams_getRangeConvFactor(self)


    def getDiffConvFactor(self):
        """getDiffConvFactor(ArRobotParams self) -> double"""
        return _AriaPy.ArRobotParams_getDiffConvFactor(self)


    def getVel2Divisor(self):
        """getVel2Divisor(ArRobotParams self) -> double"""
        return _AriaPy.ArRobotParams_getVel2Divisor(self)


    def getGyroScaler(self):
        """getGyroScaler(ArRobotParams self) -> double"""
        return _AriaPy.ArRobotParams_getGyroScaler(self)


    def haveTableSensingIR(self):
        """haveTableSensingIR(ArRobotParams self) -> bool"""
        return _AriaPy.ArRobotParams_haveTableSensingIR(self)


    def haveNewTableSensingIR(self):
        """haveNewTableSensingIR(ArRobotParams self) -> bool"""
        return _AriaPy.ArRobotParams_haveNewTableSensingIR(self)


    def haveFrontBumpers(self):
        """haveFrontBumpers(ArRobotParams self) -> bool"""
        return _AriaPy.ArRobotParams_haveFrontBumpers(self)


    def numFrontBumpers(self):
        """numFrontBumpers(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_numFrontBumpers(self)


    def haveRearBumpers(self):
        """haveRearBumpers(ArRobotParams self) -> bool"""
        return _AriaPy.ArRobotParams_haveRearBumpers(self)


    def numRearBumpers(self):
        """numRearBumpers(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_numRearBumpers(self)


    def getNumIR(self):
        """getNumIR(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getNumIR(self)


    def haveIR(self, number):
        """haveIR(ArRobotParams self, int number) -> bool"""
        return _AriaPy.ArRobotParams_haveIR(self, number)


    def getIRX(self, number):
        """getIRX(ArRobotParams self, int number) -> int"""
        return _AriaPy.ArRobotParams_getIRX(self, number)


    def getIRY(self, number):
        """getIRY(ArRobotParams self, int number) -> int"""
        return _AriaPy.ArRobotParams_getIRY(self, number)


    def getIRType(self, number):
        """getIRType(ArRobotParams self, int number) -> int"""
        return _AriaPy.ArRobotParams_getIRType(self, number)


    def getIRCycles(self, number):
        """getIRCycles(ArRobotParams self, int number) -> int"""
        return _AriaPy.ArRobotParams_getIRCycles(self, number)


    def getNumSonar(self):
        """getNumSonar(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getNumSonar(self)


    def getLaserPossessed(self):
        """getLaserPossessed(ArRobotParams self) -> bool"""
        return _AriaPy.ArRobotParams_getLaserPossessed(self)


    def getLaserType(self, laserNumber=1):
        """
        getLaserType(ArRobotParams self, int laserNumber=1) -> char const
        getLaserType(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserType(self, laserNumber)


    def getLaserPortType(self, laserNumber=1):
        """
        getLaserPortType(ArRobotParams self, int laserNumber=1) -> char const
        getLaserPortType(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserPortType(self, laserNumber)


    def getLaserPort(self, laserNumber=1):
        """
        getLaserPort(ArRobotParams self, int laserNumber=1) -> char const
        getLaserPort(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserPort(self, laserNumber)


    def getConnectLaser(self, laserNumber=1):
        """
        getConnectLaser(ArRobotParams self, int laserNumber=1) -> bool
        getConnectLaser(ArRobotParams self) -> bool
        """
        return _AriaPy.ArRobotParams_getConnectLaser(self, laserNumber)


    def getLaserFlipped(self, laserNumber=1):
        """
        getLaserFlipped(ArRobotParams self, int laserNumber=1) -> bool
        getLaserFlipped(ArRobotParams self) -> bool
        """
        return _AriaPy.ArRobotParams_getLaserFlipped(self, laserNumber)


    def getLaserPowerControlled(self, laserNumber=1):
        """
        getLaserPowerControlled(ArRobotParams self, int laserNumber=1) -> bool
        getLaserPowerControlled(ArRobotParams self) -> bool
        """
        return _AriaPy.ArRobotParams_getLaserPowerControlled(self, laserNumber)


    def getLaserMaxRange(self, laserNumber=1):
        """
        getLaserMaxRange(ArRobotParams self, int laserNumber=1) -> int
        getLaserMaxRange(ArRobotParams self) -> int
        """
        return _AriaPy.ArRobotParams_getLaserMaxRange(self, laserNumber)


    def getLaserCumulativeBufferSize(self, laserNumber=1):
        """
        getLaserCumulativeBufferSize(ArRobotParams self, int laserNumber=1) -> int
        getLaserCumulativeBufferSize(ArRobotParams self) -> int
        """
        return _AriaPy.ArRobotParams_getLaserCumulativeBufferSize(self, laserNumber)


    def getLaserX(self, laserNumber=1):
        """
        getLaserX(ArRobotParams self, int laserNumber=1) -> int
        getLaserX(ArRobotParams self) -> int
        """
        return _AriaPy.ArRobotParams_getLaserX(self, laserNumber)


    def getLaserY(self, laserNumber=1):
        """
        getLaserY(ArRobotParams self, int laserNumber=1) -> int
        getLaserY(ArRobotParams self) -> int
        """
        return _AriaPy.ArRobotParams_getLaserY(self, laserNumber)


    def getLaserTh(self, laserNumber=1):
        """
        getLaserTh(ArRobotParams self, int laserNumber=1) -> double
        getLaserTh(ArRobotParams self) -> double
        """
        return _AriaPy.ArRobotParams_getLaserTh(self, laserNumber)


    def getLaserZ(self, laserNumber=1):
        """
        getLaserZ(ArRobotParams self, int laserNumber=1) -> int
        getLaserZ(ArRobotParams self) -> int
        """
        return _AriaPy.ArRobotParams_getLaserZ(self, laserNumber)


    def getLaserIgnore(self, laserNumber=1):
        """
        getLaserIgnore(ArRobotParams self, int laserNumber=1) -> char const
        getLaserIgnore(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserIgnore(self, laserNumber)


    def getLaserStartDegrees(self, laserNumber=1):
        """
        getLaserStartDegrees(ArRobotParams self, int laserNumber=1) -> char const
        getLaserStartDegrees(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserStartDegrees(self, laserNumber)


    def getLaserEndDegrees(self, laserNumber=1):
        """
        getLaserEndDegrees(ArRobotParams self, int laserNumber=1) -> char const
        getLaserEndDegrees(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserEndDegrees(self, laserNumber)


    def getLaserDegreesChoice(self, laserNumber=1):
        """
        getLaserDegreesChoice(ArRobotParams self, int laserNumber=1) -> char const
        getLaserDegreesChoice(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserDegreesChoice(self, laserNumber)


    def getLaserIncrement(self, laserNumber=1):
        """
        getLaserIncrement(ArRobotParams self, int laserNumber=1) -> char const
        getLaserIncrement(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserIncrement(self, laserNumber)


    def getLaserIncrementChoice(self, laserNumber=1):
        """
        getLaserIncrementChoice(ArRobotParams self, int laserNumber=1) -> char const
        getLaserIncrementChoice(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserIncrementChoice(self, laserNumber)


    def getLaserUnitsChoice(self, laserNumber=1):
        """
        getLaserUnitsChoice(ArRobotParams self, int laserNumber=1) -> char const
        getLaserUnitsChoice(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserUnitsChoice(self, laserNumber)


    def getLaserReflectorBitsChoice(self, laserNumber=1):
        """
        getLaserReflectorBitsChoice(ArRobotParams self, int laserNumber=1) -> char const
        getLaserReflectorBitsChoice(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserReflectorBitsChoice(self, laserNumber)


    def getLaserStartingBaudChoice(self, laserNumber=1):
        """
        getLaserStartingBaudChoice(ArRobotParams self, int laserNumber=1) -> char const
        getLaserStartingBaudChoice(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserStartingBaudChoice(self, laserNumber)


    def getLaserAutoBaudChoice(self, laserNumber=1):
        """
        getLaserAutoBaudChoice(ArRobotParams self, int laserNumber=1) -> char const
        getLaserAutoBaudChoice(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserAutoBaudChoice(self, laserNumber)


    def getLaserSection(self, laserNumber=1):
        """
        getLaserSection(ArRobotParams self, int laserNumber=1) -> char const
        getLaserSection(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserSection(self, laserNumber)


    def getLaserPowerOutput(self, laserNumber=1):
        """
        getLaserPowerOutput(ArRobotParams self, int laserNumber=1) -> char const
        getLaserPowerOutput(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLaserPowerOutput(self, laserNumber)


    def getBatteryMTXBoardType(self, batteryNumber=1):
        """
        getBatteryMTXBoardType(ArRobotParams self, int batteryNumber=1) -> char const
        getBatteryMTXBoardType(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getBatteryMTXBoardType(self, batteryNumber)


    def getBatteryMTXBoardPortType(self, batteryNumber=1):
        """
        getBatteryMTXBoardPortType(ArRobotParams self, int batteryNumber=1) -> char const
        getBatteryMTXBoardPortType(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getBatteryMTXBoardPortType(self, batteryNumber)


    def getBatteryMTXBoardPort(self, batteryNumber=1):
        """
        getBatteryMTXBoardPort(ArRobotParams self, int batteryNumber=1) -> char const
        getBatteryMTXBoardPort(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getBatteryMTXBoardPort(self, batteryNumber)


    def getBatteryMTXBoardBaud(self, batteryNumber=1):
        """
        getBatteryMTXBoardBaud(ArRobotParams self, int batteryNumber=1) -> int
        getBatteryMTXBoardBaud(ArRobotParams self) -> int
        """
        return _AriaPy.ArRobotParams_getBatteryMTXBoardBaud(self, batteryNumber)


    def getBatteryMTXBoardAutoConn(self, batteryNumber=1):
        """
        getBatteryMTXBoardAutoConn(ArRobotParams self, int batteryNumber=1) -> bool
        getBatteryMTXBoardAutoConn(ArRobotParams self) -> bool
        """
        return _AriaPy.ArRobotParams_getBatteryMTXBoardAutoConn(self, batteryNumber)


    def getLCDMTXBoardType(self, lcdNumber=1):
        """
        getLCDMTXBoardType(ArRobotParams self, int lcdNumber=1) -> char const
        getLCDMTXBoardType(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLCDMTXBoardType(self, lcdNumber)


    def getLCDMTXBoardPortType(self, lcdNumber=1):
        """
        getLCDMTXBoardPortType(ArRobotParams self, int lcdNumber=1) -> char const
        getLCDMTXBoardPortType(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLCDMTXBoardPortType(self, lcdNumber)


    def getLCDMTXBoardPort(self, lcdNumber=1):
        """
        getLCDMTXBoardPort(ArRobotParams self, int lcdNumber=1) -> char const
        getLCDMTXBoardPort(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLCDMTXBoardPort(self, lcdNumber)


    def getLCDMTXBoardBaud(self, lcdNumber=1):
        """
        getLCDMTXBoardBaud(ArRobotParams self, int lcdNumber=1) -> int
        getLCDMTXBoardBaud(ArRobotParams self) -> int
        """
        return _AriaPy.ArRobotParams_getLCDMTXBoardBaud(self, lcdNumber)


    def getLCDMTXBoardAutoConn(self, lcdNumber=1):
        """
        getLCDMTXBoardAutoConn(ArRobotParams self, int lcdNumber=1) -> bool
        getLCDMTXBoardAutoConn(ArRobotParams self) -> bool
        """
        return _AriaPy.ArRobotParams_getLCDMTXBoardAutoConn(self, lcdNumber)


    def getLCDMTXBoardConnFailOption(self, lcdNumber=1):
        """
        getLCDMTXBoardConnFailOption(ArRobotParams self, int lcdNumber=1) -> bool
        getLCDMTXBoardConnFailOption(ArRobotParams self) -> bool
        """
        return _AriaPy.ArRobotParams_getLCDMTXBoardConnFailOption(self, lcdNumber)


    def getLCDMTXBoardPowerOutput(self, lcdNumber=1):
        """
        getLCDMTXBoardPowerOutput(ArRobotParams self, int lcdNumber=1) -> char const
        getLCDMTXBoardPowerOutput(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getLCDMTXBoardPowerOutput(self, lcdNumber)


    def getSonarMTXBoardType(self, sonarNumber=1):
        """
        getSonarMTXBoardType(ArRobotParams self, int sonarNumber=1) -> char const
        getSonarMTXBoardType(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getSonarMTXBoardType(self, sonarNumber)


    def getSonarMTXBoardPortType(self, sonarNumber=1):
        """
        getSonarMTXBoardPortType(ArRobotParams self, int sonarNumber=1) -> char const
        getSonarMTXBoardPortType(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getSonarMTXBoardPortType(self, sonarNumber)


    def getSonarMTXBoardPort(self, sonarNumber=1):
        """
        getSonarMTXBoardPort(ArRobotParams self, int sonarNumber=1) -> char const
        getSonarMTXBoardPort(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getSonarMTXBoardPort(self, sonarNumber)


    def getSonarMTXBoardBaud(self, sonarNumber=1):
        """
        getSonarMTXBoardBaud(ArRobotParams self, int sonarNumber=1) -> int
        getSonarMTXBoardBaud(ArRobotParams self) -> int
        """
        return _AriaPy.ArRobotParams_getSonarMTXBoardBaud(self, sonarNumber)


    def getSonarMTXBoardAutoConn(self, sonarNumber=1):
        """
        getSonarMTXBoardAutoConn(ArRobotParams self, int sonarNumber=1) -> bool
        getSonarMTXBoardAutoConn(ArRobotParams self) -> bool
        """
        return _AriaPy.ArRobotParams_getSonarMTXBoardAutoConn(self, sonarNumber)


    def getSonarMTXBoardDelay(self, sonarBoardNum=1):
        """
        getSonarMTXBoardDelay(ArRobotParams self, int sonarBoardNum=1) -> int
        getSonarMTXBoardDelay(ArRobotParams self) -> int
        """
        return _AriaPy.ArRobotParams_getSonarMTXBoardDelay(self, sonarBoardNum)


    def getSonarMTXBoardGain(self, sonarBoardNum=1):
        """
        getSonarMTXBoardGain(ArRobotParams self, int sonarBoardNum=1) -> int
        getSonarMTXBoardGain(ArRobotParams self) -> int
        """
        return _AriaPy.ArRobotParams_getSonarMTXBoardGain(self, sonarBoardNum)


    def getSonarMTXBoardDetectionThreshold(self, sonarBoardNum=1):
        """
        getSonarMTXBoardDetectionThreshold(ArRobotParams self, int sonarBoardNum=1) -> int
        getSonarMTXBoardDetectionThreshold(ArRobotParams self) -> int
        """
        return _AriaPy.ArRobotParams_getSonarMTXBoardDetectionThreshold(self, sonarBoardNum)


    def getSonarMTXBoardMaxRange(self, sonarBoardNum=1):
        """
        getSonarMTXBoardMaxRange(ArRobotParams self, int sonarBoardNum=1) -> int
        getSonarMTXBoardMaxRange(ArRobotParams self) -> int
        """
        return _AriaPy.ArRobotParams_getSonarMTXBoardMaxRange(self, sonarBoardNum)


    def getSonarMTXBoardUseForAutonomousDriving(self, sonarBoardNum=1):
        """
        getSonarMTXBoardUseForAutonomousDriving(ArRobotParams self, int sonarBoardNum=1) -> int
        getSonarMTXBoardUseForAutonomousDriving(ArRobotParams self) -> int
        """
        return _AriaPy.ArRobotParams_getSonarMTXBoardUseForAutonomousDriving(self, sonarBoardNum)


    def getSonarMTXBoardPowerOutput(self, sonarBoardNum=1):
        """
        getSonarMTXBoardPowerOutput(ArRobotParams self, int sonarBoardNum=1) -> char const
        getSonarMTXBoardPowerOutput(ArRobotParams self) -> char const *
        """
        return _AriaPy.ArRobotParams_getSonarMTXBoardPowerOutput(self, sonarBoardNum)


    def getNumSonarOnMTXBoard(self, sonarBoardNum=1):
        """
        getNumSonarOnMTXBoard(ArRobotParams self, int sonarBoardNum=1) -> int
        getNumSonarOnMTXBoard(ArRobotParams self) -> int
        """
        return _AriaPy.ArRobotParams_getNumSonarOnMTXBoard(self, sonarBoardNum)


    def getNumSonarUnits(self):
        """getNumSonarUnits(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getNumSonarUnits(self)


    def haveSonar(self, boardNum):
        """haveSonar(ArRobotParams self, int boardNum) -> bool"""
        return _AriaPy.ArRobotParams_haveSonar(self, boardNum)


    def getSonarX(self, number):
        """getSonarX(ArRobotParams self, int number) -> int"""
        return _AriaPy.ArRobotParams_getSonarX(self, number)


    def getSonarY(self, number):
        """getSonarY(ArRobotParams self, int number) -> int"""
        return _AriaPy.ArRobotParams_getSonarY(self, number)


    def getSonarTh(self, number):
        """getSonarTh(ArRobotParams self, int number) -> int"""
        return _AriaPy.ArRobotParams_getSonarTh(self, number)


    def getSonarGain(self, number):
        """getSonarGain(ArRobotParams self, int number) -> int"""
        return _AriaPy.ArRobotParams_getSonarGain(self, number)


    def getSonarDetectionThreshold(self, number):
        """getSonarDetectionThreshold(ArRobotParams self, int number) -> int"""
        return _AriaPy.ArRobotParams_getSonarDetectionThreshold(self, number)


    def getSonarMaxRange(self, number):
        """getSonarMaxRange(ArRobotParams self, int number) -> int"""
        return _AriaPy.ArRobotParams_getSonarMaxRange(self, number)


    def getSonarUseForAutonomousDriving(self, number):
        """getSonarUseForAutonomousDriving(ArRobotParams self, int number) -> int"""
        return _AriaPy.ArRobotParams_getSonarUseForAutonomousDriving(self, number)


    def getSonarMTXBoard(self, number):
        """getSonarMTXBoard(ArRobotParams self, int number) -> int"""
        return _AriaPy.ArRobotParams_getSonarMTXBoard(self, number)


    def getSonarMTXBoardUnitPosition(self, number):
        """getSonarMTXBoardUnitPosition(ArRobotParams self, int number) -> int"""
        return _AriaPy.ArRobotParams_getSonarMTXBoardUnitPosition(self, number)


    def hasSettableVelMaxes(self):
        """hasSettableVelMaxes(ArRobotParams self) -> bool"""
        return _AriaPy.ArRobotParams_hasSettableVelMaxes(self)


    def getTransVelMax(self):
        """getTransVelMax(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getTransVelMax(self)


    def getRotVelMax(self):
        """getRotVelMax(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getRotVelMax(self)


    def hasSettableAccsDecs(self):
        """hasSettableAccsDecs(ArRobotParams self) -> bool"""
        return _AriaPy.ArRobotParams_hasSettableAccsDecs(self)


    def getTransAccel(self):
        """getTransAccel(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getTransAccel(self)


    def getTransDecel(self):
        """getTransDecel(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getTransDecel(self)


    def getRotAccel(self):
        """getRotAccel(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getRotAccel(self)


    def getRotDecel(self):
        """getRotDecel(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getRotDecel(self)


    def hasLatVel(self):
        """hasLatVel(ArRobotParams self) -> bool"""
        return _AriaPy.ArRobotParams_hasLatVel(self)


    def getLatVelMax(self):
        """getLatVelMax(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getLatVelMax(self)


    def getLatAccel(self):
        """getLatAccel(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getLatAccel(self)


    def getLatDecel(self):
        """getLatDecel(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getLatDecel(self)


    def save(self):
        """save(ArRobotParams self) -> bool"""
        return _AriaPy.ArRobotParams_save(self)


    def getGPSX(self):
        """getGPSX(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getGPSX(self)


    def getGPSY(self):
        """getGPSY(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getGPSY(self)


    def getGPSBaud(self):
        """getGPSBaud(ArRobotParams self) -> int"""
        return _AriaPy.ArRobotParams_getGPSBaud(self)


    def getGPSPort(self):
        """getGPSPort(ArRobotParams self) -> char const *"""
        return _AriaPy.ArRobotParams_getGPSPort(self)


    def getGPSType(self):
        """getGPSType(ArRobotParams self) -> char const *"""
        return _AriaPy.ArRobotParams_getGPSType(self)


    def getCompassType(self):
        """getCompassType(ArRobotParams self) -> char const *"""
        return _AriaPy.ArRobotParams_getCompassType(self)


    def getCompassPort(self):
        """getCompassPort(ArRobotParams self) -> char const *"""
        return _AriaPy.ArRobotParams_getCompassPort(self)


    def internalGetDistConvFactorPointer(self):
        """internalGetDistConvFactorPointer(ArRobotParams self) -> double *"""
        return _AriaPy.ArRobotParams_internalGetDistConvFactorPointer(self)


    def internalSetUseDefaultBehavior(useDefaultBehavior, owerOutputDisplayHint):
        """internalSetUseDefaultBehavior(bool useDefaultBehavior, char const * owerOutputDisplayHint)"""
        return _AriaPy.ArRobotParams_internalSetUseDefaultBehavior(useDefaultBehavior, owerOutputDisplayHint)

    internalSetUseDefaultBehavior = staticmethod(internalSetUseDefaultBehavior)

    def internalGetUseDefaultBehavior():
        """internalGetUseDefaultBehavior() -> bool"""
        return _AriaPy.ArRobotParams_internalGetUseDefaultBehavior()

    internalGetUseDefaultBehavior = staticmethod(internalGetUseDefaultBehavior)

    def internalAddToConfigCommercial(self, config):
        """internalAddToConfigCommercial(ArRobotParams self, ArConfig config)"""
        return _AriaPy.ArRobotParams_internalAddToConfigCommercial(self, config)


    def internalAddToConfigDefault(self):
        """internalAddToConfigDefault(ArRobotParams self)"""
        return _AriaPy.ArRobotParams_internalAddToConfigDefault(self)


    def getVideoParams(self):
        """getVideoParams(ArRobotParams self) -> std::vector< ArVideoParams,std::allocator< ArVideoParams > > const &"""
        return _AriaPy.ArRobotParams_getVideoParams(self)


    def getPTZParams(self):
        """getPTZParams(ArRobotParams self) -> std::vector< ArPTZParams,std::allocator< ArPTZParams > > const &"""
        return _AriaPy.ArRobotParams_getPTZParams(self)

ArRobotParams_swigregister = _AriaPy.ArRobotParams_swigregister
ArRobotParams_swigregister(ArRobotParams)

def ArRobotParams_internalSetUseDefaultBehavior(useDefaultBehavior, owerOutputDisplayHint):
    """ArRobotParams_internalSetUseDefaultBehavior(bool useDefaultBehavior, char const * owerOutputDisplayHint)"""
    return _AriaPy.ArRobotParams_internalSetUseDefaultBehavior(useDefaultBehavior, owerOutputDisplayHint)

def ArRobotParams_internalGetUseDefaultBehavior():
    """ArRobotParams_internalGetUseDefaultBehavior() -> bool"""
    return _AriaPy.ArRobotParams_internalGetUseDefaultBehavior()

class ArRVisionPacket(ArBasePacket):
    """Proxy of C++ ArRVisionPacket 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, bufferSize=15):
        """
        __init__(ArRVisionPacket self, ArTypes::UByte2 bufferSize=15) -> ArRVisionPacket
        __init__(ArRVisionPacket self) -> ArRVisionPacket
        """
        this = _AriaPy.new_ArRVisionPacket(bufferSize)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRVisionPacket
    __del__ = lambda self: None

    def uByteToBuf(self, val):
        """uByteToBuf(ArRVisionPacket self, ArTypes::UByte val)"""
        return _AriaPy.ArRVisionPacket_uByteToBuf(self, val)


    def byte2ToBuf(self, val):
        """byte2ToBuf(ArRVisionPacket self, ArTypes::Byte2 val)"""
        return _AriaPy.ArRVisionPacket_byte2ToBuf(self, val)


    def byte2ToBufAtPos(self, val, pose):
        """byte2ToBufAtPos(ArRVisionPacket self, ArTypes::Byte2 val, ArTypes::UByte2 pose)"""
        return _AriaPy.ArRVisionPacket_byte2ToBufAtPos(self, val, pose)

ArRVisionPacket_swigregister = _AriaPy.ArRVisionPacket_swigregister
ArRVisionPacket_swigregister(ArRVisionPacket)

class ArRVisionPTZ(ArPTZ):
    """Proxy of C++ ArRVisionPTZ 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, robot):
        """__init__(ArRVisionPTZ self, ArRobot robot) -> ArRVisionPTZ"""
        this = _AriaPy.new_ArRVisionPTZ(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRVisionPTZ
    __del__ = lambda self: None

    def init(self):
        """init(ArRVisionPTZ self) -> bool"""
        return _AriaPy.ArRVisionPTZ_init(self)


    def getTypeName(self):
        """getTypeName(ArRVisionPTZ self) -> char const *"""
        return _AriaPy.ArRVisionPTZ_getTypeName(self)


    def setPort(self, port):
        """setPort(ArRVisionPTZ self, char const * port)"""
        return _AriaPy.ArRVisionPTZ_setPort(self, port)


    def canZoom(self):
        """canZoom(ArRVisionPTZ self) -> bool"""
        return _AriaPy.ArRVisionPTZ_canZoom(self)


    def zoom(self, zoomValue):
        """zoom(ArRVisionPTZ self, int zoomValue) -> bool"""
        return _AriaPy.ArRVisionPTZ_zoom(self, zoomValue)


    def zoomRel(self, zoomValue):
        """zoomRel(ArRVisionPTZ self, int zoomValue) -> bool"""
        return _AriaPy.ArRVisionPTZ_zoomRel(self, zoomValue)


    def getZoom(self):
        """getZoom(ArRVisionPTZ self) -> int"""
        return _AriaPy.ArRVisionPTZ_getZoom(self)


    def canGetRealPanTilt(self):
        """canGetRealPanTilt(ArRVisionPTZ self) -> bool"""
        return _AriaPy.ArRVisionPTZ_canGetRealPanTilt(self)


    def canGetRealZoom(self):
        """canGetRealZoom(ArRVisionPTZ self) -> bool"""
        return _AriaPy.ArRVisionPTZ_canGetRealZoom(self)


    def canGetFOV(self):
        """canGetFOV(ArRVisionPTZ self) -> bool"""
        return _AriaPy.ArRVisionPTZ_canGetFOV(self)


    def getFOVAtMaxZoom(self):
        """getFOVAtMaxZoom(ArRVisionPTZ self) -> double"""
        return _AriaPy.ArRVisionPTZ_getFOVAtMaxZoom(self)


    def getFOVAtMinZoom(self):
        """getFOVAtMinZoom(ArRVisionPTZ self) -> double"""
        return _AriaPy.ArRVisionPTZ_getFOVAtMinZoom(self)


    def readPacket(self):
        """readPacket(ArRVisionPTZ self) -> ArBasePacket"""
        return _AriaPy.ArRVisionPTZ_readPacket(self)

    MAX_PAN = _AriaPy.ArRVisionPTZ_MAX_PAN
    MIN_PAN = _AriaPy.ArRVisionPTZ_MIN_PAN
    MIN_TILT = _AriaPy.ArRVisionPTZ_MIN_TILT
    MAX_TILT = _AriaPy.ArRVisionPTZ_MAX_TILT
    MIN_ZOOM = _AriaPy.ArRVisionPTZ_MIN_ZOOM
    MAX_ZOOM = _AriaPy.ArRVisionPTZ_MAX_ZOOM
    TILT_OFFSET_IN_DEGREES = _AriaPy.ArRVisionPTZ_TILT_OFFSET_IN_DEGREES
    PAN_OFFSET_IN_DEGREES = _AriaPy.ArRVisionPTZ_PAN_OFFSET_IN_DEGREES
ArRVisionPTZ_swigregister = _AriaPy.ArRVisionPTZ_swigregister
ArRVisionPTZ_swigregister(ArRVisionPTZ)

class ArSensorReading(object):
    """Proxy of C++ ArSensorReading 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__(ArSensorReading self, double xPos=0.0, double yPos=0.0, double thPos=0.0) -> ArSensorReading
        __init__(ArSensorReading self, double xPos=0.0, double yPos=0.0) -> ArSensorReading
        __init__(ArSensorReading self, double xPos=0.0) -> ArSensorReading
        __init__(ArSensorReading self) -> ArSensorReading
        __init__(ArSensorReading self, ArSensorReading reading) -> ArSensorReading
        """
        this = _AriaPy.new_ArSensorReading(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSensorReading
    __del__ = lambda self: None

    def getRange(self):
        """getRange(ArSensorReading self) -> unsigned int"""
        return _AriaPy.ArSensorReading_getRange(self)


    def isNew(self, counter):
        """isNew(ArSensorReading self, unsigned int counter) -> bool"""
        return _AriaPy.ArSensorReading_isNew(self, counter)


    def getX(self):
        """getX(ArSensorReading self) -> double"""
        return _AriaPy.ArSensorReading_getX(self)


    def getY(self):
        """getY(ArSensorReading self) -> double"""
        return _AriaPy.ArSensorReading_getY(self)


    def getPose(self):
        """getPose(ArSensorReading self) -> ArPose"""
        return _AriaPy.ArSensorReading_getPose(self)


    def getLocalX(self):
        """getLocalX(ArSensorReading self) -> double"""
        return _AriaPy.ArSensorReading_getLocalX(self)


    def getLocalY(self):
        """getLocalY(ArSensorReading self) -> double"""
        return _AriaPy.ArSensorReading_getLocalY(self)


    def getLocalPose(self):
        """getLocalPose(ArSensorReading self) -> ArPose"""
        return _AriaPy.ArSensorReading_getLocalPose(self)


    def getPoseTaken(self):
        """getPoseTaken(ArSensorReading self) -> ArPose"""
        return _AriaPy.ArSensorReading_getPoseTaken(self)


    def getEncoderPoseTaken(self):
        """getEncoderPoseTaken(ArSensorReading self) -> ArPose"""
        return _AriaPy.ArSensorReading_getEncoderPoseTaken(self)


    def getSensorX(self):
        """getSensorX(ArSensorReading self) -> double"""
        return _AriaPy.ArSensorReading_getSensorX(self)


    def getSensorY(self):
        """getSensorY(ArSensorReading self) -> double"""
        return _AriaPy.ArSensorReading_getSensorY(self)


    def getSensorTh(self):
        """getSensorTh(ArSensorReading self) -> double"""
        return _AriaPy.ArSensorReading_getSensorTh(self)


    def getIgnoreThisReading(self):
        """getIgnoreThisReading(ArSensorReading self) -> bool"""
        return _AriaPy.ArSensorReading_getIgnoreThisReading(self)


    def getExtraInt(self):
        """getExtraInt(ArSensorReading self) -> int"""
        return _AriaPy.ArSensorReading_getExtraInt(self)


    def getSensorPosition(self):
        """getSensorPosition(ArSensorReading self) -> ArPose"""
        return _AriaPy.ArSensorReading_getSensorPosition(self)


    def getSensorDX(self):
        """getSensorDX(ArSensorReading self) -> double"""
        return _AriaPy.ArSensorReading_getSensorDX(self)


    def getSensorDY(self):
        """getSensorDY(ArSensorReading self) -> double"""
        return _AriaPy.ArSensorReading_getSensorDY(self)


    def getXTaken(self):
        """getXTaken(ArSensorReading self) -> double"""
        return _AriaPy.ArSensorReading_getXTaken(self)


    def getYTaken(self):
        """getYTaken(ArSensorReading self) -> double"""
        return _AriaPy.ArSensorReading_getYTaken(self)


    def getThTaken(self):
        """getThTaken(ArSensorReading self) -> double"""
        return _AriaPy.ArSensorReading_getThTaken(self)


    def getCounterTaken(self):
        """getCounterTaken(ArSensorReading self) -> unsigned int"""
        return _AriaPy.ArSensorReading_getCounterTaken(self)


    def getTimeTaken(self):
        """getTimeTaken(ArSensorReading self) -> ArTime"""
        return _AriaPy.ArSensorReading_getTimeTaken(self)


    def newData(self, *args):
        """
        newData(ArSensorReading self, int range, ArPose robotPose, ArPose encoderPose, ArTransform trans, unsigned int counter, ArTime timeTaken, bool ignoreThisReading=False, int extraInt=0)
        newData(ArSensorReading self, int range, ArPose robotPose, ArPose encoderPose, ArTransform trans, unsigned int counter, ArTime timeTaken, bool ignoreThisReading=False)
        newData(ArSensorReading self, int range, ArPose robotPose, ArPose encoderPose, ArTransform trans, unsigned int counter, ArTime timeTaken)
        newData(ArSensorReading self, int sx, int sy, ArPose robotPose, ArPose encoderPose, ArTransform trans, unsigned int counter, ArTime timeTaken, bool ignoreThisReading=False, int extraInt=0)
        newData(ArSensorReading self, int sx, int sy, ArPose robotPose, ArPose encoderPose, ArTransform trans, unsigned int counter, ArTime timeTaken, bool ignoreThisReading=False)
        newData(ArSensorReading self, int sx, int sy, ArPose robotPose, ArPose encoderPose, ArTransform trans, unsigned int counter, ArTime timeTaken)
        """
        return _AriaPy.ArSensorReading_newData(self, *args)


    def resetSensorPosition(self, xPos, yPos, thPos, forceComputation=False):
        """
        resetSensorPosition(ArSensorReading self, double xPos, double yPos, double thPos, bool forceComputation=False)
        resetSensorPosition(ArSensorReading self, double xPos, double yPos, double thPos)
        """
        return _AriaPy.ArSensorReading_resetSensorPosition(self, xPos, yPos, thPos, forceComputation)


    def setIgnoreThisReading(self, ignoreThisReading):
        """setIgnoreThisReading(ArSensorReading self, bool ignoreThisReading)"""
        return _AriaPy.ArSensorReading_setIgnoreThisReading(self, ignoreThisReading)


    def setExtraInt(self, extraInt):
        """setExtraInt(ArSensorReading self, int extraInt)"""
        return _AriaPy.ArSensorReading_setExtraInt(self, extraInt)


    def applyTransform(self, trans):
        """applyTransform(ArSensorReading self, ArTransform trans)"""
        return _AriaPy.ArSensorReading_applyTransform(self, trans)


    def applyEncoderTransform(self, trans):
        """applyEncoderTransform(ArSensorReading self, ArTransform trans)"""
        return _AriaPy.ArSensorReading_applyEncoderTransform(self, trans)


    def getAdjusted(self):
        """getAdjusted(ArSensorReading self) -> bool"""
        return _AriaPy.ArSensorReading_getAdjusted(self)


    def setAdjusted(self, adjusted):
        """setAdjusted(ArSensorReading self, bool adjusted)"""
        return _AriaPy.ArSensorReading_setAdjusted(self, adjusted)

ArSensorReading_swigregister = _AriaPy.ArSensorReading_swigregister
ArSensorReading_swigregister(ArSensorReading)

class ArSerialConnection(ArDeviceConnection):
    """Proxy of C++ ArSerialConnection 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, is422=False):
        """
        __init__(ArSerialConnection self, bool is422=False) -> ArSerialConnection
        __init__(ArSerialConnection self) -> ArSerialConnection
        """
        this = _AriaPy.new_ArSerialConnection(is422)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSerialConnection
    __del__ = lambda self: None

    def open(self, port=None):
        """
        open(ArSerialConnection self, char const * port=None) -> int
        open(ArSerialConnection self) -> int
        """
        return _AriaPy.ArSerialConnection_open(self, port)


    def setPort(self, port=None):
        """
        setPort(ArSerialConnection self, char const * port=None)
        setPort(ArSerialConnection self)
        """
        return _AriaPy.ArSerialConnection_setPort(self, port)


    def getPort(self):
        """getPort(ArSerialConnection self) -> char const *"""
        return _AriaPy.ArSerialConnection_getPort(self)


    def openSimple(self):
        """openSimple(ArSerialConnection self) -> bool"""
        return _AriaPy.ArSerialConnection_openSimple(self)


    def getStatus(self):
        """getStatus(ArSerialConnection self) -> int"""
        return _AriaPy.ArSerialConnection_getStatus(self)


    def close(self):
        """close(ArSerialConnection self) -> bool"""
        return _AriaPy.ArSerialConnection_close(self)


    def read(self, data, size, msWait=0):
        """
        read(ArSerialConnection self, char const * data, unsigned int size, unsigned int msWait=0) -> int
        read(ArSerialConnection self, char const * data, unsigned int size) -> int
        """
        return _AriaPy.ArSerialConnection_read(self, data, size, msWait)


    def write(self, data, size):
        """write(ArSerialConnection self, char const * data, unsigned int size) -> int"""
        return _AriaPy.ArSerialConnection_write(self, data, size)


    def getOpenMessage(self, messageNumber):
        """getOpenMessage(ArSerialConnection self, int messageNumber) -> char const *"""
        return _AriaPy.ArSerialConnection_getOpenMessage(self, messageNumber)


    def setBaud(self, baud):
        """setBaud(ArSerialConnection self, int baud) -> bool"""
        return _AriaPy.ArSerialConnection_setBaud(self, baud)


    def getBaud(self):
        """getBaud(ArSerialConnection self) -> int"""
        return _AriaPy.ArSerialConnection_getBaud(self)


    def setHardwareControl(self, hardwareControl):
        """setHardwareControl(ArSerialConnection self, bool hardwareControl) -> bool"""
        return _AriaPy.ArSerialConnection_setHardwareControl(self, hardwareControl)


    def getHardwareControl(self):
        """getHardwareControl(ArSerialConnection self) -> bool"""
        return _AriaPy.ArSerialConnection_getHardwareControl(self)


    def getCTS(self):
        """getCTS(ArSerialConnection self) -> bool"""
        return _AriaPy.ArSerialConnection_getCTS(self)


    def getDSR(self):
        """getDSR(ArSerialConnection self) -> bool"""
        return _AriaPy.ArSerialConnection_getDSR(self)


    def getDCD(self):
        """getDCD(ArSerialConnection self) -> bool"""
        return _AriaPy.ArSerialConnection_getDCD(self)


    def getRing(self):
        """getRing(ArSerialConnection self) -> bool"""
        return _AriaPy.ArSerialConnection_getRing(self)


    def internalOpen(self):
        """internalOpen(ArSerialConnection self) -> int"""
        return _AriaPy.ArSerialConnection_internalOpen(self)

    OPEN_COULD_NOT_OPEN_PORT = _AriaPy.ArSerialConnection_OPEN_COULD_NOT_OPEN_PORT
    OPEN_COULD_NOT_SET_UP_PORT = _AriaPy.ArSerialConnection_OPEN_COULD_NOT_SET_UP_PORT
    OPEN_INVALID_BAUD_RATE = _AriaPy.ArSerialConnection_OPEN_INVALID_BAUD_RATE
    OPEN_COULD_NOT_SET_BAUD = _AriaPy.ArSerialConnection_OPEN_COULD_NOT_SET_BAUD
    OPEN_ALREADY_OPEN = _AriaPy.ArSerialConnection_OPEN_ALREADY_OPEN

    def getTimeRead(self, index):
        """getTimeRead(ArSerialConnection self, int index) -> ArTime"""
        return _AriaPy.ArSerialConnection_getTimeRead(self, index)


    def isTimeStamping(self):
        """isTimeStamping(ArSerialConnection self) -> bool"""
        return _AriaPy.ArSerialConnection_isTimeStamping(self)

ArSerialConnection_swigregister = _AriaPy.ArSerialConnection_swigregister
ArSerialConnection_swigregister(ArSerialConnection)

class ArSignalHandler(ArASyncTask):
    """Proxy of C++ ArSignalHandler 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
    SigHUP = _AriaPy.ArSignalHandler_SigHUP
    SigINT = _AriaPy.ArSignalHandler_SigINT
    SigQUIT = _AriaPy.ArSignalHandler_SigQUIT
    SigILL = _AriaPy.ArSignalHandler_SigILL
    SigTRAP = _AriaPy.ArSignalHandler_SigTRAP
    SigABRT = _AriaPy.ArSignalHandler_SigABRT
    SigBUS = _AriaPy.ArSignalHandler_SigBUS
    SigFPE = _AriaPy.ArSignalHandler_SigFPE
    SigKILL = _AriaPy.ArSignalHandler_SigKILL
    SigUSR1 = _AriaPy.ArSignalHandler_SigUSR1
    SigSEGV = _AriaPy.ArSignalHandler_SigSEGV
    SigUSR2 = _AriaPy.ArSignalHandler_SigUSR2
    SigPIPE = _AriaPy.ArSignalHandler_SigPIPE
    SigALRM = _AriaPy.ArSignalHandler_SigALRM
    SigTERM = _AriaPy.ArSignalHandler_SigTERM
    SigSTKFLT = _AriaPy.ArSignalHandler_SigSTKFLT
    SigCHLD = _AriaPy.ArSignalHandler_SigCHLD
    SigCONT = _AriaPy.ArSignalHandler_SigCONT
    SigSTOP = _AriaPy.ArSignalHandler_SigSTOP
    SigTSTP = _AriaPy.ArSignalHandler_SigTSTP
    SigTTIN = _AriaPy.ArSignalHandler_SigTTIN
    SigTTOU = _AriaPy.ArSignalHandler_SigTTOU
    SigURG = _AriaPy.ArSignalHandler_SigURG
    SigXCPU = _AriaPy.ArSignalHandler_SigXCPU
    SigXFSZ = _AriaPy.ArSignalHandler_SigXFSZ
    SigVTALRM = _AriaPy.ArSignalHandler_SigVTALRM
    SigPROF = _AriaPy.ArSignalHandler_SigPROF
    SigWINCH = _AriaPy.ArSignalHandler_SigWINCH
    SigIO = _AriaPy.ArSignalHandler_SigIO
    SigPWR = _AriaPy.ArSignalHandler_SigPWR

    def createHandlerNonThreaded():
        """createHandlerNonThreaded()"""
        return _AriaPy.ArSignalHandler_createHandlerNonThreaded()

    createHandlerNonThreaded = staticmethod(createHandlerNonThreaded)

    def createHandlerThreaded():
        """createHandlerThreaded()"""
        return _AriaPy.ArSignalHandler_createHandlerThreaded()

    createHandlerThreaded = staticmethod(createHandlerThreaded)

    def blockCommon():
        """blockCommon()"""
        return _AriaPy.ArSignalHandler_blockCommon()

    blockCommon = staticmethod(blockCommon)

    def unblockAll():
        """unblockAll()"""
        return _AriaPy.ArSignalHandler_unblockAll()

    unblockAll = staticmethod(unblockAll)

    def block(sig):
        """block(ArSignalHandler::Signal sig)"""
        return _AriaPy.ArSignalHandler_block(sig)

    block = staticmethod(block)

    def unblock(sig):
        """unblock(ArSignalHandler::Signal sig)"""
        return _AriaPy.ArSignalHandler_unblock(sig)

    unblock = staticmethod(unblock)

    def handle(sig):
        """handle(ArSignalHandler::Signal sig)"""
        return _AriaPy.ArSignalHandler_handle(sig)

    handle = staticmethod(handle)

    def unhandle(sig):
        """unhandle(ArSignalHandler::Signal sig)"""
        return _AriaPy.ArSignalHandler_unhandle(sig)

    unhandle = staticmethod(unhandle)

    def addHandlerCB(func, position):
        """addHandlerCB(ArFunctor1_Int func, ArListPos::Pos position)"""
        return _AriaPy.ArSignalHandler_addHandlerCB(func, position)

    addHandlerCB = staticmethod(addHandlerCB)

    def delHandlerCB(func):
        """delHandlerCB(ArFunctor1_Int func)"""
        return _AriaPy.ArSignalHandler_delHandlerCB(func)

    delHandlerCB = staticmethod(delHandlerCB)

    def delAllHandlerCBs():
        """delAllHandlerCBs()"""
        return _AriaPy.ArSignalHandler_delAllHandlerCBs()

    delAllHandlerCBs = staticmethod(delAllHandlerCBs)

    def getHandler():
        """getHandler() -> ArSignalHandler"""
        return _AriaPy.ArSignalHandler_getHandler()

    getHandler = staticmethod(getHandler)

    def nameSignal(sig):
        """nameSignal(int sig) -> char const *"""
        return _AriaPy.ArSignalHandler_nameSignal(sig)

    nameSignal = staticmethod(nameSignal)

    def blockCommonThisThread():
        """blockCommonThisThread()"""
        return _AriaPy.ArSignalHandler_blockCommonThisThread()

    blockCommonThisThread = staticmethod(blockCommonThisThread)

    def blockAllThisThread():
        """blockAllThisThread()"""
        return _AriaPy.ArSignalHandler_blockAllThisThread()

    blockAllThisThread = staticmethod(blockAllThisThread)
    __swig_destroy__ = _AriaPy.delete_ArSignalHandler
    __del__ = lambda self: None

    def runThread(self, arg):
        """runThread(ArSignalHandler self, void * arg) -> void *"""
        return _AriaPy.ArSignalHandler_runThread(self, arg)


    def signalCB(sig):
        """signalCB(int sig)"""
        return _AriaPy.ArSignalHandler_signalCB(sig)

    signalCB = staticmethod(signalCB)

    def logThread():
        """logThread()"""
        return _AriaPy.ArSignalHandler_logThread()

    logThread = staticmethod(logThread)
ArSignalHandler_swigregister = _AriaPy.ArSignalHandler_swigregister
ArSignalHandler_swigregister(ArSignalHandler)

def ArSignalHandler_createHandlerNonThreaded():
    """ArSignalHandler_createHandlerNonThreaded()"""
    return _AriaPy.ArSignalHandler_createHandlerNonThreaded()

def ArSignalHandler_createHandlerThreaded():
    """ArSignalHandler_createHandlerThreaded()"""
    return _AriaPy.ArSignalHandler_createHandlerThreaded()

def ArSignalHandler_blockCommon():
    """ArSignalHandler_blockCommon()"""
    return _AriaPy.ArSignalHandler_blockCommon()

def ArSignalHandler_unblockAll():
    """ArSignalHandler_unblockAll()"""
    return _AriaPy.ArSignalHandler_unblockAll()

def ArSignalHandler_block(sig):
    """ArSignalHandler_block(ArSignalHandler::Signal sig)"""
    return _AriaPy.ArSignalHandler_block(sig)

def ArSignalHandler_unblock(sig):
    """ArSignalHandler_unblock(ArSignalHandler::Signal sig)"""
    return _AriaPy.ArSignalHandler_unblock(sig)

def ArSignalHandler_handle(sig):
    """ArSignalHandler_handle(ArSignalHandler::Signal sig)"""
    return _AriaPy.ArSignalHandler_handle(sig)

def ArSignalHandler_unhandle(sig):
    """ArSignalHandler_unhandle(ArSignalHandler::Signal sig)"""
    return _AriaPy.ArSignalHandler_unhandle(sig)

def ArSignalHandler_addHandlerCB(func, position):
    """ArSignalHandler_addHandlerCB(ArFunctor1_Int func, ArListPos::Pos position)"""
    return _AriaPy.ArSignalHandler_addHandlerCB(func, position)

def ArSignalHandler_delHandlerCB(func):
    """ArSignalHandler_delHandlerCB(ArFunctor1_Int func)"""
    return _AriaPy.ArSignalHandler_delHandlerCB(func)

def ArSignalHandler_delAllHandlerCBs():
    """ArSignalHandler_delAllHandlerCBs()"""
    return _AriaPy.ArSignalHandler_delAllHandlerCBs()

def ArSignalHandler_getHandler():
    """ArSignalHandler_getHandler() -> ArSignalHandler"""
    return _AriaPy.ArSignalHandler_getHandler()

def ArSignalHandler_nameSignal(sig):
    """ArSignalHandler_nameSignal(int sig) -> char const *"""
    return _AriaPy.ArSignalHandler_nameSignal(sig)

def ArSignalHandler_blockCommonThisThread():
    """ArSignalHandler_blockCommonThisThread()"""
    return _AriaPy.ArSignalHandler_blockCommonThisThread()

def ArSignalHandler_blockAllThisThread():
    """ArSignalHandler_blockAllThisThread()"""
    return _AriaPy.ArSignalHandler_blockAllThisThread()

def ArSignalHandler_signalCB(sig):
    """ArSignalHandler_signalCB(int sig)"""
    return _AriaPy.ArSignalHandler_signalCB(sig)

def ArSignalHandler_logThread():
    """ArSignalHandler_logThread()"""
    return _AriaPy.ArSignalHandler_logThread()

class ArSimpleConnector(object):
    """Proxy of C++ ArSimpleConnector 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__(ArSimpleConnector self, int * argc) -> ArSimpleConnector
        __init__(ArSimpleConnector self, ArArgumentBuilder arguments) -> ArSimpleConnector
        __init__(ArSimpleConnector self, ArArgumentParser parser) -> ArSimpleConnector
        """
        this = _AriaPy.new_ArSimpleConnector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSimpleConnector
    __del__ = lambda self: None

    def setupRobot(self, robot):
        """setupRobot(ArSimpleConnector self, ArRobot robot) -> bool"""
        return _AriaPy.ArSimpleConnector_setupRobot(self, robot)


    def connectRobot(self, robot):
        """connectRobot(ArSimpleConnector self, ArRobot robot) -> bool"""
        return _AriaPy.ArSimpleConnector_connectRobot(self, robot)


    def setupLaser(self, laser):
        """setupLaser(ArSimpleConnector self, ArSick * laser) -> bool"""
        return _AriaPy.ArSimpleConnector_setupLaser(self, laser)


    def setupSecondLaser(self, laser):
        """setupSecondLaser(ArSimpleConnector self, ArSick * laser) -> bool"""
        return _AriaPy.ArSimpleConnector_setupSecondLaser(self, laser)


    def setupLaserArbitrary(self, laser, laserNumber):
        """setupLaserArbitrary(ArSimpleConnector self, ArSick * laser, int laserNumber) -> bool"""
        return _AriaPy.ArSimpleConnector_setupLaserArbitrary(self, laser, laserNumber)


    def connectLaser(self, laser):
        """connectLaser(ArSimpleConnector self, ArSick * laser) -> bool"""
        return _AriaPy.ArSimpleConnector_connectLaser(self, laser)


    def connectSecondLaser(self, laser):
        """connectSecondLaser(ArSimpleConnector self, ArSick * laser) -> bool"""
        return _AriaPy.ArSimpleConnector_connectSecondLaser(self, laser)


    def connectLaserArbitrary(self, laser, laserNumber):
        """connectLaserArbitrary(ArSimpleConnector self, ArSick * laser, int laserNumber) -> bool"""
        return _AriaPy.ArSimpleConnector_connectLaserArbitrary(self, laser, laserNumber)


    def parseArgs(self, *args):
        """
        parseArgs(ArSimpleConnector self) -> bool
        parseArgs(ArSimpleConnector self, ArArgumentParser parser) -> bool
        """
        return _AriaPy.ArSimpleConnector_parseArgs(self, *args)


    def logOptions(self):
        """logOptions(ArSimpleConnector self)"""
        return _AriaPy.ArSimpleConnector_logOptions(self)


    def setMaxNumLasers(self, maxNumLasers=1):
        """
        setMaxNumLasers(ArSimpleConnector self, int maxNumLasers=1)
        setMaxNumLasers(ArSimpleConnector self)
        """
        return _AriaPy.ArSimpleConnector_setMaxNumLasers(self, maxNumLasers)

ArSimpleConnector_swigregister = _AriaPy.ArSimpleConnector_swigregister
ArSimpleConnector_swigregister(ArSimpleConnector)

class ArSimulatedLaser(ArLaser):
    """Proxy of C++ ArSimulatedLaser 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, laser):
        """__init__(ArSimulatedLaser self, ArLaser laser) -> ArSimulatedLaser"""
        this = _AriaPy.new_ArSimulatedLaser(laser)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSimulatedLaser
    __del__ = lambda self: None

    def blockingConnect(self):
        """blockingConnect(ArSimulatedLaser self) -> bool"""
        return _AriaPy.ArSimulatedLaser_blockingConnect(self)


    def asyncConnect(self):
        """asyncConnect(ArSimulatedLaser self) -> bool"""
        return _AriaPy.ArSimulatedLaser_asyncConnect(self)


    def disconnect(self):
        """disconnect(ArSimulatedLaser self) -> bool"""
        return _AriaPy.ArSimulatedLaser_disconnect(self)


    def isConnected(self):
        """isConnected(ArSimulatedLaser self) -> bool"""
        return _AriaPy.ArSimulatedLaser_isConnected(self)


    def isTryingToConnect(self):
        """isTryingToConnect(ArSimulatedLaser self) -> bool"""
        return _AriaPy.ArSimulatedLaser_isTryingToConnect(self)

ArSimulatedLaser_swigregister = _AriaPy.ArSimulatedLaser_swigregister
ArSimulatedLaser_swigregister(ArSimulatedLaser)

class ArSocket(object):
    """Proxy of C++ ArSocket class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    UDP = _AriaPy.ArSocket_UDP
    TCP = _AriaPy.ArSocket_TCP
    Unknown = _AriaPy.ArSocket_Unknown
    NoErr = _AriaPy.ArSocket_NoErr
    NetFail = _AriaPy.ArSocket_NetFail
    ConBadHost = _AriaPy.ArSocket_ConBadHost
    ConNoRoute = _AriaPy.ArSocket_ConNoRoute
    ConRefused = _AriaPy.ArSocket_ConRefused
    NameLookup = _AriaPy.ArSocket_NameLookup

    def __init__(self, *args):
        """
        __init__(ArSocket self) -> ArSocket
        __init__(ArSocket self, char const * host, int port, ArSocket::Type type) -> ArSocket
        __init__(ArSocket self, int port, bool doClose, ArSocket::Type type) -> ArSocket
        """
        this = _AriaPy.new_ArSocket(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSocket
    __del__ = lambda self: None

    def init():
        """init() -> bool"""
        return _AriaPy.ArSocket_init()

    init = staticmethod(init)

    def shutdown():
        """shutdown()"""
        return _AriaPy.ArSocket_shutdown()

    shutdown = staticmethod(shutdown)

    def toString(t):
        """toString(ArSocket::Type t) -> char const *"""
        return _AriaPy.ArSocket_toString(t)

    toString = staticmethod(toString)
    ourInitialized = _swig_property(_AriaPy.ArSocket_ourInitialized_get, _AriaPy.ArSocket_ourInitialized_set)

    def copy(self, *args):
        """
        copy(ArSocket self, int fd, bool doclose) -> bool
        copy(ArSocket self, ArSocket s)
        """
        return _AriaPy.ArSocket_copy(self, *args)


    def transfer(self, s):
        """transfer(ArSocket self, ArSocket s)"""
        return _AriaPy.ArSocket_transfer(self, s)


    def connect(self, *args):
        """
        connect(ArSocket self, char const * host, int port, ArSocket::Type type, char const * openOnIP=None) -> bool
        connect(ArSocket self, char const * host, int port, ArSocket::Type type) -> bool
        connect(ArSocket self, char const * host, int port) -> bool
        """
        return _AriaPy.ArSocket_connect(self, *args)


    def open(self, port, type, openOnIP=None):
        """
        open(ArSocket self, int port, ArSocket::Type type, char const * openOnIP=None) -> bool
        open(ArSocket self, int port, ArSocket::Type type) -> bool
        """
        return _AriaPy.ArSocket_open(self, port, type, openOnIP)


    def create(self, type):
        """create(ArSocket self, ArSocket::Type type) -> bool"""
        return _AriaPy.ArSocket_create(self, type)


    def findValidPort(self, startPort, openOnIP=None):
        """
        findValidPort(ArSocket self, int startPort, char const * openOnIP=None) -> bool
        findValidPort(ArSocket self, int startPort) -> bool
        """
        return _AriaPy.ArSocket_findValidPort(self, startPort, openOnIP)


    def connectTo(self, *args):
        """
        connectTo(ArSocket self, char const * host, int port) -> bool
        connectTo(ArSocket self, sockaddr_in * sin) -> bool
        """
        return _AriaPy.ArSocket_connectTo(self, *args)


    def accept(self, sock):
        """accept(ArSocket self, ArSocket sock) -> bool"""
        return _AriaPy.ArSocket_accept(self, sock)


    def close(self):
        """close(ArSocket self) -> bool"""
        return _AriaPy.ArSocket_close(self)


    def sendTo(self, *args):
        """
        sendTo(ArSocket self, void const * msg, int len) -> int
        sendTo(ArSocket self, void const * msg, int len, sockaddr_in * sin) -> int
        """
        return _AriaPy.ArSocket_sendTo(self, *args)


    def recvFrom(self, msg, len, sin):
        """recvFrom(ArSocket self, void * msg, int len, sockaddr_in * sin) -> int"""
        return _AriaPy.ArSocket_recvFrom(self, msg, len, sin)


    def hostAddr(host, addr):
        """hostAddr(char const * host, in_addr & addr) -> bool"""
        return _AriaPy.ArSocket_hostAddr(host, addr)

    hostAddr = staticmethod(hostAddr)

    def addrHost(addr, host):
        """addrHost(in_addr & addr, char * host) -> bool"""
        return _AriaPy.ArSocket_addrHost(addr, host)

    addrHost = staticmethod(addrHost)

    def getHostName():
        """getHostName() -> std::string"""
        return _AriaPy.ArSocket_getHostName()

    getHostName = staticmethod(getHostName)

    def getSockName(self):
        """getSockName(ArSocket self) -> bool"""
        return _AriaPy.ArSocket_getSockName(self)


    def sockAddrIn(self):
        """sockAddrIn(ArSocket self) -> sockaddr_in *"""
        return _AriaPy.ArSocket_sockAddrIn(self)


    def inAddr(self):
        """inAddr(ArSocket self) -> in_addr *"""
        return _AriaPy.ArSocket_inAddr(self)


    def inPort(self):
        """inPort(ArSocket self) -> unsigned short"""
        return _AriaPy.ArSocket_inPort(self)


    def inToA(addr, buff):
        """inToA(in_addr * addr, char * buff)"""
        return _AriaPy.ArSocket_inToA(addr, buff)

    inToA = staticmethod(inToA)

    def sockAddrLen():
        """sockAddrLen() -> size_t"""
        return _AriaPy.ArSocket_sockAddrLen()

    sockAddrLen = staticmethod(sockAddrLen)

    def maxHostNameLen():
        """maxHostNameLen() -> size_t"""
        return _AriaPy.ArSocket_maxHostNameLen()

    maxHostNameLen = staticmethod(maxHostNameLen)

    def hostToNetOrder(i):
        """hostToNetOrder(int i) -> unsigned int"""
        return _AriaPy.ArSocket_hostToNetOrder(i)

    hostToNetOrder = staticmethod(hostToNetOrder)

    def netToHostOrder(i):
        """netToHostOrder(int i) -> unsigned int"""
        return _AriaPy.ArSocket_netToHostOrder(i)

    netToHostOrder = staticmethod(netToHostOrder)

    def setLinger(self, time):
        """setLinger(ArSocket self, int time) -> bool"""
        return _AriaPy.ArSocket_setLinger(self, time)


    def setBroadcast(self):
        """setBroadcast(ArSocket self) -> bool"""
        return _AriaPy.ArSocket_setBroadcast(self)


    def setReuseAddress(self):
        """setReuseAddress(ArSocket self) -> bool"""
        return _AriaPy.ArSocket_setReuseAddress(self)


    def setNonBlock(self):
        """setNonBlock(ArSocket self) -> bool"""
        return _AriaPy.ArSocket_setNonBlock(self)


    def setDoClose(self, yesno):
        """setDoClose(ArSocket self, bool yesno)"""
        return _AriaPy.ArSocket_setDoClose(self, yesno)


    def getFD(self):
        """getFD(ArSocket self) -> int"""
        return _AriaPy.ArSocket_getFD(self)


    def getType(self):
        """getType(ArSocket self) -> ArSocket::Type"""
        return _AriaPy.ArSocket_getType(self)


    def getErrorStr(self):
        """getErrorStr(ArSocket self) -> std::string const &"""
        return _AriaPy.ArSocket_getErrorStr(self)


    def getError(self):
        """getError(ArSocket self) -> ArSocket::Error"""
        return _AriaPy.ArSocket_getError(self)


    def setErrorTracking(self, errorTracking):
        """setErrorTracking(ArSocket self, bool errorTracking)"""
        return _AriaPy.ArSocket_setErrorTracking(self, errorTracking)


    def getErrorTracking(self):
        """getErrorTracking(ArSocket self) -> bool"""
        return _AriaPy.ArSocket_getErrorTracking(self)


    def getBadWrite(self):
        """getBadWrite(ArSocket self) -> bool"""
        return _AriaPy.ArSocket_getBadWrite(self)


    def getBadRead(self):
        """getBadRead(ArSocket self) -> bool"""
        return _AriaPy.ArSocket_getBadRead(self)


    def writeStringPlain(self, str):
        """writeStringPlain(ArSocket self, char const * str) -> int"""
        return _AriaPy.ArSocket_writeStringPlain(self, str)


    def readString(self, msWait=0):
        """
        readString(ArSocket self, unsigned int msWait=0) -> char
        readString(ArSocket self) -> char *
        """
        return _AriaPy.ArSocket_readString(self, msWait)


    def setReadStringIgnoreReturn(self, ignore):
        """setReadStringIgnoreReturn(ArSocket self, bool ignore)"""
        return _AriaPy.ArSocket_setReadStringIgnoreReturn(self, ignore)


    def clearPartialReadString(self):
        """clearPartialReadString(ArSocket self)"""
        return _AriaPy.ArSocket_clearPartialReadString(self)


    def comparePartialReadString(self, partialString):
        """comparePartialReadString(ArSocket self, char const * partialString) -> int"""
        return _AriaPy.ArSocket_comparePartialReadString(self, partialString)


    def getLastStringReadTime(self):
        """getLastStringReadTime(ArSocket self) -> ArTime"""
        return _AriaPy.ArSocket_getLastStringReadTime(self)


    def setEcho(self, echo):
        """setEcho(ArSocket self, bool echo)"""
        return _AriaPy.ArSocket_setEcho(self, echo)


    def getEcho(self):
        """getEcho(ArSocket self) -> bool"""
        return _AriaPy.ArSocket_getEcho(self)


    def setLogWriteStrings(self, logWriteStrings):
        """setLogWriteStrings(ArSocket self, bool logWriteStrings)"""
        return _AriaPy.ArSocket_setLogWriteStrings(self, logWriteStrings)


    def getLogWriteStrings(self):
        """getLogWriteStrings(ArSocket self) -> bool"""
        return _AriaPy.ArSocket_getLogWriteStrings(self)


    def setStringUseWrongEndChars(self, useWrongEndChars):
        """setStringUseWrongEndChars(ArSocket self, bool useWrongEndChars)"""
        return _AriaPy.ArSocket_setStringUseWrongEndChars(self, useWrongEndChars)


    def getStringUseWrongEndChars(self):
        """getStringUseWrongEndChars(ArSocket self) -> bool"""
        return _AriaPy.ArSocket_getStringUseWrongEndChars(self)


    def getRawIPString(self):
        """getRawIPString(ArSocket self) -> char const *"""
        return _AriaPy.ArSocket_getRawIPString(self)


    def getIPString(self):
        """getIPString(ArSocket self) -> char const *"""
        return _AriaPy.ArSocket_getIPString(self)


    def setIPString(self, ipString):
        """setIPString(ArSocket self, char const * ipString)"""
        return _AriaPy.ArSocket_setIPString(self, ipString)


    def setCloseCallback(self, functor):
        """setCloseCallback(ArSocket self, ArFunctor functor)"""
        return _AriaPy.ArSocket_setCloseCallback(self, functor)


    def getCloseCallback(self):
        """getCloseCallback(ArSocket self) -> ArFunctor"""
        return _AriaPy.ArSocket_getCloseCallback(self)


    def getSends(self):
        """getSends(ArSocket self) -> long"""
        return _AriaPy.ArSocket_getSends(self)


    def getBytesSent(self):
        """getBytesSent(ArSocket self) -> long"""
        return _AriaPy.ArSocket_getBytesSent(self)


    def getRecvs(self):
        """getRecvs(ArSocket self) -> long"""
        return _AriaPy.ArSocket_getRecvs(self)


    def getBytesRecvd(self):
        """getBytesRecvd(ArSocket self) -> long"""
        return _AriaPy.ArSocket_getBytesRecvd(self)


    def resetTracking(self):
        """resetTracking(ArSocket self)"""
        return _AriaPy.ArSocket_resetTracking(self)


    def setNoDelay(self, flag):
        """setNoDelay(ArSocket self, bool flag) -> bool"""
        return _AriaPy.ArSocket_setNoDelay(self, flag)


    def isOpen(self):
        """isOpen(ArSocket self) -> bool"""
        return _AriaPy.ArSocket_isOpen(self)


    def read(self, *args):
        """
        read(ArSocket self, void * buff, size_t len, unsigned int msWait=0) -> int
        read(ArSocket self, void * buff, size_t len) -> int
        read(ArSocket self, size_t len, unsigned int msWait) -> std::string
        """
        return _AriaPy.ArSocket_read(self, *args)


    def write(self, *args):
        """
        write(ArSocket self, void const * buff, size_t len) -> int
        write(ArSocket self, std::string s) -> bool
        """
        return _AriaPy.ArSocket_write(self, *args)

ArSocket_swigregister = _AriaPy.ArSocket_swigregister
ArSocket_swigregister(ArSocket)

def ArSocket_init():
    """ArSocket_init() -> bool"""
    return _AriaPy.ArSocket_init()

def ArSocket_shutdown():
    """ArSocket_shutdown()"""
    return _AriaPy.ArSocket_shutdown()

def ArSocket_toString(t):
    """ArSocket_toString(ArSocket::Type t) -> char const *"""
    return _AriaPy.ArSocket_toString(t)

def ArSocket_hostAddr(host, addr):
    """ArSocket_hostAddr(char const * host, in_addr & addr) -> bool"""
    return _AriaPy.ArSocket_hostAddr(host, addr)

def ArSocket_addrHost(addr, host):
    """ArSocket_addrHost(in_addr & addr, char * host) -> bool"""
    return _AriaPy.ArSocket_addrHost(addr, host)

def ArSocket_getHostName():
    """ArSocket_getHostName() -> std::string"""
    return _AriaPy.ArSocket_getHostName()

def ArSocket_inToA(addr, buff):
    """ArSocket_inToA(in_addr * addr, char * buff)"""
    return _AriaPy.ArSocket_inToA(addr, buff)

def ArSocket_sockAddrLen():
    """ArSocket_sockAddrLen() -> size_t"""
    return _AriaPy.ArSocket_sockAddrLen()

def ArSocket_maxHostNameLen():
    """ArSocket_maxHostNameLen() -> size_t"""
    return _AriaPy.ArSocket_maxHostNameLen()

def ArSocket_hostToNetOrder(i):
    """ArSocket_hostToNetOrder(int i) -> unsigned int"""
    return _AriaPy.ArSocket_hostToNetOrder(i)

def ArSocket_netToHostOrder(i):
    """ArSocket_netToHostOrder(int i) -> unsigned int"""
    return _AriaPy.ArSocket_netToHostOrder(i)

class ArSonarAutoDisabler(object):
    """Proxy of C++ ArSonarAutoDisabler 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, robot):
        """__init__(ArSonarAutoDisabler self, ArRobot robot) -> ArSonarAutoDisabler"""
        this = _AriaPy.new_ArSonarAutoDisabler(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSonarAutoDisabler
    __del__ = lambda self: None

    def supress(self):
        """supress(ArSonarAutoDisabler self)"""
        return _AriaPy.ArSonarAutoDisabler_supress(self)


    def getSupressCallback(self):
        """getSupressCallback(ArSonarAutoDisabler self) -> ArFunctor"""
        return _AriaPy.ArSonarAutoDisabler_getSupressCallback(self)


    def unsupress(self):
        """unsupress(ArSonarAutoDisabler self)"""
        return _AriaPy.ArSonarAutoDisabler_unsupress(self)


    def getUnsupressCallback(self):
        """getUnsupressCallback(ArSonarAutoDisabler self) -> ArFunctor"""
        return _AriaPy.ArSonarAutoDisabler_getUnsupressCallback(self)


    def setAutonomousDriving(self):
        """setAutonomousDriving(ArSonarAutoDisabler self)"""
        return _AriaPy.ArSonarAutoDisabler_setAutonomousDriving(self)


    def getSetAutonomousDrivingCallback(self):
        """getSetAutonomousDrivingCallback(ArSonarAutoDisabler self) -> ArFunctor"""
        return _AriaPy.ArSonarAutoDisabler_getSetAutonomousDrivingCallback(self)


    def clearAutonomousDriving(self):
        """clearAutonomousDriving(ArSonarAutoDisabler self)"""
        return _AriaPy.ArSonarAutoDisabler_clearAutonomousDriving(self)


    def getClearAutonomousDrivingCallback(self):
        """getClearAutonomousDrivingCallback(ArSonarAutoDisabler self) -> ArFunctor"""
        return _AriaPy.ArSonarAutoDisabler_getClearAutonomousDrivingCallback(self)

ArSonarAutoDisabler_swigregister = _AriaPy.ArSonarAutoDisabler_swigregister
ArSonarAutoDisabler_swigregister(ArSonarAutoDisabler)

class ArSonarDevice(ArRangeDevice):
    """Proxy of C++ ArSonarDevice 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__(ArSonarDevice self, size_t currentBufferSize=24, size_t cumulativeBufferSize=64, char const * name) -> ArSonarDevice
        __init__(ArSonarDevice self, size_t currentBufferSize=24, size_t cumulativeBufferSize=64) -> ArSonarDevice
        __init__(ArSonarDevice self, size_t currentBufferSize=24) -> ArSonarDevice
        __init__(ArSonarDevice self) -> ArSonarDevice
        """
        this = _AriaPy.new_ArSonarDevice(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSonarDevice
    __del__ = lambda self: None

    def processReadings(self):
        """processReadings(ArSonarDevice self)"""
        return _AriaPy.ArSonarDevice_processReadings(self)


    def setRobot(self, robot):
        """setRobot(ArSonarDevice self, ArRobot robot)"""
        return _AriaPy.ArSonarDevice_setRobot(self, robot)


    def addReading(self, x, y):
        """addReading(ArSonarDevice self, double x, double y)"""
        return _AriaPy.ArSonarDevice_addReading(self, x, y)


    def setIgnoreReadingCB(self, ignoreReadingCB):
        """setIgnoreReadingCB(ArSonarDevice self, ArRetFunctor1< bool,ArPose > * ignoreReadingCB)"""
        return _AriaPy.ArSonarDevice_setIgnoreReadingCB(self, ignoreReadingCB)


    def getIgnoreReadingCB(self):
        """getIgnoreReadingCB(ArSonarDevice self) -> ArRetFunctor1< bool,ArPose > *"""
        return _AriaPy.ArSonarDevice_getIgnoreReadingCB(self)


    def setCumulativeMaxRange(self, range):
        """setCumulativeMaxRange(ArSonarDevice self, double range)"""
        return _AriaPy.ArSonarDevice_setCumulativeMaxRange(self, range)

ArSonarDevice_swigregister = _AriaPy.ArSonarDevice_swigregister
ArSonarDevice_swigregister(ArSonarDevice)

class ArSonyPacket(ArBasePacket):
    """Proxy of C++ ArSonyPacket 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, bufferSize=15):
        """
        __init__(ArSonyPacket self, ArTypes::UByte2 bufferSize=15) -> ArSonyPacket
        __init__(ArSonyPacket self) -> ArSonyPacket
        """
        this = _AriaPy.new_ArSonyPacket(bufferSize)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSonyPacket
    __del__ = lambda self: None

    def uByteToBuf(self, val):
        """uByteToBuf(ArSonyPacket self, ArTypes::UByte val)"""
        return _AriaPy.ArSonyPacket_uByteToBuf(self, val)


    def byte2ToBuf(self, val):
        """byte2ToBuf(ArSonyPacket self, ArTypes::Byte2 val)"""
        return _AriaPy.ArSonyPacket_byte2ToBuf(self, val)


    def byte2ToBufAtPos(self, val, pose):
        """byte2ToBufAtPos(ArSonyPacket self, ArTypes::Byte2 val, ArTypes::UByte2 pose)"""
        return _AriaPy.ArSonyPacket_byte2ToBufAtPos(self, val, pose)

ArSonyPacket_swigregister = _AriaPy.ArSonyPacket_swigregister
ArSonyPacket_swigregister(ArSonyPacket)

class ArSonyPTZ(ArPTZ):
    """Proxy of C++ ArSonyPTZ 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, robot):
        """__init__(ArSonyPTZ self, ArRobot robot) -> ArSonyPTZ"""
        this = _AriaPy.new_ArSonyPTZ(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSonyPTZ
    __del__ = lambda self: None

    def init(self):
        """init(ArSonyPTZ self) -> bool"""
        return _AriaPy.ArSonyPTZ_init(self)


    def getTypeName(self):
        """getTypeName(ArSonyPTZ self) -> char const *"""
        return _AriaPy.ArSonyPTZ_getTypeName(self)


    def canZoom(self):
        """canZoom(ArSonyPTZ self) -> bool"""
        return _AriaPy.ArSonyPTZ_canZoom(self)


    def zoom(self, zoomValue):
        """zoom(ArSonyPTZ self, int zoomValue) -> bool"""
        return _AriaPy.ArSonyPTZ_zoom(self, zoomValue)


    def zoomRel(self, zoomValue):
        """zoomRel(ArSonyPTZ self, int zoomValue) -> bool"""
        return _AriaPy.ArSonyPTZ_zoomRel(self, zoomValue)


    def getZoom(self):
        """getZoom(ArSonyPTZ self) -> int"""
        return _AriaPy.ArSonyPTZ_getZoom(self)


    def canGetFOV(self):
        """canGetFOV(ArSonyPTZ self) -> bool"""
        return _AriaPy.ArSonyPTZ_canGetFOV(self)


    def getFOVAtMaxZoom(self):
        """getFOVAtMaxZoom(ArSonyPTZ self) -> double"""
        return _AriaPy.ArSonyPTZ_getFOVAtMaxZoom(self)


    def getFOVAtMinZoom(self):
        """getFOVAtMinZoom(ArSonyPTZ self) -> double"""
        return _AriaPy.ArSonyPTZ_getFOVAtMinZoom(self)


    def backLightingOn(self):
        """backLightingOn(ArSonyPTZ self) -> bool"""
        return _AriaPy.ArSonyPTZ_backLightingOn(self)


    def backLightingOff(self):
        """backLightingOff(ArSonyPTZ self) -> bool"""
        return _AriaPy.ArSonyPTZ_backLightingOff(self)

ArSonyPTZ_swigregister = _AriaPy.ArSonyPTZ_swigregister
ArSonyPTZ_swigregister(ArSonyPTZ)

class ArSoundPlayer(object):
    """Proxy of C++ ArSoundPlayer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def playWavFile(*args):
        """
        playWavFile(char const * filename, char const * params) -> bool
        playWavFile(char const * filename) -> bool
        """
        return _AriaPy.ArSoundPlayer_playWavFile(*args)

    playWavFile = staticmethod(playWavFile)

    def playNativeFile(filename, params):
        """playNativeFile(char const * filename, char const * params) -> bool"""
        return _AriaPy.ArSoundPlayer_playNativeFile(filename, params)

    playNativeFile = staticmethod(playNativeFile)

    def stopPlaying():
        """stopPlaying()"""
        return _AriaPy.ArSoundPlayer_stopPlaying()

    stopPlaying = staticmethod(stopPlaying)

    def getPlayWavFileCallback():
        """getPlayWavFileCallback() -> ArRetFunctor2< bool,char const *,char const * > *"""
        return _AriaPy.ArSoundPlayer_getPlayWavFileCallback()

    getPlayWavFileCallback = staticmethod(getPlayWavFileCallback)

    def getStopPlayingCallback():
        """getStopPlayingCallback() -> ArFunctor"""
        return _AriaPy.ArSoundPlayer_getStopPlayingCallback()

    getStopPlayingCallback = staticmethod(getStopPlayingCallback)

    def playSoundPCM16(data, numSamples):
        """playSoundPCM16(char * data, int numSamples) -> bool"""
        return _AriaPy.ArSoundPlayer_playSoundPCM16(data, numSamples)

    playSoundPCM16 = staticmethod(playSoundPCM16)

    def setVolume(v):
        """setVolume(double v)"""
        return _AriaPy.ArSoundPlayer_setVolume(v)

    setVolume = staticmethod(setVolume)

    def setVolumePercent(pct):
        """setVolumePercent(double pct)"""
        return _AriaPy.ArSoundPlayer_setVolumePercent(pct)

    setVolumePercent = staticmethod(setVolumePercent)

    def __init__(self):
        """__init__(ArSoundPlayer self) -> ArSoundPlayer"""
        this = _AriaPy.new_ArSoundPlayer()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSoundPlayer
    __del__ = lambda self: None
ArSoundPlayer_swigregister = _AriaPy.ArSoundPlayer_swigregister
ArSoundPlayer_swigregister(ArSoundPlayer)

def ArSoundPlayer_playWavFile(*args):
    """
    playWavFile(char const * filename, char const * params) -> bool
    ArSoundPlayer_playWavFile(char const * filename) -> bool
    """
    return _AriaPy.ArSoundPlayer_playWavFile(*args)

def ArSoundPlayer_playNativeFile(filename, params):
    """ArSoundPlayer_playNativeFile(char const * filename, char const * params) -> bool"""
    return _AriaPy.ArSoundPlayer_playNativeFile(filename, params)

def ArSoundPlayer_stopPlaying():
    """ArSoundPlayer_stopPlaying()"""
    return _AriaPy.ArSoundPlayer_stopPlaying()

def ArSoundPlayer_getPlayWavFileCallback():
    """ArSoundPlayer_getPlayWavFileCallback() -> ArRetFunctor2< bool,char const *,char const * > *"""
    return _AriaPy.ArSoundPlayer_getPlayWavFileCallback()

def ArSoundPlayer_getStopPlayingCallback():
    """ArSoundPlayer_getStopPlayingCallback() -> ArFunctor"""
    return _AriaPy.ArSoundPlayer_getStopPlayingCallback()

def ArSoundPlayer_playSoundPCM16(data, numSamples):
    """ArSoundPlayer_playSoundPCM16(char * data, int numSamples) -> bool"""
    return _AriaPy.ArSoundPlayer_playSoundPCM16(data, numSamples)

def ArSoundPlayer_setVolume(v):
    """ArSoundPlayer_setVolume(double v)"""
    return _AriaPy.ArSoundPlayer_setVolume(v)

def ArSoundPlayer_setVolumePercent(pct):
    """ArSoundPlayer_setVolumePercent(double pct)"""
    return _AriaPy.ArSoundPlayer_setVolumePercent(pct)

class ArSoundsQueue(ArASyncTask):
    """Proxy of C++ ArSoundsQueue class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    SPEECH = _AriaPy.ArSoundsQueue_SPEECH
    SOUND_FILE = _AriaPy.ArSoundsQueue_SOUND_FILE
    SOUND_DATA = _AriaPy.ArSoundsQueue_SOUND_DATA
    OTHER = _AriaPy.ArSoundsQueue_OTHER

    def __init__(self, *args):
        """
        __init__(ArSoundsQueue self) -> ArSoundsQueue
        __init__(ArSoundsQueue self, ArRetFunctor_Bool speakInitCB, ArSoundsQueue::PlayItemFunctor * speakCB=None, ArFunctor interruptSpeechCB=None, ArRetFunctor_Bool playInitCB=None, ArSoundsQueue::PlayItemFunctor * playFileCB=None, ArFunctor interruptFileCB=None) -> ArSoundsQueue
        __init__(ArSoundsQueue self, ArRetFunctor_Bool speakInitCB, ArSoundsQueue::PlayItemFunctor * speakCB=None, ArFunctor interruptSpeechCB=None, ArRetFunctor_Bool playInitCB=None, ArSoundsQueue::PlayItemFunctor * playFileCB=None) -> ArSoundsQueue
        __init__(ArSoundsQueue self, ArRetFunctor_Bool speakInitCB, ArSoundsQueue::PlayItemFunctor * speakCB=None, ArFunctor interruptSpeechCB=None, ArRetFunctor_Bool playInitCB=None) -> ArSoundsQueue
        __init__(ArSoundsQueue self, ArRetFunctor_Bool speakInitCB, ArSoundsQueue::PlayItemFunctor * speakCB=None, ArFunctor interruptSpeechCB=None) -> ArSoundsQueue
        __init__(ArSoundsQueue self, ArRetFunctor_Bool speakInitCB, ArSoundsQueue::PlayItemFunctor * speakCB=None) -> ArSoundsQueue
        __init__(ArSoundsQueue self, ArRetFunctor_Bool speakInitCB) -> ArSoundsQueue
        __init__(ArSoundsQueue self, ArSpeechSynth speechSynthesizer, ArRetFunctor_Bool playInitCB=None, ArSoundsQueue::PlayItemFunctor * playFileCB=None, ArFunctor interruptFileCB=None) -> ArSoundsQueue
        __init__(ArSoundsQueue self, ArSpeechSynth speechSynthesizer, ArRetFunctor_Bool playInitCB=None, ArSoundsQueue::PlayItemFunctor * playFileCB=None) -> ArSoundsQueue
        __init__(ArSoundsQueue self, ArSpeechSynth speechSynthesizer, ArRetFunctor_Bool playInitCB=None) -> ArSoundsQueue
        __init__(ArSoundsQueue self, ArSpeechSynth speechSynthesizer) -> ArSoundsQueue
        """
        this = _AriaPy.new_ArSoundsQueue(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSoundsQueue
    __del__ = lambda self: None

    def addInitCallback(self, cb):
        """addInitCallback(ArSoundsQueue self, ArRetFunctor_Bool cb)"""
        return _AriaPy.ArSoundsQueue_addInitCallback(self, cb)


    def setSpeakInitCallback(self, cb):
        """setSpeakInitCallback(ArSoundsQueue self, ArRetFunctor_Bool cb)"""
        return _AriaPy.ArSoundsQueue_setSpeakInitCallback(self, cb)


    def addItem(self, *args):
        """
        addItem(ArSoundsQueue self, ArSoundsQueue::Item item)
        addItem(ArSoundsQueue self, ArSoundsQueue::ItemType type, char const * data, std::list< ArSoundsQueue::PlayItemFunctor *,std::allocator< ArSoundsQueue::PlayItemFunctor * > > callbacks, int priority=0, char const * params=None)
        addItem(ArSoundsQueue self, ArSoundsQueue::ItemType type, char const * data, std::list< ArSoundsQueue::PlayItemFunctor *,std::allocator< ArSoundsQueue::PlayItemFunctor * > > callbacks, int priority=0)
        addItem(ArSoundsQueue self, ArSoundsQueue::ItemType type, char const * data, std::list< ArSoundsQueue::PlayItemFunctor *,std::allocator< ArSoundsQueue::PlayItemFunctor * > > callbacks)
        """
        return _AriaPy.ArSoundsQueue_addItem(self, *args)


    def isInitialized(self):
        """isInitialized(ArSoundsQueue self) -> bool"""
        return _AriaPy.ArSoundsQueue_isInitialized(self)


    def isSpeakingOrPlaying(self):
        """isSpeakingOrPlaying(ArSoundsQueue self) -> bool"""
        return _AriaPy.ArSoundsQueue_isSpeakingOrPlaying(self)


    def isPlaying(self):
        """isPlaying(ArSoundsQueue self) -> bool"""
        return _AriaPy.ArSoundsQueue_isPlaying(self)


    def isSpeaking(self):
        """isSpeaking(ArSoundsQueue self) -> bool"""
        return _AriaPy.ArSoundsQueue_isSpeaking(self)


    def run(self):
        """run(ArSoundsQueue self)"""
        return _AriaPy.ArSoundsQueue_run(self)


    def runAsync(self):
        """runAsync(ArSoundsQueue self)"""
        return _AriaPy.ArSoundsQueue_runAsync(self)


    def pause(self):
        """pause(ArSoundsQueue self)"""
        return _AriaPy.ArSoundsQueue_pause(self)


    def resume(self):
        """resume(ArSoundsQueue self)"""
        return _AriaPy.ArSoundsQueue_resume(self)


    def isPaused(self):
        """isPaused(ArSoundsQueue self) -> bool"""
        return _AriaPy.ArSoundsQueue_isPaused(self)


    def interrupt(self):
        """interrupt(ArSoundsQueue self)"""
        return _AriaPy.ArSoundsQueue_interrupt(self)


    def clearQueue(self):
        """clearQueue(ArSoundsQueue self)"""
        return _AriaPy.ArSoundsQueue_clearQueue(self)


    def stop(self):
        """stop(ArSoundsQueue self)"""
        return _AriaPy.ArSoundsQueue_stop(self)


    def getPauseCallback(self):
        """getPauseCallback(ArSoundsQueue self) -> ArFunctor"""
        return _AriaPy.ArSoundsQueue_getPauseCallback(self)


    def getResumeCallback(self):
        """getResumeCallback(ArSoundsQueue self) -> ArFunctor"""
        return _AriaPy.ArSoundsQueue_getResumeCallback(self)


    def getCurrentQueueSize(self):
        """getCurrentQueueSize(ArSoundsQueue self) -> size_t"""
        return _AriaPy.ArSoundsQueue_getCurrentQueueSize(self)


    def addSoundStartedCallback(self, f):
        """addSoundStartedCallback(ArSoundsQueue self, ArFunctor f)"""
        return _AriaPy.ArSoundsQueue_addSoundStartedCallback(self, f)


    def remSoundStartedCallback(self, f):
        """remSoundStartedCallback(ArSoundsQueue self, ArFunctor f)"""
        return _AriaPy.ArSoundsQueue_remSoundStartedCallback(self, f)


    def addSoundFinishedCallback(self, f):
        """addSoundFinishedCallback(ArSoundsQueue self, ArFunctor f)"""
        return _AriaPy.ArSoundsQueue_addSoundFinishedCallback(self, f)


    def remSoundFinishedCallback(self, f):
        """remSoundFinishedCallback(ArSoundsQueue self, ArFunctor f)"""
        return _AriaPy.ArSoundsQueue_remSoundFinishedCallback(self, f)


    def addSoundItemStartedCallback(self, f):
        """addSoundItemStartedCallback(ArSoundsQueue self, ArFunctor1< ArSoundsQueue::Item > * f)"""
        return _AriaPy.ArSoundsQueue_addSoundItemStartedCallback(self, f)


    def remSoundItemStartedCallback(self, f):
        """remSoundItemStartedCallback(ArSoundsQueue self, ArFunctor1< ArSoundsQueue::Item > * f)"""
        return _AriaPy.ArSoundsQueue_remSoundItemStartedCallback(self, f)


    def addSoundItemFinishedCallback(self, f):
        """addSoundItemFinishedCallback(ArSoundsQueue self, ArFunctor1< ArSoundsQueue::Item > * f)"""
        return _AriaPy.ArSoundsQueue_addSoundItemFinishedCallback(self, f)


    def remSoundItemFinishedCallback(self, f):
        """remSoundItemFinishedCallback(ArSoundsQueue self, ArFunctor1< ArSoundsQueue::Item > * f)"""
        return _AriaPy.ArSoundsQueue_remSoundItemFinishedCallback(self, f)


    def addQueueNonemptyCallback(self, f):
        """addQueueNonemptyCallback(ArSoundsQueue self, ArFunctor f)"""
        return _AriaPy.ArSoundsQueue_addQueueNonemptyCallback(self, f)


    def remQueueNonemptyCallback(self, f):
        """remQueueNonemptyCallback(ArSoundsQueue self, ArFunctor f)"""
        return _AriaPy.ArSoundsQueue_remQueueNonemptyCallback(self, f)


    def addQueueEmptyCallback(self, f):
        """addQueueEmptyCallback(ArSoundsQueue self, ArFunctor f)"""
        return _AriaPy.ArSoundsQueue_addQueueEmptyCallback(self, f)


    def remQueueEmptyCallback(self, f):
        """remQueueEmptyCallback(ArSoundsQueue self, ArFunctor f)"""
        return _AriaPy.ArSoundsQueue_remQueueEmptyCallback(self, f)


    def findPendingItems(self, item):
        """findPendingItems(ArSoundsQueue self, char const * item) -> IntSet"""
        return _AriaPy.ArSoundsQueue_findPendingItems(self, item)


    def removePendingItems(self, *args):
        """
        removePendingItems(ArSoundsQueue self, char const * item, ArSoundsQueue::ItemType type)
        removePendingItems(ArSoundsQueue self, char const * data)
        """
        return _AriaPy.ArSoundsQueue_removePendingItems(self, *args)


    def removePendingItemsByPriority(self, priority):
        """removePendingItemsByPriority(ArSoundsQueue self, int priority)"""
        return _AriaPy.ArSoundsQueue_removePendingItemsByPriority(self, priority)


    def removePendingItemsByPriorityWithType(self, priority, type):
        """removePendingItemsByPriorityWithType(ArSoundsQueue self, int priority, ArSoundsQueue::ItemType type)"""
        return _AriaPy.ArSoundsQueue_removePendingItemsByPriorityWithType(self, priority, type)


    def removePendingItemsByType(self, type):
        """removePendingItemsByType(ArSoundsQueue self, ArSoundsQueue::ItemType type)"""
        return _AriaPy.ArSoundsQueue_removePendingItemsByType(self, type)


    def removeItems(self, *args):
        """
        removeItems(ArSoundsQueue self, int priority)
        removeItems(ArSoundsQueue self, ArSoundsQueue::Item item)
        """
        return _AriaPy.ArSoundsQueue_removeItems(self, *args)


    def nextItemByType(self, type):
        """nextItemByType(ArSoundsQueue self, ArSoundsQueue::ItemType type) -> std::string"""
        return _AriaPy.ArSoundsQueue_nextItemByType(self, type)


    def nextItemByPriority(self, priority):
        """nextItemByPriority(ArSoundsQueue self, int priority) -> std::string"""
        return _AriaPy.ArSoundsQueue_nextItemByPriority(self, priority)


    def nextItemByTypeAndPriority(self, type, priority):
        """nextItemByTypeAndPriority(ArSoundsQueue self, ArSoundsQueue::ItemType type, int priority) -> std::string"""
        return _AriaPy.ArSoundsQueue_nextItemByTypeAndPriority(self, type, priority)


    def setSpeakCallback(self, cb):
        """setSpeakCallback(ArSoundsQueue self, ArSoundsQueue::PlayItemFunctor * cb)"""
        return _AriaPy.ArSoundsQueue_setSpeakCallback(self, cb)


    def setInterruptSpeechCallback(self, cb):
        """setInterruptSpeechCallback(ArSoundsQueue self, ArFunctor cb)"""
        return _AriaPy.ArSoundsQueue_setInterruptSpeechCallback(self, cb)


    def setPlayFileCallback(self, cb):
        """setPlayFileCallback(ArSoundsQueue self, ArSoundsQueue::PlayItemFunctor * cb)"""
        return _AriaPy.ArSoundsQueue_setPlayFileCallback(self, cb)


    def setPlayWavFileCallback(self, cb):
        """setPlayWavFileCallback(ArSoundsQueue self, ArSoundsQueue::PlayItemFunctor * cb)"""
        return _AriaPy.ArSoundsQueue_setPlayWavFileCallback(self, cb)


    def setInterruptFileCallback(self, cb):
        """setInterruptFileCallback(ArSoundsQueue self, ArFunctor cb)"""
        return _AriaPy.ArSoundsQueue_setInterruptFileCallback(self, cb)


    def setInterruptWavFileCallback(self, cb):
        """setInterruptWavFileCallback(ArSoundsQueue self, ArFunctor cb)"""
        return _AriaPy.ArSoundsQueue_setInterruptWavFileCallback(self, cb)


    def speak(self, str):
        """speak(ArSoundsQueue self, char const * str)"""
        return _AriaPy.ArSoundsQueue_speak(self, str)


    def play(self, filename):
        """play(ArSoundsQueue self, char const * filename)"""
        return _AriaPy.ArSoundsQueue_play(self, filename)


    def createDefaultSpeechItem(self, speech=None):
        """
        createDefaultSpeechItem(ArSoundsQueue self, char const * speech=None) -> ArSoundsQueue::Item
        createDefaultSpeechItem(ArSoundsQueue self) -> ArSoundsQueue::Item
        """
        return _AriaPy.ArSoundsQueue_createDefaultSpeechItem(self, speech)


    def createDefaultFileItem(self, filename=None):
        """
        createDefaultFileItem(ArSoundsQueue self, char const * filename=None) -> ArSoundsQueue::Item
        createDefaultFileItem(ArSoundsQueue self) -> ArSoundsQueue::Item
        """
        return _AriaPy.ArSoundsQueue_createDefaultFileItem(self, filename)


    def setDefaultPlayConditionCB(self, f):
        """setDefaultPlayConditionCB(ArSoundsQueue self, ArRetFunctor_Bool f)"""
        return _AriaPy.ArSoundsQueue_setDefaultPlayConditionCB(self, f)


    def runThread(self, arg):
        """runThread(ArSoundsQueue self, void * arg) -> void *"""
        return _AriaPy.ArSoundsQueue_runThread(self, arg)

ArSoundsQueue_swigregister = _AriaPy.ArSoundsQueue_swigregister
ArSoundsQueue_swigregister(ArSoundsQueue)

class ArSpeechSynth(object):
    """Proxy of C++ ArSpeechSynth 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__ = _AriaPy.delete_ArSpeechSynth
    __del__ = lambda self: None

    def init(self):
        """init(ArSpeechSynth self) -> bool"""
        return _AriaPy.ArSpeechSynth_init(self)


    def addToConfig(self, config):
        """addToConfig(ArSpeechSynth self, ArConfig config)"""
        return _AriaPy.ArSpeechSynth_addToConfig(self, config)


    def speak(self, *args):
        """
        speak(ArSpeechSynth self, char const * str, char const * voiceParams, ArRetFunctor2< bool,ArTypes::Byte2 *,int > * audioOutputCB, unsigned short sampleRate=0) -> bool
        speak(ArSpeechSynth self, char const * str, char const * voiceParams, ArRetFunctor2< bool,ArTypes::Byte2 *,int > * audioOutputCB) -> bool
        speak(ArSpeechSynth self, char const * str, char const * voiceParams=None) -> bool
        speak(ArSpeechSynth self, char const * str) -> bool
        """
        return _AriaPy.ArSpeechSynth_speak(self, *args)


    def speakf(self, fmt):
        """speakf(ArSpeechSynth self, char const * fmt) -> bool"""
        return _AriaPy.ArSpeechSynth_speakf(self, fmt)


    def interrupt(self):
        """interrupt(ArSpeechSynth self)"""
        return _AriaPy.ArSpeechSynth_interrupt(self)


    def getInitCallback(self):
        """getInitCallback(ArSpeechSynth self) -> ArRetFunctorC< bool,ArSpeechSynth > *"""
        return _AriaPy.ArSpeechSynth_getInitCallback(self)


    def getSpeakCallback(self):
        """getSpeakCallback(ArSpeechSynth self) -> ArRetFunctor2C< bool,ArSpeechSynth,char const *,char const * > *"""
        return _AriaPy.ArSpeechSynth_getSpeakCallback(self)


    def getInterruptCallback(self):
        """getInterruptCallback(ArSpeechSynth self) -> ArFunctorC< ArSpeechSynth > *"""
        return _AriaPy.ArSpeechSynth_getInterruptCallback(self)


    def setAudioCallback(self, cb):
        """setAudioCallback(ArSpeechSynth self, ArRetFunctor2< bool,ArTypes::Byte2 *,int > * cb)"""
        return _AriaPy.ArSpeechSynth_setAudioCallback(self, cb)


    def setAudioSampleRate(self, rate):
        """setAudioSampleRate(ArSpeechSynth self, int rate)"""
        return _AriaPy.ArSpeechSynth_setAudioSampleRate(self, rate)


    def getAudioSampleRate(self):
        """getAudioSampleRate(ArSpeechSynth self) -> int"""
        return _AriaPy.ArSpeechSynth_getAudioSampleRate(self)


    def lock(self):
        """lock(ArSpeechSynth self)"""
        return _AriaPy.ArSpeechSynth_lock(self)


    def unlock(self):
        """unlock(ArSpeechSynth self)"""
        return _AriaPy.ArSpeechSynth_unlock(self)


    def setVoice(self, name):
        """setVoice(ArSpeechSynth self, char const * name) -> bool"""
        return _AriaPy.ArSpeechSynth_setVoice(self, name)


    def getCurrentVoiceName(self):
        """getCurrentVoiceName(ArSpeechSynth self) -> char const *"""
        return _AriaPy.ArSpeechSynth_getCurrentVoiceName(self)


    def getVoiceNames(self):
        """getVoiceNames(ArSpeechSynth self) -> std::list< std::string,std::allocator< std::string > >"""
        return _AriaPy.ArSpeechSynth_getVoiceNames(self)

ArSpeechSynth_swigregister = _AriaPy.ArSpeechSynth_swigregister
ArSpeechSynth_swigregister(ArSpeechSynth)

class ArStringInfoGroup(object):
    """Proxy of C++ ArStringInfoGroup 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):
        """__init__(ArStringInfoGroup self) -> ArStringInfoGroup"""
        this = _AriaPy.new_ArStringInfoGroup()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArStringInfoGroup
    __del__ = lambda self: None

    def addString(self, name, maxLen, functor):
        """addString(ArStringInfoGroup self, char const * name, ArTypes::UByte2 maxLen, ArFunctor2< char *,ArTypes::UByte2 > * functor) -> bool"""
        return _AriaPy.ArStringInfoGroup_addString(self, name, maxLen, functor)


    def addStringInt(self, *args):
        """
        addStringInt(ArStringInfoGroup self, char const * name, ArTypes::UByte2 maxLen, ArRetFunctor_Int functor, char const * format) -> bool
        addStringInt(ArStringInfoGroup self, char const * name, ArTypes::UByte2 maxLen, ArRetFunctor_Int functor) -> bool
        """
        return _AriaPy.ArStringInfoGroup_addStringInt(self, *args)


    def addStringDouble(self, *args):
        """
        addStringDouble(ArStringInfoGroup self, char const * name, ArTypes::UByte2 maxLen, ArRetFunctor_Double functor, char const * format) -> bool
        addStringDouble(ArStringInfoGroup self, char const * name, ArTypes::UByte2 maxLen, ArRetFunctor_Double functor) -> bool
        """
        return _AriaPy.ArStringInfoGroup_addStringDouble(self, *args)


    def addStringBool(self, *args):
        """
        addStringBool(ArStringInfoGroup self, char const * name, ArTypes::UByte2 maxLen, ArRetFunctor_Bool functor, char const * format) -> bool
        addStringBool(ArStringInfoGroup self, char const * name, ArTypes::UByte2 maxLen, ArRetFunctor_Bool functor) -> bool
        """
        return _AriaPy.ArStringInfoGroup_addStringBool(self, *args)


    def addStringString(self, *args):
        """
        addStringString(ArStringInfoGroup self, char const * name, ArTypes::UByte2 maxLen, ArRetFunctor< char const * > * functor, char const * format) -> bool
        addStringString(ArStringInfoGroup self, char const * name, ArTypes::UByte2 maxLen, ArRetFunctor< char const * > * functor) -> bool
        """
        return _AriaPy.ArStringInfoGroup_addStringString(self, *args)


    def addStringUnsignedLong(self, *args):
        """
        addStringUnsignedLong(ArStringInfoGroup self, char const * name, ArTypes::UByte2 maxLen, ArRetFunctor< unsigned long > * functor, char const * format) -> bool
        addStringUnsignedLong(ArStringInfoGroup self, char const * name, ArTypes::UByte2 maxLen, ArRetFunctor< unsigned long > * functor) -> bool
        """
        return _AriaPy.ArStringInfoGroup_addStringUnsignedLong(self, *args)


    def addStringLong(self, *args):
        """
        addStringLong(ArStringInfoGroup self, char const * name, ArTypes::UByte2 maxLen, ArRetFunctor< long > * functor, char const * format) -> bool
        addStringLong(ArStringInfoGroup self, char const * name, ArTypes::UByte2 maxLen, ArRetFunctor< long > * functor) -> bool
        """
        return _AriaPy.ArStringInfoGroup_addStringLong(self, *args)


    def addAddStringCallback(self, *args):
        """
        addAddStringCallback(ArStringInfoGroup self, ArFunctor3< char const *,ArTypes::UByte2,ArFunctor2< char *,ArTypes::UByte2 > * > * functor, ArListPos::Pos position)
        addAddStringCallback(ArStringInfoGroup self, ArFunctor3< char const *,ArTypes::UByte2,ArFunctor2< char *,ArTypes::UByte2 > * > * functor)
        """
        return _AriaPy.ArStringInfoGroup_addAddStringCallback(self, *args)

ArStringInfoGroup_swigregister = _AriaPy.ArStringInfoGroup_swigregister
ArStringInfoGroup_swigregister(ArStringInfoGroup)

class ArSyncLoop(ArASyncTask):
    """Proxy of C++ ArSyncLoop 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):
        """__init__(ArSyncLoop self) -> ArSyncLoop"""
        this = _AriaPy.new_ArSyncLoop()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSyncLoop
    __del__ = lambda self: None

    def setRobot(self, robot):
        """setRobot(ArSyncLoop self, ArRobot robot)"""
        return _AriaPy.ArSyncLoop_setRobot(self, robot)


    def stopRunIfNotConnected(self, stopRun):
        """stopRunIfNotConnected(ArSyncLoop self, bool stopRun)"""
        return _AriaPy.ArSyncLoop_stopRunIfNotConnected(self, stopRun)


    def runThread(self, arg):
        """runThread(ArSyncLoop self, void * arg) -> void *"""
        return _AriaPy.ArSyncLoop_runThread(self, arg)


    def getThreadActivity(self):
        """getThreadActivity(ArSyncLoop self) -> char const *"""
        return _AriaPy.ArSyncLoop_getThreadActivity(self)

ArSyncLoop_swigregister = _AriaPy.ArSyncLoop_swigregister
ArSyncLoop_swigregister(ArSyncLoop)

class ArSyncTask(object):
    """Proxy of C++ ArSyncTask 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, name, functor=None, state=None, parent=None):
        """
        __init__(ArSyncTask self, char const * name, ArFunctor functor=None, ArTaskState::State * state=None, ArSyncTask parent=None) -> ArSyncTask
        __init__(ArSyncTask self, char const * name, ArFunctor functor=None, ArTaskState::State * state=None) -> ArSyncTask
        __init__(ArSyncTask self, char const * name, ArFunctor functor=None) -> ArSyncTask
        __init__(ArSyncTask self, char const * name) -> ArSyncTask
        """
        this = _AriaPy.new_ArSyncTask(name, functor, state, parent)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSyncTask
    __del__ = lambda self: None

    def run(self):
        """run(ArSyncTask self)"""
        return _AriaPy.ArSyncTask_run(self)


    def log(self, depth=0):
        """
        log(ArSyncTask self, int depth=0)
        log(ArSyncTask self)
        """
        return _AriaPy.ArSyncTask_log(self, depth)


    def getState(self):
        """getState(ArSyncTask self) -> ArTaskState::State"""
        return _AriaPy.ArSyncTask_getState(self)


    def setState(self, state):
        """setState(ArSyncTask self, ArTaskState::State state)"""
        return _AriaPy.ArSyncTask_setState(self, state)


    def findNonRecursive(self, *args):
        """
        findNonRecursive(ArSyncTask self, char const * name) -> ArSyncTask
        findNonRecursive(ArSyncTask self, ArFunctor functor) -> ArSyncTask
        """
        return _AriaPy.ArSyncTask_findNonRecursive(self, *args)


    def find(self, *args):
        """
        find(ArSyncTask self, char const * name) -> ArSyncTask
        find(ArSyncTask self, ArFunctor functor) -> ArSyncTask
        """
        return _AriaPy.ArSyncTask_find(self, *args)


    def getRunning(self):
        """getRunning(ArSyncTask self) -> ArSyncTask"""
        return _AriaPy.ArSyncTask_getRunning(self)


    def addNewBranch(self, nameOfNew, position, state=None):
        """
        addNewBranch(ArSyncTask self, char const * nameOfNew, int position, ArTaskState::State * state=None)
        addNewBranch(ArSyncTask self, char const * nameOfNew, int position)
        """
        return _AriaPy.ArSyncTask_addNewBranch(self, nameOfNew, position, state)


    def addNewLeaf(self, nameOfNew, position, functor, state=None):
        """
        addNewLeaf(ArSyncTask self, char const * nameOfNew, int position, ArFunctor functor, ArTaskState::State * state=None)
        addNewLeaf(ArSyncTask self, char const * nameOfNew, int position, ArFunctor functor)
        """
        return _AriaPy.ArSyncTask_addNewLeaf(self, nameOfNew, position, functor, state)


    def getName(self):
        """getName(ArSyncTask self) -> std::string"""
        return _AriaPy.ArSyncTask_getName(self)


    def getFunctor(self):
        """getFunctor(ArSyncTask self) -> ArFunctor"""
        return _AriaPy.ArSyncTask_getFunctor(self)


    def setWarningTimeCB(self, functor):
        """setWarningTimeCB(ArSyncTask self, ArRetFunctor_UnsignedInt functor)"""
        return _AriaPy.ArSyncTask_setWarningTimeCB(self, functor)


    def getWarningTimeCB(self):
        """getWarningTimeCB(ArSyncTask self) -> ArRetFunctor_UnsignedInt"""
        return _AriaPy.ArSyncTask_getWarningTimeCB(self)


    def setNoTimeWarningCB(self, functor):
        """setNoTimeWarningCB(ArSyncTask self, ArRetFunctor_Bool functor)"""
        return _AriaPy.ArSyncTask_setNoTimeWarningCB(self, functor)


    def getNoTimeWarningCB(self):
        """getNoTimeWarningCB(ArSyncTask self) -> ArRetFunctor_Bool"""
        return _AriaPy.ArSyncTask_getNoTimeWarningCB(self)


    def remove(self, proc):
        """remove(ArSyncTask self, ArSyncTask proc)"""
        return _AriaPy.ArSyncTask_remove(self, proc)


    def isDeleting(self):
        """isDeleting(ArSyncTask self) -> bool"""
        return _AriaPy.ArSyncTask_isDeleting(self)

ArSyncTask_swigregister = _AriaPy.ArSyncTask_swigregister
ArSyncTask_swigregister(ArSyncTask)

class ArSystemStatus(object):
    """Proxy of C++ ArSystemStatus class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def startPeriodicUpdate(*args):
        """
        startPeriodicUpdate(int refreshFrequency=5000, ArLog::LogLevel logLevel)
        startPeriodicUpdate(int refreshFrequency=5000)
        startPeriodicUpdate()
        """
        return _AriaPy.ArSystemStatus_startPeriodicUpdate(*args)

    startPeriodicUpdate = staticmethod(startPeriodicUpdate)

    def stopPeriodicUpdate():
        """stopPeriodicUpdate()"""
        return _AriaPy.ArSystemStatus_stopPeriodicUpdate()

    stopPeriodicUpdate = staticmethod(stopPeriodicUpdate)

    def runRefreshThread(refreshFrequency=5000):
        """
        runRefreshThread(int refreshFrequency=5000)
        runRefreshThread()
        """
        return _AriaPy.ArSystemStatus_runRefreshThread(refreshFrequency)

    runRefreshThread = staticmethod(runRefreshThread)

    def getCPU():
        """getCPU() -> double"""
        return _AriaPy.ArSystemStatus_getCPU()

    getCPU = staticmethod(getCPU)

    def getCPUPercent():
        """getCPUPercent() -> double"""
        return _AriaPy.ArSystemStatus_getCPUPercent()

    getCPUPercent = staticmethod(getCPUPercent)

    def getCPUPercentAsString():
        """getCPUPercentAsString() -> std::string"""
        return _AriaPy.ArSystemStatus_getCPUPercentAsString()

    getCPUPercentAsString = staticmethod(getCPUPercentAsString)

    def getUptime():
        """getUptime() -> unsigned long"""
        return _AriaPy.ArSystemStatus_getUptime()

    getUptime = staticmethod(getUptime)

    def getProgramUptime():
        """getProgramUptime() -> unsigned long"""
        return _AriaPy.ArSystemStatus_getProgramUptime()

    getProgramUptime = staticmethod(getProgramUptime)

    def getUptimeHours():
        """getUptimeHours() -> double"""
        return _AriaPy.ArSystemStatus_getUptimeHours()

    getUptimeHours = staticmethod(getUptimeHours)

    def getUptimeHoursAsString():
        """getUptimeHoursAsString() -> std::string"""
        return _AriaPy.ArSystemStatus_getUptimeHoursAsString()

    getUptimeHoursAsString = staticmethod(getUptimeHoursAsString)

    def getCPUPercentFunctor():
        """getCPUPercentFunctor() -> ArRetFunctor_Double"""
        return _AriaPy.ArSystemStatus_getCPUPercentFunctor()

    getCPUPercentFunctor = staticmethod(getCPUPercentFunctor)

    def getUptimeHoursFunctor():
        """getUptimeHoursFunctor() -> ArRetFunctor_Double"""
        return _AriaPy.ArSystemStatus_getUptimeHoursFunctor()

    getUptimeHoursFunctor = staticmethod(getUptimeHoursFunctor)

    def getUptimeFunctor():
        """getUptimeFunctor() -> ArRetFunctor< unsigned long > *"""
        return _AriaPy.ArSystemStatus_getUptimeFunctor()

    getUptimeFunctor = staticmethod(getUptimeFunctor)

    def getProgramUptimeFunctor():
        """getProgramUptimeFunctor() -> ArRetFunctor< unsigned long > *"""
        return _AriaPy.ArSystemStatus_getProgramUptimeFunctor()

    getProgramUptimeFunctor = staticmethod(getProgramUptimeFunctor)

    def getWirelessLinkQuality():
        """getWirelessLinkQuality() -> int"""
        return _AriaPy.ArSystemStatus_getWirelessLinkQuality()

    getWirelessLinkQuality = staticmethod(getWirelessLinkQuality)

    def getWirelessLinkSignal():
        """getWirelessLinkSignal() -> int"""
        return _AriaPy.ArSystemStatus_getWirelessLinkSignal()

    getWirelessLinkSignal = staticmethod(getWirelessLinkSignal)

    def getWirelessLinkNoise():
        """getWirelessLinkNoise() -> int"""
        return _AriaPy.ArSystemStatus_getWirelessLinkNoise()

    getWirelessLinkNoise = staticmethod(getWirelessLinkNoise)

    def getWirelessDiscardedPackets():
        """getWirelessDiscardedPackets() -> int"""
        return _AriaPy.ArSystemStatus_getWirelessDiscardedPackets()

    getWirelessDiscardedPackets = staticmethod(getWirelessDiscardedPackets)

    def getWirelessDiscardedPacketsBecauseNetConflict():
        """getWirelessDiscardedPacketsBecauseNetConflict() -> int"""
        return _AriaPy.ArSystemStatus_getWirelessDiscardedPacketsBecauseNetConflict()

    getWirelessDiscardedPacketsBecauseNetConflict = staticmethod(getWirelessDiscardedPacketsBecauseNetConflict)

    def getWirelessLinkQualityFunctor():
        """getWirelessLinkQualityFunctor() -> ArRetFunctor_Int"""
        return _AriaPy.ArSystemStatus_getWirelessLinkQualityFunctor()

    getWirelessLinkQualityFunctor = staticmethod(getWirelessLinkQualityFunctor)

    def getWirelessLinkNoiseFunctor():
        """getWirelessLinkNoiseFunctor() -> ArRetFunctor_Int"""
        return _AriaPy.ArSystemStatus_getWirelessLinkNoiseFunctor()

    getWirelessLinkNoiseFunctor = staticmethod(getWirelessLinkNoiseFunctor)

    def getWirelessLinkSignalFunctor():
        """getWirelessLinkSignalFunctor() -> ArRetFunctor_Int"""
        return _AriaPy.ArSystemStatus_getWirelessLinkSignalFunctor()

    getWirelessLinkSignalFunctor = staticmethod(getWirelessLinkSignalFunctor)

    def invalidate():
        """invalidate()"""
        return _AriaPy.ArSystemStatus_invalidate()

    invalidate = staticmethod(invalidate)

    def refresh():
        """refresh()"""
        return _AriaPy.ArSystemStatus_refresh()

    refresh = staticmethod(refresh)

    def __init__(self):
        """__init__(ArSystemStatus self) -> ArSystemStatus"""
        this = _AriaPy.new_ArSystemStatus()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSystemStatus
    __del__ = lambda self: None
ArSystemStatus_swigregister = _AriaPy.ArSystemStatus_swigregister
ArSystemStatus_swigregister(ArSystemStatus)

def ArSystemStatus_startPeriodicUpdate(*args):
    """
    startPeriodicUpdate(int refreshFrequency=5000, ArLog::LogLevel logLevel)
    startPeriodicUpdate(int refreshFrequency=5000)
    ArSystemStatus_startPeriodicUpdate()
    """
    return _AriaPy.ArSystemStatus_startPeriodicUpdate(*args)

def ArSystemStatus_stopPeriodicUpdate():
    """ArSystemStatus_stopPeriodicUpdate()"""
    return _AriaPy.ArSystemStatus_stopPeriodicUpdate()

def ArSystemStatus_runRefreshThread(refreshFrequency=5000):
    """
    runRefreshThread(int refreshFrequency=5000)
    ArSystemStatus_runRefreshThread()
    """
    return _AriaPy.ArSystemStatus_runRefreshThread(refreshFrequency)

def ArSystemStatus_getCPU():
    """ArSystemStatus_getCPU() -> double"""
    return _AriaPy.ArSystemStatus_getCPU()

def ArSystemStatus_getCPUPercent():
    """ArSystemStatus_getCPUPercent() -> double"""
    return _AriaPy.ArSystemStatus_getCPUPercent()

def ArSystemStatus_getCPUPercentAsString():
    """ArSystemStatus_getCPUPercentAsString() -> std::string"""
    return _AriaPy.ArSystemStatus_getCPUPercentAsString()

def ArSystemStatus_getUptime():
    """ArSystemStatus_getUptime() -> unsigned long"""
    return _AriaPy.ArSystemStatus_getUptime()

def ArSystemStatus_getProgramUptime():
    """ArSystemStatus_getProgramUptime() -> unsigned long"""
    return _AriaPy.ArSystemStatus_getProgramUptime()

def ArSystemStatus_getUptimeHours():
    """ArSystemStatus_getUptimeHours() -> double"""
    return _AriaPy.ArSystemStatus_getUptimeHours()

def ArSystemStatus_getUptimeHoursAsString():
    """ArSystemStatus_getUptimeHoursAsString() -> std::string"""
    return _AriaPy.ArSystemStatus_getUptimeHoursAsString()

def ArSystemStatus_getCPUPercentFunctor():
    """ArSystemStatus_getCPUPercentFunctor() -> ArRetFunctor_Double"""
    return _AriaPy.ArSystemStatus_getCPUPercentFunctor()

def ArSystemStatus_getUptimeHoursFunctor():
    """ArSystemStatus_getUptimeHoursFunctor() -> ArRetFunctor_Double"""
    return _AriaPy.ArSystemStatus_getUptimeHoursFunctor()

def ArSystemStatus_getUptimeFunctor():
    """ArSystemStatus_getUptimeFunctor() -> ArRetFunctor< unsigned long > *"""
    return _AriaPy.ArSystemStatus_getUptimeFunctor()

def ArSystemStatus_getProgramUptimeFunctor():
    """ArSystemStatus_getProgramUptimeFunctor() -> ArRetFunctor< unsigned long > *"""
    return _AriaPy.ArSystemStatus_getProgramUptimeFunctor()

def ArSystemStatus_getWirelessLinkQuality():
    """ArSystemStatus_getWirelessLinkQuality() -> int"""
    return _AriaPy.ArSystemStatus_getWirelessLinkQuality()

def ArSystemStatus_getWirelessLinkSignal():
    """ArSystemStatus_getWirelessLinkSignal() -> int"""
    return _AriaPy.ArSystemStatus_getWirelessLinkSignal()

def ArSystemStatus_getWirelessLinkNoise():
    """ArSystemStatus_getWirelessLinkNoise() -> int"""
    return _AriaPy.ArSystemStatus_getWirelessLinkNoise()

def ArSystemStatus_getWirelessDiscardedPackets():
    """ArSystemStatus_getWirelessDiscardedPackets() -> int"""
    return _AriaPy.ArSystemStatus_getWirelessDiscardedPackets()

def ArSystemStatus_getWirelessDiscardedPacketsBecauseNetConflict():
    """ArSystemStatus_getWirelessDiscardedPacketsBecauseNetConflict() -> int"""
    return _AriaPy.ArSystemStatus_getWirelessDiscardedPacketsBecauseNetConflict()

def ArSystemStatus_getWirelessLinkQualityFunctor():
    """ArSystemStatus_getWirelessLinkQualityFunctor() -> ArRetFunctor_Int"""
    return _AriaPy.ArSystemStatus_getWirelessLinkQualityFunctor()

def ArSystemStatus_getWirelessLinkNoiseFunctor():
    """ArSystemStatus_getWirelessLinkNoiseFunctor() -> ArRetFunctor_Int"""
    return _AriaPy.ArSystemStatus_getWirelessLinkNoiseFunctor()

def ArSystemStatus_getWirelessLinkSignalFunctor():
    """ArSystemStatus_getWirelessLinkSignalFunctor() -> ArRetFunctor_Int"""
    return _AriaPy.ArSystemStatus_getWirelessLinkSignalFunctor()

def ArSystemStatus_invalidate():
    """ArSystemStatus_invalidate()"""
    return _AriaPy.ArSystemStatus_invalidate()

def ArSystemStatus_refresh():
    """ArSystemStatus_refresh()"""
    return _AriaPy.ArSystemStatus_refresh()

ARTCM2_DEFAULT_SERIAL_PORT = _AriaPy.ARTCM2_DEFAULT_SERIAL_PORT
class ArTCM2(object):
    """Proxy of C++ ArTCM2 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__ = _AriaPy.delete_ArTCM2
    __del__ = lambda self: None

    def connect(self):
        """connect(ArTCM2 self) -> bool"""
        return _AriaPy.ArTCM2_connect(self)


    def blockingConnect(self, connectTimeout=5000):
        """
        blockingConnect(ArTCM2 self, unsigned long connectTimeout=5000) -> bool
        blockingConnect(ArTCM2 self) -> bool
        """
        return _AriaPy.ArTCM2_blockingConnect(self, connectTimeout)


    def getHeading(self):
        """getHeading(ArTCM2 self) -> double"""
        return _AriaPy.ArTCM2_getHeading(self)


    def haveHeading(self):
        """haveHeading(ArTCM2 self) -> bool"""
        return _AriaPy.ArTCM2_haveHeading(self)


    def getCompass(self):
        """getCompass(ArTCM2 self) -> double"""
        return _AriaPy.ArTCM2_getCompass(self)


    def getPitch(self):
        """getPitch(ArTCM2 self) -> double"""
        return _AriaPy.ArTCM2_getPitch(self)


    def havePitch(self):
        """havePitch(ArTCM2 self) -> bool"""
        return _AriaPy.ArTCM2_havePitch(self)


    def getRoll(self):
        """getRoll(ArTCM2 self) -> double"""
        return _AriaPy.ArTCM2_getRoll(self)


    def haveRoll(self):
        """haveRoll(ArTCM2 self) -> bool"""
        return _AriaPy.ArTCM2_haveRoll(self)


    def getXMagnetic(self):
        """getXMagnetic(ArTCM2 self) -> double"""
        return _AriaPy.ArTCM2_getXMagnetic(self)


    def haveXMagnetic(self):
        """haveXMagnetic(ArTCM2 self) -> bool"""
        return _AriaPy.ArTCM2_haveXMagnetic(self)


    def getYMagnetic(self):
        """getYMagnetic(ArTCM2 self) -> double"""
        return _AriaPy.ArTCM2_getYMagnetic(self)


    def haveYMagnetic(self):
        """haveYMagnetic(ArTCM2 self) -> bool"""
        return _AriaPy.ArTCM2_haveYMagnetic(self)


    def getZMagnetic(self):
        """getZMagnetic(ArTCM2 self) -> double"""
        return _AriaPy.ArTCM2_getZMagnetic(self)


    def haveZMagnetic(self):
        """haveZMagnetic(ArTCM2 self) -> bool"""
        return _AriaPy.ArTCM2_haveZMagnetic(self)


    def getTemperature(self):
        """getTemperature(ArTCM2 self) -> double"""
        return _AriaPy.ArTCM2_getTemperature(self)


    def haveTemperature(self):
        """haveTemperature(ArTCM2 self) -> bool"""
        return _AriaPy.ArTCM2_haveTemperature(self)


    def getError(self):
        """getError(ArTCM2 self) -> int"""
        return _AriaPy.ArTCM2_getError(self)


    def getCalibrationH(self):
        """getCalibrationH(ArTCM2 self) -> double"""
        return _AriaPy.ArTCM2_getCalibrationH(self)


    def haveCalibrationH(self):
        """haveCalibrationH(ArTCM2 self) -> bool"""
        return _AriaPy.ArTCM2_haveCalibrationH(self)


    def getCalibrationV(self):
        """getCalibrationV(ArTCM2 self) -> double"""
        return _AriaPy.ArTCM2_getCalibrationV(self)


    def haveCalibrationV(self):
        """haveCalibrationV(ArTCM2 self) -> bool"""
        return _AriaPy.ArTCM2_haveCalibrationV(self)


    def getCalibrationM(self):
        """getCalibrationM(ArTCM2 self) -> double"""
        return _AriaPy.ArTCM2_getCalibrationM(self)


    def haveCalibrationM(self):
        """haveCalibrationM(ArTCM2 self) -> bool"""
        return _AriaPy.ArTCM2_haveCalibrationM(self)


    def commandOff(self):
        """commandOff(ArTCM2 self)"""
        return _AriaPy.ArTCM2_commandOff(self)


    def commandOnePacket(self):
        """commandOnePacket(ArTCM2 self)"""
        return _AriaPy.ArTCM2_commandOnePacket(self)


    def commandContinuousPackets(self):
        """commandContinuousPackets(ArTCM2 self)"""
        return _AriaPy.ArTCM2_commandContinuousPackets(self)


    def commandUserCalibration(self):
        """commandUserCalibration(ArTCM2 self)"""
        return _AriaPy.ArTCM2_commandUserCalibration(self)


    def commandAutoCalibration(self):
        """commandAutoCalibration(ArTCM2 self)"""
        return _AriaPy.ArTCM2_commandAutoCalibration(self)


    def commandStopCalibration(self):
        """commandStopCalibration(ArTCM2 self)"""
        return _AriaPy.ArTCM2_commandStopCalibration(self)


    def commandSoftReset(self):
        """commandSoftReset(ArTCM2 self)"""
        return _AriaPy.ArTCM2_commandSoftReset(self)


    def commandJustCompass(self):
        """commandJustCompass(ArTCM2 self)"""
        return _AriaPy.ArTCM2_commandJustCompass(self)


    def getPacCount(self):
        """getPacCount(ArTCM2 self) -> int"""
        return _AriaPy.ArTCM2_getPacCount(self)


    def addHeadingDataCallback(self, f):
        """addHeadingDataCallback(ArTCM2 self, ArFunctor1< double > * f)"""
        return _AriaPy.ArTCM2_addHeadingDataCallback(self, f)

ArTCM2_swigregister = _AriaPy.ArTCM2_swigregister
ArTCM2_swigregister(ArTCM2)

class ArCompassConnector(object):
    """Proxy of C++ ArCompassConnector 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, argParser):
        """__init__(ArCompassConnector self, ArArgumentParser argParser) -> ArCompassConnector"""
        this = _AriaPy.new_ArCompassConnector(argParser)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArCompassConnector
    __del__ = lambda self: None

    def create(self, robot):
        """create(ArCompassConnector self, ArRobot robot) -> ArTCM2"""
        return _AriaPy.ArCompassConnector_create(self, robot)


    def connect(self, arg2):
        """connect(ArCompassConnector self, ArTCM2 arg2) -> bool"""
        return _AriaPy.ArCompassConnector_connect(self, arg2)

ArCompassConnector_swigregister = _AriaPy.ArCompassConnector_swigregister
ArCompassConnector_swigregister(ArCompassConnector)

class ArTCMCompassDirect(ArTCM2):
    """Proxy of C++ ArTCMCompassDirect 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__(ArTCMCompassDirect self, ArDeviceConnection devCon) -> ArTCMCompassDirect
        __init__(ArTCMCompassDirect self, char const * serialPortName) -> ArTCMCompassDirect
        __init__(ArTCMCompassDirect self) -> ArTCMCompassDirect
        """
        this = _AriaPy.new_ArTCMCompassDirect(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArTCMCompassDirect
    __del__ = lambda self: None

    def connect(self):
        """connect(ArTCMCompassDirect self) -> bool"""
        return _AriaPy.ArTCMCompassDirect_connect(self)


    def blockingConnect(self, connectTimeout=5000):
        """
        blockingConnect(ArTCMCompassDirect self, unsigned long connectTimeout=5000) -> bool
        blockingConnect(ArTCMCompassDirect self) -> bool
        """
        return _AriaPy.ArTCMCompassDirect_blockingConnect(self, connectTimeout)


    def commandAutoCalibration(self):
        """commandAutoCalibration(ArTCMCompassDirect self)"""
        return _AriaPy.ArTCMCompassDirect_commandAutoCalibration(self)


    def commandUserCalibration(self):
        """commandUserCalibration(ArTCMCompassDirect self)"""
        return _AriaPy.ArTCMCompassDirect_commandUserCalibration(self)


    def commandStopCalibration(self):
        """commandStopCalibration(ArTCMCompassDirect self)"""
        return _AriaPy.ArTCMCompassDirect_commandStopCalibration(self)


    def commandContinuousPackets(self):
        """commandContinuousPackets(ArTCMCompassDirect self)"""
        return _AriaPy.ArTCMCompassDirect_commandContinuousPackets(self)


    def commandOnePacket(self):
        """commandOnePacket(ArTCMCompassDirect self)"""
        return _AriaPy.ArTCMCompassDirect_commandOnePacket(self)


    def commandOff(self):
        """commandOff(ArTCMCompassDirect self)"""
        return _AriaPy.ArTCMCompassDirect_commandOff(self)


    def commandSoftReset(self):
        """commandSoftReset(ArTCMCompassDirect self)"""
        return _AriaPy.ArTCMCompassDirect_commandSoftReset(self)


    def commandJustCompass(self):
        """commandJustCompass(ArTCMCompassDirect self)"""
        return _AriaPy.ArTCMCompassDirect_commandJustCompass(self)


    def read(self, msWait=1):
        """
        read(ArTCMCompassDirect self, unsigned int msWait=1) -> int
        read(ArTCMCompassDirect self) -> int
        """
        return _AriaPy.ArTCMCompassDirect_read(self, msWait)


    def setDeviceConnection(self, devCon):
        """setDeviceConnection(ArTCMCompassDirect self, ArDeviceConnection devCon)"""
        return _AriaPy.ArTCMCompassDirect_setDeviceConnection(self, devCon)


    def getDeviceConnetion(self):
        """getDeviceConnetion(ArTCMCompassDirect self) -> ArDeviceConnection"""
        return _AriaPy.ArTCMCompassDirect_getDeviceConnetion(self)

ArTCMCompassDirect_swigregister = _AriaPy.ArTCMCompassDirect_swigregister
ArTCMCompassDirect_swigregister(ArTCMCompassDirect)

class ArTCMCompassRobot(ArTCM2):
    """Proxy of C++ ArTCMCompassRobot 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, robot):
        """__init__(ArTCMCompassRobot self, ArRobot robot) -> ArTCMCompassRobot"""
        this = _AriaPy.new_ArTCMCompassRobot(robot)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArTCMCompassRobot
    __del__ = lambda self: None

    def commandOff(self):
        """commandOff(ArTCMCompassRobot self)"""
        return _AriaPy.ArTCMCompassRobot_commandOff(self)


    def commandJustCompass(self):
        """commandJustCompass(ArTCMCompassRobot self)"""
        return _AriaPy.ArTCMCompassRobot_commandJustCompass(self)


    def commandOnePacket(self):
        """commandOnePacket(ArTCMCompassRobot self)"""
        return _AriaPy.ArTCMCompassRobot_commandOnePacket(self)


    def commandContinuousPackets(self):
        """commandContinuousPackets(ArTCMCompassRobot self)"""
        return _AriaPy.ArTCMCompassRobot_commandContinuousPackets(self)


    def commandUserCalibration(self):
        """commandUserCalibration(ArTCMCompassRobot self)"""
        return _AriaPy.ArTCMCompassRobot_commandUserCalibration(self)


    def commandAutoCalibration(self):
        """commandAutoCalibration(ArTCMCompassRobot self)"""
        return _AriaPy.ArTCMCompassRobot_commandAutoCalibration(self)


    def commandStopCalibration(self):
        """commandStopCalibration(ArTCMCompassRobot self)"""
        return _AriaPy.ArTCMCompassRobot_commandStopCalibration(self)


    def commandSoftReset(self):
        """commandSoftReset(ArTCMCompassRobot self)"""
        return _AriaPy.ArTCMCompassRobot_commandSoftReset(self)

ArTCMCompassRobot_swigregister = _AriaPy.ArTCMCompassRobot_swigregister
ArTCMCompassRobot_swigregister(ArTCMCompassRobot)

class ArTaskState(object):
    """Proxy of C++ ArTaskState class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    INIT = _AriaPy.ArTaskState_INIT
    RESUME = _AriaPy.ArTaskState_RESUME
    ACTIVE = _AriaPy.ArTaskState_ACTIVE
    SUSPEND = _AriaPy.ArTaskState_SUSPEND
    SUCCESS = _AriaPy.ArTaskState_SUCCESS
    FAILURE = _AriaPy.ArTaskState_FAILURE
    USER_START = _AriaPy.ArTaskState_USER_START

    def __init__(self):
        """__init__(ArTaskState self) -> ArTaskState"""
        this = _AriaPy.new_ArTaskState()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArTaskState
    __del__ = lambda self: None
ArTaskState_swigregister = _AriaPy.ArTaskState_swigregister
ArTaskState_swigregister(ArTaskState)

class ArTcpConnection(ArDeviceConnection):
    """Proxy of C++ ArTcpConnection 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):
        """__init__(ArTcpConnection self) -> ArTcpConnection"""
        this = _AriaPy.new_ArTcpConnection()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArTcpConnection
    __del__ = lambda self: None

    def open(self, host=None, port=8101):
        """
        open(ArTcpConnection self, char const * host=None, int port=8101) -> int
        open(ArTcpConnection self, char const * host=None) -> int
        open(ArTcpConnection self) -> int
        """
        return _AriaPy.ArTcpConnection_open(self, host, port)


    def setPort(self, host=None, port=8101):
        """
        setPort(ArTcpConnection self, char const * host=None, int port=8101)
        setPort(ArTcpConnection self, char const * host=None)
        setPort(ArTcpConnection self)
        """
        return _AriaPy.ArTcpConnection_setPort(self, host, port)


    def openSimple(self):
        """openSimple(ArTcpConnection self) -> bool"""
        return _AriaPy.ArTcpConnection_openSimple(self)


    def getStatus(self):
        """getStatus(ArTcpConnection self) -> int"""
        return _AriaPy.ArTcpConnection_getStatus(self)


    def close(self):
        """close(ArTcpConnection self) -> bool"""
        return _AriaPy.ArTcpConnection_close(self)


    def read(self, data, size, msWait=0):
        """
        read(ArTcpConnection self, char const * data, unsigned int size, unsigned int msWait=0) -> int
        read(ArTcpConnection self, char const * data, unsigned int size) -> int
        """
        return _AriaPy.ArTcpConnection_read(self, data, size, msWait)


    def write(self, data, size):
        """write(ArTcpConnection self, char const * data, unsigned int size) -> int"""
        return _AriaPy.ArTcpConnection_write(self, data, size)


    def getOpenMessage(self, messageNumber):
        """getOpenMessage(ArTcpConnection self, int messageNumber) -> char const *"""
        return _AriaPy.ArTcpConnection_getOpenMessage(self, messageNumber)


    def getTimeRead(self, index):
        """getTimeRead(ArTcpConnection self, int index) -> ArTime"""
        return _AriaPy.ArTcpConnection_getTimeRead(self, index)


    def isTimeStamping(self):
        """isTimeStamping(ArTcpConnection self) -> bool"""
        return _AriaPy.ArTcpConnection_isTimeStamping(self)


    def getHost(self):
        """getHost(ArTcpConnection self) -> std::string"""
        return _AriaPy.ArTcpConnection_getHost(self)


    def getPort(self):
        """getPort(ArTcpConnection self) -> int"""
        return _AriaPy.ArTcpConnection_getPort(self)


    def internalOpen(self):
        """internalOpen(ArTcpConnection self) -> int"""
        return _AriaPy.ArTcpConnection_internalOpen(self)


    def setSocket(self, socket):
        """setSocket(ArTcpConnection self, ArSocket socket)"""
        return _AriaPy.ArTcpConnection_setSocket(self, socket)


    def getSocket(self):
        """getSocket(ArTcpConnection self) -> ArSocket"""
        return _AriaPy.ArTcpConnection_getSocket(self)


    def setStatus(self, status):
        """setStatus(ArTcpConnection self, int status)"""
        return _AriaPy.ArTcpConnection_setStatus(self, status)

    OPEN_NET_FAIL = _AriaPy.ArTcpConnection_OPEN_NET_FAIL
    OPEN_BAD_HOST = _AriaPy.ArTcpConnection_OPEN_BAD_HOST
    OPEN_NO_ROUTE = _AriaPy.ArTcpConnection_OPEN_NO_ROUTE
    OPEN_CON_REFUSED = _AriaPy.ArTcpConnection_OPEN_CON_REFUSED
ArTcpConnection_swigregister = _AriaPy.ArTcpConnection_swigregister
ArTcpConnection_swigregister(ArTcpConnection)

class ArTransform(object):
    """Proxy of C++ ArTransform 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__(ArTransform self) -> ArTransform
        __init__(ArTransform self, ArPose pose) -> ArTransform
        __init__(ArTransform self, ArPose pose1, ArPose pose2) -> ArTransform
        """
        this = _AriaPy.new_ArTransform(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArTransform
    __del__ = lambda self: None

    def doInvTransform(self, *args):
        """
        doInvTransform(ArTransform self, ArPose source) -> ArPose
        doInvTransform(ArTransform self, ArPoseWithTime source) -> ArPoseWithTime
        """
        return _AriaPy.ArTransform_doInvTransform(self, *args)


    def doTransform(self, *args):
        """
        doTransform(ArTransform self, ArPose source) -> ArPose
        doTransform(ArTransform self, ArPoseWithTime source) -> ArPoseWithTime
        doTransform(ArTransform self, ArPosePtrList poseList)
        doTransform(ArTransform self, ArPoseWithTimePtrList poseList)
        """
        return _AriaPy.ArTransform_doTransform(self, *args)


    def setTransform(self, *args):
        """
        setTransform(ArTransform self, ArPose pose)
        setTransform(ArTransform self, ArPose pose1, ArPose pose2)
        """
        return _AriaPy.ArTransform_setTransform(self, *args)


    def getX(self):
        """getX(ArTransform self) -> double"""
        return _AriaPy.ArTransform_getX(self)


    def getY(self):
        """getY(ArTransform self) -> double"""
        return _AriaPy.ArTransform_getY(self)


    def getTh(self):
        """getTh(ArTransform self) -> double"""
        return _AriaPy.ArTransform_getTh(self)


    def setTransformLowLevel(self, x, y, th):
        """setTransformLowLevel(ArTransform self, double x, double y, double th)"""
        return _AriaPy.ArTransform_setTransformLowLevel(self, x, y, th)

ArTransform_swigregister = _AriaPy.ArTransform_swigregister
ArTransform_swigregister(ArTransform)

class ArTrimbleGPS(ArGPS):
    """Proxy of C++ ArTrimbleGPS 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):
        """__init__(ArTrimbleGPS self) -> ArTrimbleGPS"""
        this = _AriaPy.new_ArTrimbleGPS()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArTrimbleGPS
    __del__ = lambda self: None

    def sendTSIPCommand(self, command, data, dataLen):
        """sendTSIPCommand(ArTrimbleGPS self, char command, char const * data, size_t dataLen) -> bool"""
        return _AriaPy.ArTrimbleGPS_sendTSIPCommand(self, command, data, dataLen)

ArTrimbleGPS_swigregister = _AriaPy.ArTrimbleGPS_swigregister
ArTrimbleGPS_swigregister(ArTrimbleGPS)

class ArUrg(ArLaser):
    """Proxy of C++ ArUrg 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__(ArUrg self, int laserNumber, char const * name) -> ArUrg
        __init__(ArUrg self, int laserNumber) -> ArUrg
        """
        this = _AriaPy.new_ArUrg(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArUrg
    __del__ = lambda self: None

    def blockingConnect(self):
        """blockingConnect(ArUrg self) -> bool"""
        return _AriaPy.ArUrg_blockingConnect(self)


    def asyncConnect(self):
        """asyncConnect(ArUrg self) -> bool"""
        return _AriaPy.ArUrg_asyncConnect(self)


    def disconnect(self):
        """disconnect(ArUrg self) -> bool"""
        return _AriaPy.ArUrg_disconnect(self)


    def isConnected(self):
        """isConnected(ArUrg self) -> bool"""
        return _AriaPy.ArUrg_isConnected(self)


    def isTryingToConnect(self):
        """isTryingToConnect(ArUrg self) -> bool"""
        return _AriaPy.ArUrg_isTryingToConnect(self)


    def log(self):
        """log(ArUrg self)"""
        return _AriaPy.ArUrg_log(self)

ArUrg_swigregister = _AriaPy.ArUrg_swigregister
ArUrg_swigregister(ArUrg)

MAX_RESPONSE_BYTES = _AriaPy.MAX_RESPONSE_BYTES
BIDIRECTIONAL_TIMEOUT = _AriaPy.BIDIRECTIONAL_TIMEOUT
UNIDIRECTIONAL_TIMEOUT = _AriaPy.UNIDIRECTIONAL_TIMEOUT
AUTO_UPDATE_TIME = _AriaPy.AUTO_UPDATE_TIME
TOLERANCE = _AriaPy.TOLERANCE
class ArVCC4Commands(object):
    """Proxy of C++ ArVCC4Commands class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    DELIM = _AriaPy.ArVCC4Commands_DELIM
    DEVICEID = _AriaPy.ArVCC4Commands_DEVICEID
    PANSLEW = _AriaPy.ArVCC4Commands_PANSLEW
    TILTSLEW = _AriaPy.ArVCC4Commands_TILTSLEW
    STOP = _AriaPy.ArVCC4Commands_STOP
    INIT = _AriaPy.ArVCC4Commands_INIT
    SLEWREQ = _AriaPy.ArVCC4Commands_SLEWREQ
    ANGLEREQ = _AriaPy.ArVCC4Commands_ANGLEREQ
    PANTILT = _AriaPy.ArVCC4Commands_PANTILT
    SETRANGE = _AriaPy.ArVCC4Commands_SETRANGE
    PANTILTREQ = _AriaPy.ArVCC4Commands_PANTILTREQ
    INFRARED = _AriaPy.ArVCC4Commands_INFRARED
    PRODUCTNAME = _AriaPy.ArVCC4Commands_PRODUCTNAME
    LEDCONTROL = _AriaPy.ArVCC4Commands_LEDCONTROL
    CONTROL = _AriaPy.ArVCC4Commands_CONTROL
    POWER = _AriaPy.ArVCC4Commands_POWER
    AUTOFOCUS = _AriaPy.ArVCC4Commands_AUTOFOCUS
    ZOOMSTOP = _AriaPy.ArVCC4Commands_ZOOMSTOP
    GAIN = _AriaPy.ArVCC4Commands_GAIN
    FOCUS = _AriaPy.ArVCC4Commands_FOCUS
    ZOOM = _AriaPy.ArVCC4Commands_ZOOM
    ZOOMREQ = _AriaPy.ArVCC4Commands_ZOOMREQ
    IRCUTFILTER = _AriaPy.ArVCC4Commands_IRCUTFILTER
    DIGITALZOOM = _AriaPy.ArVCC4Commands_DIGITALZOOM
    FOOTER = _AriaPy.ArVCC4Commands_FOOTER
    RESPONSE = _AriaPy.ArVCC4Commands_RESPONSE
    HEADER = _AriaPy.ArVCC4Commands_HEADER

    def __init__(self):
        """__init__(ArVCC4Commands self) -> ArVCC4Commands"""
        this = _AriaPy.new_ArVCC4Commands()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArVCC4Commands
    __del__ = lambda self: None
ArVCC4Commands_swigregister = _AriaPy.ArVCC4Commands_swigregister
ArVCC4Commands_swigregister(ArVCC4Commands)

class ArVCC4Packet(ArBasePacket):
    """Proxy of C++ ArVCC4Packet 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, bufferSize=30):
        """
        __init__(ArVCC4Packet self, ArTypes::UByte2 bufferSize=30) -> ArVCC4Packet
        __init__(ArVCC4Packet self) -> ArVCC4Packet
        """
        this = _AriaPy.new_ArVCC4Packet(bufferSize)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArVCC4Packet
    __del__ = lambda self: None

    def byte2ToBuf(self, val):
        """byte2ToBuf(ArVCC4Packet self, ArTypes::Byte4 val)"""
        return _AriaPy.ArVCC4Packet_byte2ToBuf(self, val)


    def finalizePacket(self):
        """finalizePacket(ArVCC4Packet self)"""
        return _AriaPy.ArVCC4Packet_finalizePacket(self)

ArVCC4Packet_swigregister = _AriaPy.ArVCC4Packet_swigregister
ArVCC4Packet_swigregister(ArVCC4Packet)

class ArVCC4(ArPTZ):
    """Proxy of C++ ArVCC4 class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    COMM_UNKNOWN = _AriaPy.ArVCC4_COMM_UNKNOWN
    COMM_BIDIRECTIONAL = _AriaPy.ArVCC4_COMM_BIDIRECTIONAL
    COMM_UNIDIRECTIONAL = _AriaPy.ArVCC4_COMM_UNIDIRECTIONAL
    CAMERA_VCC4 = _AriaPy.ArVCC4_CAMERA_VCC4
    CAMERA_C50I = _AriaPy.ArVCC4_CAMERA_C50I

    def __init__(self, *args):
        """
        __init__(ArVCC4 self, ArRobot robot, bool inverted=False, ArVCC4::CommState commDirection, bool autoUpdate=True, bool disableLED=False, ArVCC4::CameraType cameraType) -> ArVCC4
        __init__(ArVCC4 self, ArRobot robot, bool inverted=False, ArVCC4::CommState commDirection, bool autoUpdate=True, bool disableLED=False) -> ArVCC4
        __init__(ArVCC4 self, ArRobot robot, bool inverted=False, ArVCC4::CommState commDirection, bool autoUpdate=True) -> ArVCC4
        __init__(ArVCC4 self, ArRobot robot, bool inverted=False, ArVCC4::CommState commDirection) -> ArVCC4
        __init__(ArVCC4 self, ArRobot robot, bool inverted=False) -> ArVCC4
        __init__(ArVCC4 self, ArRobot robot) -> ArVCC4
        """
        this = _AriaPy.new_ArVCC4(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArVCC4
    __del__ = lambda self: None

    def power(self, state):
        """power(ArVCC4 self, bool state) -> bool"""
        return _AriaPy.ArVCC4_power(self, state)


    def getPower(self):
        """getPower(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_getPower(self)


    def init(self):
        """init(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_init(self)


    def reset(self):
        """reset(ArVCC4 self)"""
        return _AriaPy.ArVCC4_reset(self)


    def getTypeName(self):
        """getTypeName(ArVCC4 self) -> char const *"""
        return _AriaPy.ArVCC4_getTypeName(self)


    def isInitted(self):
        """isInitted(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_isInitted(self)


    def connectHandler(self):
        """connectHandler(ArVCC4 self)"""
        return _AriaPy.ArVCC4_connectHandler(self)


    def packetHandler(self, packet):
        """packetHandler(ArVCC4 self, ArBasePacket packet) -> bool"""
        return _AriaPy.ArVCC4_packetHandler(self, packet)


    def getRealPanTilt(self):
        """getRealPanTilt(ArVCC4 self)"""
        return _AriaPy.ArVCC4_getRealPanTilt(self)


    def getRealZoomPos(self):
        """getRealZoomPos(ArVCC4 self)"""
        return _AriaPy.ArVCC4_getRealZoomPos(self)


    def canZoom(self):
        """canZoom(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_canZoom(self)


    def zoom(self, deg):
        """zoom(ArVCC4 self, int deg) -> bool"""
        return _AriaPy.ArVCC4_zoom(self, deg)


    def digitalZoom(self, deg):
        """digitalZoom(ArVCC4 self, int deg) -> bool"""
        return _AriaPy.ArVCC4_digitalZoom(self, deg)


    def addErrorCB(self, functor, position):
        """addErrorCB(ArVCC4 self, ArFunctor functor, ArListPos::Pos position)"""
        return _AriaPy.ArVCC4_addErrorCB(self, functor, position)


    def remErrorCB(self, functor):
        """remErrorCB(ArVCC4 self, ArFunctor functor)"""
        return _AriaPy.ArVCC4_remErrorCB(self, functor)


    def haltPanTilt(self):
        """haltPanTilt(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_haltPanTilt(self)


    def haltZoom(self):
        """haltZoom(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_haltZoom(self)


    def panSlew(self, deg):
        """panSlew(ArVCC4 self, double deg) -> bool"""
        return _AriaPy.ArVCC4_panSlew(self, deg)


    def tiltSlew(self, deg):
        """tiltSlew(ArVCC4 self, double deg) -> bool"""
        return _AriaPy.ArVCC4_tiltSlew(self, deg)


    def canSetPanTiltSlew(self):
        """canSetPanTiltSlew(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_canSetPanTiltSlew(self)


    def preparePacket(self, packet):
        """preparePacket(ArVCC4 self, ArVCC4Packet packet)"""
        return _AriaPy.ArVCC4_preparePacket(self, packet)


    def getZoom(self):
        """getZoom(ArVCC4 self) -> int"""
        return _AriaPy.ArVCC4_getZoom(self)


    def getDigitalZoom(self):
        """getDigitalZoom(ArVCC4 self) -> double"""
        return _AriaPy.ArVCC4_getDigitalZoom(self)


    def canGetRealPanTilt(self):
        """canGetRealPanTilt(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_canGetRealPanTilt(self)


    def canGetRealZoom(self):
        """canGetRealZoom(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_canGetRealZoom(self)


    def canSetFocus(self):
        """canSetFocus(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_canSetFocus(self)


    def autoFocus(self):
        """autoFocus(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_autoFocus(self)


    def focusNear(self):
        """focusNear(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_focusNear(self)


    def focusFar(self):
        """focusFar(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_focusFar(self)


    def getPanSlew(self):
        """getPanSlew(ArVCC4 self) -> double"""
        return _AriaPy.ArVCC4_getPanSlew(self)


    def getMaxPanSlew(self):
        """getMaxPanSlew(ArVCC4 self) -> double"""
        return _AriaPy.ArVCC4_getMaxPanSlew(self)


    def getMinPanSlew(self):
        """getMinPanSlew(ArVCC4 self) -> double"""
        return _AriaPy.ArVCC4_getMinPanSlew(self)


    def getTiltSlew(self):
        """getTiltSlew(ArVCC4 self) -> double"""
        return _AriaPy.ArVCC4_getTiltSlew(self)


    def getMaxTiltSlew(self):
        """getMaxTiltSlew(ArVCC4 self) -> double"""
        return _AriaPy.ArVCC4_getMaxTiltSlew(self)


    def getMinTiltSlew(self):
        """getMinTiltSlew(ArVCC4 self) -> double"""
        return _AriaPy.ArVCC4_getMinTiltSlew(self)


    def getMaxZoom(self):
        """getMaxZoom(ArVCC4 self) -> int"""
        return _AriaPy.ArVCC4_getMaxZoom(self)


    def getMinZoom(self):
        """getMinZoom(ArVCC4 self) -> int"""
        return _AriaPy.ArVCC4_getMinZoom(self)


    def canGetFOV(self):
        """canGetFOV(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_canGetFOV(self)


    def getFOVAtMaxZoom(self):
        """getFOVAtMaxZoom(ArVCC4 self) -> double"""
        return _AriaPy.ArVCC4_getFOVAtMaxZoom(self)


    def getFOVAtMinZoom(self):
        """getFOVAtMinZoom(ArVCC4 self) -> double"""
        return _AriaPy.ArVCC4_getFOVAtMinZoom(self)


    def wasError(self):
        """wasError(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_wasError(self)


    def enableAutoUpdate(self):
        """enableAutoUpdate(ArVCC4 self)"""
        return _AriaPy.ArVCC4_enableAutoUpdate(self)


    def disableAutoUpdate(self):
        """disableAutoUpdate(ArVCC4 self)"""
        return _AriaPy.ArVCC4_disableAutoUpdate(self)


    def getAutoUpdate(self):
        """getAutoUpdate(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_getAutoUpdate(self)


    def setLEDControlMode(self, controlMode):
        """setLEDControlMode(ArVCC4 self, int controlMode)"""
        return _AriaPy.ArVCC4_setLEDControlMode(self, controlMode)


    def enableIRLEDs(self):
        """enableIRLEDs(ArVCC4 self)"""
        return _AriaPy.ArVCC4_enableIRLEDs(self)


    def disableIRLEDs(self):
        """disableIRLEDs(ArVCC4 self)"""
        return _AriaPy.ArVCC4_disableIRLEDs(self)


    def getIRLEDsEnabled(self):
        """getIRLEDsEnabled(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_getIRLEDsEnabled(self)


    def enableIRFilterMode(self):
        """enableIRFilterMode(ArVCC4 self)"""
        return _AriaPy.ArVCC4_enableIRFilterMode(self)


    def disableIRFilterMode(self):
        """disableIRFilterMode(ArVCC4 self)"""
        return _AriaPy.ArVCC4_disableIRFilterMode(self)


    def getIRFilterModeEnabled(self):
        """getIRFilterModeEnabled(ArVCC4 self) -> bool"""
        return _AriaPy.ArVCC4_getIRFilterModeEnabled(self)

ArVCC4_swigregister = _AriaPy.ArVCC4_swigregister
ArVCC4_swigregister(ArVCC4)

class ArVersalogicIO(object):
    """Proxy of C++ ArVersalogicIO class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    DIGITAL_INPUT = _AriaPy.ArVersalogicIO_DIGITAL_INPUT
    DIGITAL_OUTPUT = _AriaPy.ArVersalogicIO_DIGITAL_OUTPUT

    def __init__(self, *args):
        """
        __init__(ArVersalogicIO self, char const * dev) -> ArVersalogicIO
        __init__(ArVersalogicIO self) -> ArVersalogicIO
        """
        this = _AriaPy.new_ArVersalogicIO(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArVersalogicIO
    __del__ = lambda self: None

    def closeIO(self):
        """closeIO(ArVersalogicIO self) -> bool"""
        return _AriaPy.ArVersalogicIO_closeIO(self)


    def isEnabled(self):
        """isEnabled(ArVersalogicIO self) -> bool"""
        return _AriaPy.ArVersalogicIO_isEnabled(self)


    def isAnalogSupported(self):
        """isAnalogSupported(ArVersalogicIO self) -> bool"""
        return _AriaPy.ArVersalogicIO_isAnalogSupported(self)


    def getAnalogValue(self, port, val):
        """getAnalogValue(ArVersalogicIO self, int port, double * val) -> bool"""
        return _AriaPy.ArVersalogicIO_getAnalogValue(self, port, val)


    def getAnalogValueRaw(self, port, val):
        """getAnalogValueRaw(ArVersalogicIO self, int port, int * val) -> bool"""
        return _AriaPy.ArVersalogicIO_getAnalogValueRaw(self, port, val)


    def getDigitalBankDirection(self, bank):
        """getDigitalBankDirection(ArVersalogicIO self, int bank) -> ArVersalogicIO::Direction"""
        return _AriaPy.ArVersalogicIO_getDigitalBankDirection(self, bank)


    def setDigitalBankDirection(self, bank, dir):
        """setDigitalBankDirection(ArVersalogicIO self, int bank, ArVersalogicIO::Direction dir) -> bool"""
        return _AriaPy.ArVersalogicIO_setDigitalBankDirection(self, bank, dir)


    def getDigitalBankInputs(self, bank, val):
        """getDigitalBankInputs(ArVersalogicIO self, int bank, unsigned char * val) -> bool"""
        return _AriaPy.ArVersalogicIO_getDigitalBankInputs(self, bank, val)


    def getDigitalBankOutputs(self, bank, val):
        """getDigitalBankOutputs(ArVersalogicIO self, int bank, unsigned char * val) -> bool"""
        return _AriaPy.ArVersalogicIO_getDigitalBankOutputs(self, bank, val)


    def setDigitalBankOutputs(self, bank, val):
        """setDigitalBankOutputs(ArVersalogicIO self, int bank, unsigned char val) -> bool"""
        return _AriaPy.ArVersalogicIO_setDigitalBankOutputs(self, bank, val)


    def getSpecialControlRegister(self, val):
        """getSpecialControlRegister(ArVersalogicIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArVersalogicIO_getSpecialControlRegister(self, val)


    def lock(self):
        """lock(ArVersalogicIO self) -> int"""
        return _AriaPy.ArVersalogicIO_lock(self)


    def unlock(self):
        """unlock(ArVersalogicIO self) -> int"""
        return _AriaPy.ArVersalogicIO_unlock(self)


    def tryLock(self):
        """tryLock(ArVersalogicIO self) -> int"""
        return _AriaPy.ArVersalogicIO_tryLock(self)

ArVersalogicIO_swigregister = _AriaPy.ArVersalogicIO_swigregister
ArVersalogicIO_swigregister(ArVersalogicIO)

class ArMTXIO(object):
    """Proxy of C++ ArMTXIO class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    DIGITAL_INPUT = _AriaPy.ArMTXIO_DIGITAL_INPUT
    DIGITAL_OUTPUT = _AriaPy.ArMTXIO_DIGITAL_OUTPUT
    INVALID = _AriaPy.ArMTXIO_INVALID

    def __init__(self, *args):
        """
        __init__(ArMTXIO self, char const * dev) -> ArMTXIO
        __init__(ArMTXIO self) -> ArMTXIO
        """
        this = _AriaPy.new_ArMTXIO(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMTXIO
    __del__ = lambda self: None

    def closeIO(self):
        """closeIO(ArMTXIO self) -> bool"""
        return _AriaPy.ArMTXIO_closeIO(self)


    def isEnabled(self):
        """isEnabled(ArMTXIO self) -> bool"""
        return _AriaPy.ArMTXIO_isEnabled(self)


    def isAnalogSupported(self):
        """isAnalogSupported(ArMTXIO self) -> bool"""
        return _AriaPy.ArMTXIO_isAnalogSupported(self)


    def getDigitalBankDirection(self, bank):
        """getDigitalBankDirection(ArMTXIO self, int bank) -> ArMTXIO::Direction"""
        return _AriaPy.ArMTXIO_getDigitalBankDirection(self, bank)


    def setDigitalBankOutputs(self, bank, val):
        """setDigitalBankOutputs(ArMTXIO self, int bank, unsigned char val) -> bool"""
        return _AriaPy.ArMTXIO_setDigitalBankOutputs(self, bank, val)


    def getDigitalBankInputs(self, bank, val):
        """getDigitalBankInputs(ArMTXIO self, int bank, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getDigitalBankInputs(self, bank, val)


    def getDigitalBankOutputs(self, bank, val):
        """getDigitalBankOutputs(ArMTXIO self, int bank, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getDigitalBankOutputs(self, bank, val)


    def setDigitalOutputBit(self, bank, bit):
        """setDigitalOutputBit(ArMTXIO self, int bank, int bit) -> bool"""
        return _AriaPy.ArMTXIO_setDigitalOutputBit(self, bank, bit)


    def getDigitalInputBit(self, bank, bit):
        """getDigitalInputBit(ArMTXIO self, int bank, int bit) -> bool"""
        return _AriaPy.ArMTXIO_getDigitalInputBit(self, bank, bit)


    def setPeripheralPowerBankOutputs(self, bank, val):
        """setPeripheralPowerBankOutputs(ArMTXIO self, int bank, unsigned char val) -> bool"""
        return _AriaPy.ArMTXIO_setPeripheralPowerBankOutputs(self, bank, val)


    def getPeripheralPowerBankOutputs(self, bank, val):
        """getPeripheralPowerBankOutputs(ArMTXIO self, int bank, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getPeripheralPowerBankOutputs(self, bank, val)


    def setPowerOutput(self, bank, bit, on):
        """setPowerOutput(ArMTXIO self, int bank, int bit, bool on) -> bool"""
        return _AriaPy.ArMTXIO_setPowerOutput(self, bank, bit, on)


    def lock(self):
        """lock(ArMTXIO self) -> int"""
        return _AriaPy.ArMTXIO_lock(self)


    def unlock(self):
        """unlock(ArMTXIO self) -> int"""
        return _AriaPy.ArMTXIO_unlock(self)


    def tryLock(self):
        """tryLock(ArMTXIO self) -> int"""
        return _AriaPy.ArMTXIO_tryLock(self)


    def getFirmwareRevision(self):
        """getFirmwareRevision(ArMTXIO self) -> unsigned char"""
        return _AriaPy.ArMTXIO_getFirmwareRevision(self)


    def getFirmwareVersion(self):
        """getFirmwareVersion(ArMTXIO self) -> unsigned char"""
        return _AriaPy.ArMTXIO_getFirmwareVersion(self)


    def getCompatibilityCode(self):
        """getCompatibilityCode(ArMTXIO self) -> unsigned char"""
        return _AriaPy.ArMTXIO_getCompatibilityCode(self)


    def getFPGAType(self):
        """getFPGAType(ArMTXIO self) -> unsigned char"""
        return _AriaPy.ArMTXIO_getFPGAType(self)


    def getDigitalIOInputMon1(self, val):
        """getDigitalIOInputMon1(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getDigitalIOInputMon1(self, val)


    def getDigitalIOInputMon2(self, val):
        """getDigitalIOInputMon2(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getDigitalIOInputMon2(self, val)


    def getDigitalIOOutputMon1(self, val):
        """getDigitalIOOutputMon1(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getDigitalIOOutputMon1(self, val)


    def getDigitalIOOutputMon2(self, val):
        """getDigitalIOOutputMon2(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getDigitalIOOutputMon2(self, val)


    def getLightPole(self, val):
        """getLightPole(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getLightPole(self, val)


    def setLightPole(self, val):
        """setLightPole(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_setLightPole(self, val)


    def getLPCTimeUSec(self, timeUSec):
        """getLPCTimeUSec(ArMTXIO self, ArTypes::UByte4 * timeUSec) -> bool"""
        return _AriaPy.ArMTXIO_getLPCTimeUSec(self, timeUSec)


    def getLPCTimeUSecCB(self):
        """getLPCTimeUSecCB(ArMTXIO self) -> ArRetFunctor1< bool,ArTypes::UByte4 * > *"""
        return _AriaPy.ArMTXIO_getLPCTimeUSecCB(self)


    def setSemaphore1(self, val):
        """setSemaphore1(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_setSemaphore1(self, val)


    def getSemaphore1(self, val):
        """getSemaphore1(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getSemaphore1(self, val)


    def setSemaphore2(self, val):
        """setSemaphore2(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_setSemaphore2(self, val)


    def getSemaphore2(self, val):
        """getSemaphore2(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getSemaphore2(self, val)


    def setSemaphore3(self, val):
        """setSemaphore3(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_setSemaphore3(self, val)


    def getSemaphore3(self, val):
        """getSemaphore3(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getSemaphore3(self, val)


    def setSemaphore4(self, val):
        """setSemaphore4(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_setSemaphore4(self, val)


    def getSemaphore4(self, val):
        """getSemaphore4(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getSemaphore4(self, val)


    def getBumperInput(self, val):
        """getBumperInput(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getBumperInput(self, val)


    def getPowerStatus1(self, val):
        """getPowerStatus1(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getPowerStatus1(self, val)


    def getPowerStatus2(self, val):
        """getPowerStatus2(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getPowerStatus2(self, val)


    def getLIDARSafety(self, val):
        """getLIDARSafety(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getLIDARSafety(self, val)


    def getESTOPStatus1(self, val):
        """getESTOPStatus1(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getESTOPStatus1(self, val)


    def getESTOPStatus2(self, val):
        """getESTOPStatus2(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getESTOPStatus2(self, val)


    def getESTOPStatus3(self, val):
        """getESTOPStatus3(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getESTOPStatus3(self, val)


    def getESTOPStatus4(self, val):
        """getESTOPStatus4(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getESTOPStatus4(self, val)


    def compareESTOPStatus4HighNibbleAgainst(self, val):
        """compareESTOPStatus4HighNibbleAgainst(ArMTXIO self, int val) -> bool"""
        return _AriaPy.ArMTXIO_compareESTOPStatus4HighNibbleAgainst(self, val)


    def getDigitalOutputControl1(self, val):
        """getDigitalOutputControl1(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getDigitalOutputControl1(self, val)


    def setDigitalOutputControl1(self, val):
        """setDigitalOutputControl1(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_setDigitalOutputControl1(self, val)


    def getDigitalOutputControl2(self, val):
        """getDigitalOutputControl2(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getDigitalOutputControl2(self, val)


    def setDigitalOutputControl2(self, val):
        """setDigitalOutputControl2(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_setDigitalOutputControl2(self, val)


    def getPeripheralPower1(self, val):
        """getPeripheralPower1(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getPeripheralPower1(self, val)


    def setPeripheralPower1(self, val):
        """setPeripheralPower1(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_setPeripheralPower1(self, val)


    def getPeripheralPower2(self, val):
        """getPeripheralPower2(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getPeripheralPower2(self, val)


    def setPeripheralPower2(self, val):
        """setPeripheralPower2(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_setPeripheralPower2(self, val)


    def getPeripheralPower3(self, val):
        """getPeripheralPower3(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getPeripheralPower3(self, val)


    def setPeripheralPower3(self, val):
        """setPeripheralPower3(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_setPeripheralPower3(self, val)


    def getMotionPowerStatus(self, val):
        """getMotionPowerStatus(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getMotionPowerStatus(self, val)


    def getLIDARControl(self, val):
        """getLIDARControl(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_getLIDARControl(self, val)


    def setLIDARControl(self, val):
        """setLIDARControl(ArMTXIO self, unsigned char * val) -> bool"""
        return _AriaPy.ArMTXIO_setLIDARControl(self, val)


    def getAnalogIOBlock1(self, analog, val):
        """getAnalogIOBlock1(ArMTXIO self, int analog, unsigned short * val) -> bool"""
        return _AriaPy.ArMTXIO_getAnalogIOBlock1(self, analog, val)


    def getAnalogIOBlock2(self, analog, val):
        """getAnalogIOBlock2(ArMTXIO self, int analog, unsigned short * val) -> bool"""
        return _AriaPy.ArMTXIO_getAnalogIOBlock2(self, analog, val)


    def setAnalogIOBlock2(self, analog, val):
        """setAnalogIOBlock2(ArMTXIO self, int analog, unsigned short * val) -> bool"""
        return _AriaPy.ArMTXIO_setAnalogIOBlock2(self, analog, val)


    def getAnalogValue(self, *args):
        """
        getAnalogValue(ArMTXIO self, int port, double * val) -> bool
        getAnalogValue(ArMTXIO self, double * val) -> bool
        """
        return _AriaPy.ArMTXIO_getAnalogValue(self, *args)


    def getAnalogValueRaw(self, *args):
        """
        getAnalogValueRaw(ArMTXIO self, int port, int * val) -> bool
        getAnalogValueRaw(ArMTXIO self, int * val) -> bool
        """
        return _AriaPy.ArMTXIO_getAnalogValueRaw(self, *args)

ArMTXIO_swigregister = _AriaPy.ArMTXIO_swigregister
ArMTXIO_swigregister(ArMTXIO)

class Aria(object):
    """Proxy of C++ Aria class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    SIGHANDLE_SINGLE = _AriaPy.Aria_SIGHANDLE_SINGLE
    SIGHANDLE_THREAD = _AriaPy.Aria_SIGHANDLE_THREAD
    SIGHANDLE_NONE = _AriaPy.Aria_SIGHANDLE_NONE

    def init(*args):
        """
        init(Aria::SigHandleMethod method, bool initSockets=True, bool sigHandleExitNotShutdown=True)
        init(Aria::SigHandleMethod method, bool initSockets=True)
        init(Aria::SigHandleMethod method)
        init()
        """
        return _AriaPy.Aria_init(*args)

    init = staticmethod(init)

    def uninit():
        """uninit()"""
        return _AriaPy.Aria_uninit()

    uninit = staticmethod(uninit)

    def addInitCallBack(cb, position):
        """addInitCallBack(ArFunctor cb, ArListPos::Pos position)"""
        return _AriaPy.Aria_addInitCallBack(cb, position)

    addInitCallBack = staticmethod(addInitCallBack)

    def addUninitCallBack(cb, position):
        """addUninitCallBack(ArFunctor cb, ArListPos::Pos position)"""
        return _AriaPy.Aria_addUninitCallBack(cb, position)

    addUninitCallBack = staticmethod(addUninitCallBack)

    def shutdown():
        """shutdown()"""
        return _AriaPy.Aria_shutdown()

    shutdown = staticmethod(shutdown)

    def exit(exitCode=0):
        """
        exit(int exitCode=0)
        exit()
        """
        return _AriaPy.Aria_exit(exitCode)

    exit = staticmethod(exit)

    def getRunning():
        """getRunning() -> bool"""
        return _AriaPy.Aria_getRunning()

    getRunning = staticmethod(getRunning)

    def setDirectory(directory):
        """setDirectory(char const * directory)"""
        return _AriaPy.Aria_setDirectory(directory)

    setDirectory = staticmethod(setDirectory)

    def getDirectory():
        """getDirectory() -> char const *"""
        return _AriaPy.Aria_getDirectory()

    getDirectory = staticmethod(getDirectory)

    def parseArgs():
        """parseArgs() -> bool"""
        return _AriaPy.Aria_parseArgs()

    parseArgs = staticmethod(parseArgs)

    def logOptions():
        """logOptions()"""
        return _AriaPy.Aria_logOptions()

    logOptions = staticmethod(logOptions)

    def setKeyHandler(keyHandler):
        """setKeyHandler(ArKeyHandler keyHandler)"""
        return _AriaPy.Aria_setKeyHandler(keyHandler)

    setKeyHandler = staticmethod(setKeyHandler)

    def getKeyHandler():
        """getKeyHandler() -> ArKeyHandler"""
        return _AriaPy.Aria_getKeyHandler()

    getKeyHandler = staticmethod(getKeyHandler)

    def setJoyHandler(joyHandler):
        """setJoyHandler(ArJoyHandler joyHandler)"""
        return _AriaPy.Aria_setJoyHandler(joyHandler)

    setJoyHandler = staticmethod(setJoyHandler)

    def getJoyHandler():
        """getJoyHandler() -> ArJoyHandler"""
        return _AriaPy.Aria_getJoyHandler()

    getJoyHandler = staticmethod(getJoyHandler)

    def addExitCallback(functor, position=50):
        """
        addExitCallback(ArFunctor functor, int position=50)
        addExitCallback(ArFunctor functor)
        """
        return _AriaPy.Aria_addExitCallback(functor, position)

    addExitCallback = staticmethod(addExitCallback)

    def remExitCallback(functor):
        """remExitCallback(ArFunctor functor)"""
        return _AriaPy.Aria_remExitCallback(functor)

    remExitCallback = staticmethod(remExitCallback)

    def setExitCallbacksLogLevel(level):
        """setExitCallbacksLogLevel(ArLog::LogLevel level)"""
        return _AriaPy.Aria_setExitCallbacksLogLevel(level)

    setExitCallbacksLogLevel = staticmethod(setExitCallbacksLogLevel)

    def exitOld(exitCode=0):
        """
        exitOld(int exitCode=0)
        exitOld()
        """
        return _AriaPy.Aria_exitOld(exitCode)

    exitOld = staticmethod(exitOld)

    def signalHandlerCB(sig):
        """signalHandlerCB(int sig)"""
        return _AriaPy.Aria_signalHandlerCB(sig)

    signalHandlerCB = staticmethod(signalHandlerCB)

    def callExitCallbacks():
        """callExitCallbacks()"""
        return _AriaPy.Aria_callExitCallbacks()

    callExitCallbacks = staticmethod(callExitCallbacks)

    def addParseArgsCB(functor, position=50):
        """
        addParseArgsCB(ArRetFunctor_Bool functor, int position=50)
        addParseArgsCB(ArRetFunctor_Bool functor)
        """
        return _AriaPy.Aria_addParseArgsCB(functor, position)

    addParseArgsCB = staticmethod(addParseArgsCB)

    def setParseArgLogLevel(level):
        """setParseArgLogLevel(ArLog::LogLevel level)"""
        return _AriaPy.Aria_setParseArgLogLevel(level)

    setParseArgLogLevel = staticmethod(setParseArgLogLevel)

    def addLogOptionsCB(functor, position=50):
        """
        addLogOptionsCB(ArFunctor functor, int position=50)
        addLogOptionsCB(ArFunctor functor)
        """
        return _AriaPy.Aria_addLogOptionsCB(functor, position)

    addLogOptionsCB = staticmethod(addLogOptionsCB)

    def deviceConnectionAddCreator(deviceConnectionType, creator):
        """deviceConnectionAddCreator(char const * deviceConnectionType, ArRetFunctor3< ArDeviceConnection *,char const *,char const *,char const * > * creator) -> bool"""
        return _AriaPy.Aria_deviceConnectionAddCreator(deviceConnectionType, creator)

    deviceConnectionAddCreator = staticmethod(deviceConnectionAddCreator)

    def deviceConnectionGetTypes():
        """deviceConnectionGetTypes() -> char const *"""
        return _AriaPy.Aria_deviceConnectionGetTypes()

    deviceConnectionGetTypes = staticmethod(deviceConnectionGetTypes)

    def deviceConnectionGetChoices():
        """deviceConnectionGetChoices() -> char const *"""
        return _AriaPy.Aria_deviceConnectionGetChoices()

    deviceConnectionGetChoices = staticmethod(deviceConnectionGetChoices)

    def deviceConnectionCreate(*args):
        """
        deviceConnectionCreate(char const * deviceConnectionType, char const * port, char const * defaultInfo, char const * prefix) -> ArDeviceConnection
        deviceConnectionCreate(char const * deviceConnectionType, char const * port, char const * defaultInfo) -> ArDeviceConnection
        """
        return _AriaPy.Aria_deviceConnectionCreate(*args)

    deviceConnectionCreate = staticmethod(deviceConnectionCreate)

    def setRobotJoyHandler(robotJoyHandler):
        """setRobotJoyHandler(ArRobotJoyHandler robotJoyHandler)"""
        return _AriaPy.Aria_setRobotJoyHandler(robotJoyHandler)

    setRobotJoyHandler = staticmethod(setRobotJoyHandler)

    def getRobotJoyHandler():
        """getRobotJoyHandler() -> ArRobotJoyHandler"""
        return _AriaPy.Aria_getRobotJoyHandler()

    getRobotJoyHandler = staticmethod(getRobotJoyHandler)

    def getConfig():
        """getConfig() -> ArConfig"""
        return _AriaPy.Aria_getConfig()

    getConfig = staticmethod(getConfig)

    def getInfoGroup():
        """getInfoGroup() -> ArStringInfoGroup"""
        return _AriaPy.Aria_getInfoGroup()

    getInfoGroup = staticmethod(getInfoGroup)

    def addRobot(robot):
        """addRobot(ArRobot robot)"""
        return _AriaPy.Aria_addRobot(robot)

    addRobot = staticmethod(addRobot)

    def delRobot(robot):
        """delRobot(ArRobot robot)"""
        return _AriaPy.Aria_delRobot(robot)

    delRobot = staticmethod(delRobot)

    def findRobot(name):
        """findRobot(char * name) -> ArRobot"""
        return _AriaPy.Aria_findRobot(name)

    findRobot = staticmethod(findRobot)

    def getRobotList():
        """getRobotList() -> std::list< ArRobot *,std::allocator< ArRobot * > > *"""
        return _AriaPy.Aria_getRobotList()

    getRobotList = staticmethod(getRobotList)

    def getMaxNumLasers():
        """getMaxNumLasers() -> int"""
        return _AriaPy.Aria_getMaxNumLasers()

    getMaxNumLasers = staticmethod(getMaxNumLasers)

    def setMaxNumLasers(maxNumLasers):
        """setMaxNumLasers(int maxNumLasers)"""
        return _AriaPy.Aria_setMaxNumLasers(maxNumLasers)

    setMaxNumLasers = staticmethod(setMaxNumLasers)

    def getMaxNumSonarBoards():
        """getMaxNumSonarBoards() -> int"""
        return _AriaPy.Aria_getMaxNumSonarBoards()

    getMaxNumSonarBoards = staticmethod(getMaxNumSonarBoards)

    def setMaxNumSonarBoards(maxNumSonarBoards):
        """setMaxNumSonarBoards(int maxNumSonarBoards)"""
        return _AriaPy.Aria_setMaxNumSonarBoards(maxNumSonarBoards)

    setMaxNumSonarBoards = staticmethod(setMaxNumSonarBoards)

    def getMaxNumBatteries():
        """getMaxNumBatteries() -> int"""
        return _AriaPy.Aria_getMaxNumBatteries()

    getMaxNumBatteries = staticmethod(getMaxNumBatteries)

    def setMaxNumBatteries(maxNumBatteries):
        """setMaxNumBatteries(int maxNumBatteries)"""
        return _AriaPy.Aria_setMaxNumBatteries(maxNumBatteries)

    setMaxNumBatteries = staticmethod(setMaxNumBatteries)

    def getMaxNumLCDs():
        """getMaxNumLCDs() -> int"""
        return _AriaPy.Aria_getMaxNumLCDs()

    getMaxNumLCDs = staticmethod(getMaxNumLCDs)

    def setMaxNumLCDs(maxNumLCDs):
        """setMaxNumLCDs(int maxNumLCDs)"""
        return _AriaPy.Aria_setMaxNumLCDs(maxNumLCDs)

    setMaxNumLCDs = staticmethod(setMaxNumLCDs)

    def laserCreate(*args):
        """
        laserCreate(char const * laserType, int laserNumber, char const * prefix) -> ArLaser
        laserCreate(char const * laserType, int laserNumber) -> ArLaser
        """
        return _AriaPy.Aria_laserCreate(*args)

    laserCreate = staticmethod(laserCreate)

    def laserAddCreator(laserType, creator):
        """laserAddCreator(char const * laserType, ArRetFunctor2< ArLaser *,int,char const * > * creator) -> bool"""
        return _AriaPy.Aria_laserAddCreator(laserType, creator)

    laserAddCreator = staticmethod(laserAddCreator)

    def laserGetTypes():
        """laserGetTypes() -> char const *"""
        return _AriaPy.Aria_laserGetTypes()

    laserGetTypes = staticmethod(laserGetTypes)

    def laserGetChoices():
        """laserGetChoices() -> char const *"""
        return _AriaPy.Aria_laserGetChoices()

    laserGetChoices = staticmethod(laserGetChoices)

    def batteryCreate(*args):
        """
        batteryCreate(char const * batteryType, int batteryNumber, char const * prefix) -> ArBatteryMTX
        batteryCreate(char const * batteryType, int batteryNumber) -> ArBatteryMTX *
        """
        return _AriaPy.Aria_batteryCreate(*args)

    batteryCreate = staticmethod(batteryCreate)

    def batteryAddCreator(batteryType, creator):
        """batteryAddCreator(char const * batteryType, ArRetFunctor2< ArBatteryMTX *,int,char const * > * creator) -> bool"""
        return _AriaPy.Aria_batteryAddCreator(batteryType, creator)

    batteryAddCreator = staticmethod(batteryAddCreator)

    def batteryGetTypes():
        """batteryGetTypes() -> char const *"""
        return _AriaPy.Aria_batteryGetTypes()

    batteryGetTypes = staticmethod(batteryGetTypes)

    def batteryGetChoices():
        """batteryGetChoices() -> char const *"""
        return _AriaPy.Aria_batteryGetChoices()

    batteryGetChoices = staticmethod(batteryGetChoices)

    def lcdCreate(*args):
        """
        lcdCreate(char const * lcdType, int lcdNumber, char const * prefix) -> ArLCDMTX
        lcdCreate(char const * lcdType, int lcdNumber) -> ArLCDMTX *
        """
        return _AriaPy.Aria_lcdCreate(*args)

    lcdCreate = staticmethod(lcdCreate)

    def lcdAddCreator(lcdType, creator):
        """lcdAddCreator(char const * lcdType, ArRetFunctor2< ArLCDMTX *,int,char const * > * creator) -> bool"""
        return _AriaPy.Aria_lcdAddCreator(lcdType, creator)

    lcdAddCreator = staticmethod(lcdAddCreator)

    def lcdGetTypes():
        """lcdGetTypes() -> char const *"""
        return _AriaPy.Aria_lcdGetTypes()

    lcdGetTypes = staticmethod(lcdGetTypes)

    def lcdGetChoices():
        """lcdGetChoices() -> char const *"""
        return _AriaPy.Aria_lcdGetChoices()

    lcdGetChoices = staticmethod(lcdGetChoices)

    def sonarCreate(*args):
        """
        sonarCreate(char const * sonarType, int sonarNumber, char const * prefix) -> ArSonarMTX
        sonarCreate(char const * sonarType, int sonarNumber) -> ArSonarMTX *
        """
        return _AriaPy.Aria_sonarCreate(*args)

    sonarCreate = staticmethod(sonarCreate)

    def sonarAddCreator(sonarType, creator):
        """sonarAddCreator(char const * sonarType, ArRetFunctor2< ArSonarMTX *,int,char const * > * creator) -> bool"""
        return _AriaPy.Aria_sonarAddCreator(sonarType, creator)

    sonarAddCreator = staticmethod(sonarAddCreator)

    def sonarGetTypes():
        """sonarGetTypes() -> char const *"""
        return _AriaPy.Aria_sonarGetTypes()

    sonarGetTypes = staticmethod(sonarGetTypes)

    def sonarGetChoices():
        """sonarGetChoices() -> char const *"""
        return _AriaPy.Aria_sonarGetChoices()

    sonarGetChoices = staticmethod(sonarGetChoices)

    def setMaxNumVideoDevices(n):
        """setMaxNumVideoDevices(size_t n)"""
        return _AriaPy.Aria_setMaxNumVideoDevices(n)

    setMaxNumVideoDevices = staticmethod(setMaxNumVideoDevices)

    def getMaxNumVideoDevices():
        """getMaxNumVideoDevices() -> size_t"""
        return _AriaPy.Aria_getMaxNumVideoDevices()

    getMaxNumVideoDevices = staticmethod(getMaxNumVideoDevices)

    def setMaxNumPTZs(n):
        """setMaxNumPTZs(size_t n)"""
        return _AriaPy.Aria_setMaxNumPTZs(n)

    setMaxNumPTZs = staticmethod(setMaxNumPTZs)

    def getMaxNumPTZs():
        """getMaxNumPTZs() -> size_t"""
        return _AriaPy.Aria_getMaxNumPTZs()

    getMaxNumPTZs = staticmethod(getMaxNumPTZs)

    def getIdentifier():
        """getIdentifier() -> char const *"""
        return _AriaPy.Aria_getIdentifier()

    getIdentifier = staticmethod(getIdentifier)

    def setIdentifier(identifier):
        """setIdentifier(char const * identifier)"""
        return _AriaPy.Aria_setIdentifier(identifier)

    setIdentifier = staticmethod(setIdentifier)

    def __init__(self):
        """__init__(Aria self) -> Aria"""
        this = _AriaPy.new_Aria()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_Aria
    __del__ = lambda self: None
Aria_swigregister = _AriaPy.Aria_swigregister
Aria_swigregister(Aria)

def Aria_init(*args):
    """
    init(Aria::SigHandleMethod method, bool initSockets=True, bool sigHandleExitNotShutdown=True)
    init(Aria::SigHandleMethod method, bool initSockets=True)
    init(Aria::SigHandleMethod method)
    Aria_init()
    """
    return _AriaPy.Aria_init(*args)

def Aria_uninit():
    """Aria_uninit()"""
    return _AriaPy.Aria_uninit()

def Aria_addInitCallBack(cb, position):
    """Aria_addInitCallBack(ArFunctor cb, ArListPos::Pos position)"""
    return _AriaPy.Aria_addInitCallBack(cb, position)

def Aria_addUninitCallBack(cb, position):
    """Aria_addUninitCallBack(ArFunctor cb, ArListPos::Pos position)"""
    return _AriaPy.Aria_addUninitCallBack(cb, position)

def Aria_shutdown():
    """Aria_shutdown()"""
    return _AriaPy.Aria_shutdown()

def Aria_exit(exitCode=0):
    """
    exit(int exitCode=0)
    Aria_exit()
    """
    return _AriaPy.Aria_exit(exitCode)

def Aria_getRunning():
    """Aria_getRunning() -> bool"""
    return _AriaPy.Aria_getRunning()

def Aria_setDirectory(directory):
    """Aria_setDirectory(char const * directory)"""
    return _AriaPy.Aria_setDirectory(directory)

def Aria_getDirectory():
    """Aria_getDirectory() -> char const *"""
    return _AriaPy.Aria_getDirectory()

def Aria_parseArgs():
    """Aria_parseArgs() -> bool"""
    return _AriaPy.Aria_parseArgs()

def Aria_logOptions():
    """Aria_logOptions()"""
    return _AriaPy.Aria_logOptions()

def Aria_setKeyHandler(keyHandler):
    """Aria_setKeyHandler(ArKeyHandler keyHandler)"""
    return _AriaPy.Aria_setKeyHandler(keyHandler)

def Aria_getKeyHandler():
    """Aria_getKeyHandler() -> ArKeyHandler"""
    return _AriaPy.Aria_getKeyHandler()

def Aria_setJoyHandler(joyHandler):
    """Aria_setJoyHandler(ArJoyHandler joyHandler)"""
    return _AriaPy.Aria_setJoyHandler(joyHandler)

def Aria_getJoyHandler():
    """Aria_getJoyHandler() -> ArJoyHandler"""
    return _AriaPy.Aria_getJoyHandler()

def Aria_addExitCallback(functor, position=50):
    """
    addExitCallback(ArFunctor functor, int position=50)
    Aria_addExitCallback(ArFunctor functor)
    """
    return _AriaPy.Aria_addExitCallback(functor, position)

def Aria_remExitCallback(functor):
    """Aria_remExitCallback(ArFunctor functor)"""
    return _AriaPy.Aria_remExitCallback(functor)

def Aria_setExitCallbacksLogLevel(level):
    """Aria_setExitCallbacksLogLevel(ArLog::LogLevel level)"""
    return _AriaPy.Aria_setExitCallbacksLogLevel(level)

def Aria_exitOld(exitCode=0):
    """
    exitOld(int exitCode=0)
    Aria_exitOld()
    """
    return _AriaPy.Aria_exitOld(exitCode)

def Aria_signalHandlerCB(sig):
    """Aria_signalHandlerCB(int sig)"""
    return _AriaPy.Aria_signalHandlerCB(sig)

def Aria_callExitCallbacks():
    """Aria_callExitCallbacks()"""
    return _AriaPy.Aria_callExitCallbacks()

def Aria_addParseArgsCB(functor, position=50):
    """
    addParseArgsCB(ArRetFunctor_Bool functor, int position=50)
    Aria_addParseArgsCB(ArRetFunctor_Bool functor)
    """
    return _AriaPy.Aria_addParseArgsCB(functor, position)

def Aria_setParseArgLogLevel(level):
    """Aria_setParseArgLogLevel(ArLog::LogLevel level)"""
    return _AriaPy.Aria_setParseArgLogLevel(level)

def Aria_addLogOptionsCB(functor, position=50):
    """
    addLogOptionsCB(ArFunctor functor, int position=50)
    Aria_addLogOptionsCB(ArFunctor functor)
    """
    return _AriaPy.Aria_addLogOptionsCB(functor, position)

def Aria_deviceConnectionAddCreator(deviceConnectionType, creator):
    """Aria_deviceConnectionAddCreator(char const * deviceConnectionType, ArRetFunctor3< ArDeviceConnection *,char const *,char const *,char const * > * creator) -> bool"""
    return _AriaPy.Aria_deviceConnectionAddCreator(deviceConnectionType, creator)

def Aria_deviceConnectionGetTypes():
    """Aria_deviceConnectionGetTypes() -> char const *"""
    return _AriaPy.Aria_deviceConnectionGetTypes()

def Aria_deviceConnectionGetChoices():
    """Aria_deviceConnectionGetChoices() -> char const *"""
    return _AriaPy.Aria_deviceConnectionGetChoices()

def Aria_deviceConnectionCreate(*args):
    """
    deviceConnectionCreate(char const * deviceConnectionType, char const * port, char const * defaultInfo, char const * prefix) -> ArDeviceConnection
    Aria_deviceConnectionCreate(char const * deviceConnectionType, char const * port, char const * defaultInfo) -> ArDeviceConnection
    """
    return _AriaPy.Aria_deviceConnectionCreate(*args)

def Aria_setRobotJoyHandler(robotJoyHandler):
    """Aria_setRobotJoyHandler(ArRobotJoyHandler robotJoyHandler)"""
    return _AriaPy.Aria_setRobotJoyHandler(robotJoyHandler)

def Aria_getRobotJoyHandler():
    """Aria_getRobotJoyHandler() -> ArRobotJoyHandler"""
    return _AriaPy.Aria_getRobotJoyHandler()

def Aria_getConfig():
    """Aria_getConfig() -> ArConfig"""
    return _AriaPy.Aria_getConfig()

def Aria_getInfoGroup():
    """Aria_getInfoGroup() -> ArStringInfoGroup"""
    return _AriaPy.Aria_getInfoGroup()

def Aria_addRobot(robot):
    """Aria_addRobot(ArRobot robot)"""
    return _AriaPy.Aria_addRobot(robot)

def Aria_delRobot(robot):
    """Aria_delRobot(ArRobot robot)"""
    return _AriaPy.Aria_delRobot(robot)

def Aria_findRobot(name):
    """Aria_findRobot(char * name) -> ArRobot"""
    return _AriaPy.Aria_findRobot(name)

def Aria_getRobotList():
    """Aria_getRobotList() -> std::list< ArRobot *,std::allocator< ArRobot * > > *"""
    return _AriaPy.Aria_getRobotList()

def Aria_getMaxNumLasers():
    """Aria_getMaxNumLasers() -> int"""
    return _AriaPy.Aria_getMaxNumLasers()

def Aria_setMaxNumLasers(maxNumLasers):
    """Aria_setMaxNumLasers(int maxNumLasers)"""
    return _AriaPy.Aria_setMaxNumLasers(maxNumLasers)

def Aria_getMaxNumSonarBoards():
    """Aria_getMaxNumSonarBoards() -> int"""
    return _AriaPy.Aria_getMaxNumSonarBoards()

def Aria_setMaxNumSonarBoards(maxNumSonarBoards):
    """Aria_setMaxNumSonarBoards(int maxNumSonarBoards)"""
    return _AriaPy.Aria_setMaxNumSonarBoards(maxNumSonarBoards)

def Aria_getMaxNumBatteries():
    """Aria_getMaxNumBatteries() -> int"""
    return _AriaPy.Aria_getMaxNumBatteries()

def Aria_setMaxNumBatteries(maxNumBatteries):
    """Aria_setMaxNumBatteries(int maxNumBatteries)"""
    return _AriaPy.Aria_setMaxNumBatteries(maxNumBatteries)

def Aria_getMaxNumLCDs():
    """Aria_getMaxNumLCDs() -> int"""
    return _AriaPy.Aria_getMaxNumLCDs()

def Aria_setMaxNumLCDs(maxNumLCDs):
    """Aria_setMaxNumLCDs(int maxNumLCDs)"""
    return _AriaPy.Aria_setMaxNumLCDs(maxNumLCDs)

def Aria_laserCreate(*args):
    """
    laserCreate(char const * laserType, int laserNumber, char const * prefix) -> ArLaser
    Aria_laserCreate(char const * laserType, int laserNumber) -> ArLaser
    """
    return _AriaPy.Aria_laserCreate(*args)

def Aria_laserAddCreator(laserType, creator):
    """Aria_laserAddCreator(char const * laserType, ArRetFunctor2< ArLaser *,int,char const * > * creator) -> bool"""
    return _AriaPy.Aria_laserAddCreator(laserType, creator)

def Aria_laserGetTypes():
    """Aria_laserGetTypes() -> char const *"""
    return _AriaPy.Aria_laserGetTypes()

def Aria_laserGetChoices():
    """Aria_laserGetChoices() -> char const *"""
    return _AriaPy.Aria_laserGetChoices()

def Aria_batteryCreate(*args):
    """
    batteryCreate(char const * batteryType, int batteryNumber, char const * prefix) -> ArBatteryMTX
    Aria_batteryCreate(char const * batteryType, int batteryNumber) -> ArBatteryMTX *
    """
    return _AriaPy.Aria_batteryCreate(*args)

def Aria_batteryAddCreator(batteryType, creator):
    """Aria_batteryAddCreator(char const * batteryType, ArRetFunctor2< ArBatteryMTX *,int,char const * > * creator) -> bool"""
    return _AriaPy.Aria_batteryAddCreator(batteryType, creator)

def Aria_batteryGetTypes():
    """Aria_batteryGetTypes() -> char const *"""
    return _AriaPy.Aria_batteryGetTypes()

def Aria_batteryGetChoices():
    """Aria_batteryGetChoices() -> char const *"""
    return _AriaPy.Aria_batteryGetChoices()

def Aria_lcdCreate(*args):
    """
    lcdCreate(char const * lcdType, int lcdNumber, char const * prefix) -> ArLCDMTX
    Aria_lcdCreate(char const * lcdType, int lcdNumber) -> ArLCDMTX *
    """
    return _AriaPy.Aria_lcdCreate(*args)

def Aria_lcdAddCreator(lcdType, creator):
    """Aria_lcdAddCreator(char const * lcdType, ArRetFunctor2< ArLCDMTX *,int,char const * > * creator) -> bool"""
    return _AriaPy.Aria_lcdAddCreator(lcdType, creator)

def Aria_lcdGetTypes():
    """Aria_lcdGetTypes() -> char const *"""
    return _AriaPy.Aria_lcdGetTypes()

def Aria_lcdGetChoices():
    """Aria_lcdGetChoices() -> char const *"""
    return _AriaPy.Aria_lcdGetChoices()

def Aria_sonarCreate(*args):
    """
    sonarCreate(char const * sonarType, int sonarNumber, char const * prefix) -> ArSonarMTX
    Aria_sonarCreate(char const * sonarType, int sonarNumber) -> ArSonarMTX *
    """
    return _AriaPy.Aria_sonarCreate(*args)

def Aria_sonarAddCreator(sonarType, creator):
    """Aria_sonarAddCreator(char const * sonarType, ArRetFunctor2< ArSonarMTX *,int,char const * > * creator) -> bool"""
    return _AriaPy.Aria_sonarAddCreator(sonarType, creator)

def Aria_sonarGetTypes():
    """Aria_sonarGetTypes() -> char const *"""
    return _AriaPy.Aria_sonarGetTypes()

def Aria_sonarGetChoices():
    """Aria_sonarGetChoices() -> char const *"""
    return _AriaPy.Aria_sonarGetChoices()

def Aria_setMaxNumVideoDevices(n):
    """Aria_setMaxNumVideoDevices(size_t n)"""
    return _AriaPy.Aria_setMaxNumVideoDevices(n)

def Aria_getMaxNumVideoDevices():
    """Aria_getMaxNumVideoDevices() -> size_t"""
    return _AriaPy.Aria_getMaxNumVideoDevices()

def Aria_setMaxNumPTZs(n):
    """Aria_setMaxNumPTZs(size_t n)"""
    return _AriaPy.Aria_setMaxNumPTZs(n)

def Aria_getMaxNumPTZs():
    """Aria_getMaxNumPTZs() -> size_t"""
    return _AriaPy.Aria_getMaxNumPTZs()

def Aria_getIdentifier():
    """Aria_getIdentifier() -> char const *"""
    return _AriaPy.Aria_getIdentifier()

def Aria_setIdentifier(identifier):
    """Aria_setIdentifier(char const * identifier)"""
    return _AriaPy.Aria_setIdentifier(identifier)

class ArPyFunctor(ArFunctor):
    """Proxy of C++ ArPyFunctor 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, _m):
        """__init__(ArPyFunctor self, PyObject * _m) -> ArPyFunctor"""
        this = _AriaPy.new_ArPyFunctor(_m)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def invoke(self):
        """invoke(ArPyFunctor self)"""
        return _AriaPy.ArPyFunctor_invoke(self)

    __swig_destroy__ = _AriaPy.delete_ArPyFunctor
    __del__ = lambda self: None

    def getName(self):
        """getName(ArPyFunctor self) -> char const *"""
        return _AriaPy.ArPyFunctor_getName(self)

ArPyFunctor_swigregister = _AriaPy.ArPyFunctor_swigregister
ArPyFunctor_swigregister(ArPyFunctor)

class ArPyRetFunctor_Bool(ArRetFunctor_Bool, ArPyFunctor):
    """Proxy of C++ ArPyRetFunctor_Bool 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, _m):
        """__init__(ArPyRetFunctor_Bool self, PyObject * _m) -> ArPyRetFunctor_Bool"""
        this = _AriaPy.new_ArPyRetFunctor_Bool(_m)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def invokeR(self):
        """invokeR(ArPyRetFunctor_Bool self) -> bool"""
        return _AriaPy.ArPyRetFunctor_Bool_invokeR(self)


    def getName(self):
        """getName(ArPyRetFunctor_Bool self) -> char const *"""
        return _AriaPy.ArPyRetFunctor_Bool_getName(self)

    __swig_destroy__ = _AriaPy.delete_ArPyRetFunctor_Bool
    __del__ = lambda self: None
ArPyRetFunctor_Bool_swigregister = _AriaPy.ArPyRetFunctor_Bool_swigregister
ArPyRetFunctor_Bool_swigregister(ArPyRetFunctor_Bool)

class ArConfigArg_Bool(ArConfigArg):
    """Proxy of C++ ArConfigArg_Bool 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__(ArConfigArg_Bool self, char const * name, bool b, char const * desc) -> ArConfigArg_Bool
        __init__(ArConfigArg_Bool self, char const * name, bool b) -> ArConfigArg_Bool
        """
        this = _AriaPy.new_ArConfigArg_Bool(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArConfigArg_Bool
    __del__ = lambda self: None
ArConfigArg_Bool_swigregister = _AriaPy.ArConfigArg_Bool_swigregister
ArConfigArg_Bool_swigregister(ArConfigArg_Bool)

class ArConfigArg_Int(ArConfigArg):
    """Proxy of C++ ArConfigArg_Int 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__(ArConfigArg_Int self, char const * name, int i, char const * desc, int min, int max) -> ArConfigArg_Int
        __init__(ArConfigArg_Int self, char const * name, int i, char const * desc, int min) -> ArConfigArg_Int
        __init__(ArConfigArg_Int self, char const * name, int i, char const * desc) -> ArConfigArg_Int
        __init__(ArConfigArg_Int self, char const * name, int i) -> ArConfigArg_Int
        """
        this = _AriaPy.new_ArConfigArg_Int(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArConfigArg_Int
    __del__ = lambda self: None
ArConfigArg_Int_swigregister = _AriaPy.ArConfigArg_Int_swigregister
ArConfigArg_Int_swigregister(ArConfigArg_Int)

class ArConfigArg_Double(ArConfigArg):
    """Proxy of C++ ArConfigArg_Double 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__(ArConfigArg_Double self, char const * name, double d, char const * desc, double min, double max) -> ArConfigArg_Double
        __init__(ArConfigArg_Double self, char const * name, double d, char const * desc, double min) -> ArConfigArg_Double
        __init__(ArConfigArg_Double self, char const * name, double d, char const * desc) -> ArConfigArg_Double
        __init__(ArConfigArg_Double self, char const * name, double d) -> ArConfigArg_Double
        """
        this = _AriaPy.new_ArConfigArg_Double(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArConfigArg_Double
    __del__ = lambda self: None
ArConfigArg_Double_swigregister = _AriaPy.ArConfigArg_Double_swigregister
ArConfigArg_Double_swigregister(ArConfigArg_Double)

class ArConfigArg_String(ArConfigArg):
    """Proxy of C++ ArConfigArg_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 __init__(self, name, str, desc):
        """__init__(ArConfigArg_String self, char const * name, char * str, char const * desc) -> ArConfigArg_String"""
        this = _AriaPy.new_ArConfigArg_String(name, str, desc)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _AriaPy.delete_ArConfigArg_String
    __del__ = lambda self: None
ArConfigArg_String_swigregister = _AriaPy.ArConfigArg_String_swigregister
ArConfigArg_String_swigregister(ArConfigArg_String)