"""
MobileRobots Advanced Robotics Navigation and Localization (ARNL)
Version 1.7.1

Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007, 2008, 2009 MobileRobots Inc.

All Rights Reserved.

MobileRobots Inc does not make any representations about the
suitability of this software for any purpose.  It is provided "as is"
without express or implied warranty.

The license for this software is distributed as LICENSE.txt in the top
level directory.

robots@mobilerobots.com
MobileRobots
10 Columbia Drive
Amherst, NH 03031
800-639-9481

"""
# This file was created automatically by SWIG 1.3.29.
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.

"""
Python wrapper library for Aria
"""

import _AriaPy
import new
new_instancemethod = new.instancemethod
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__ == 'PySwigObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

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

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

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


class PySwigIterator:
    """Proxy of C++ PySwigIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PySwigIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PySwigIterator, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_PySwigIterator
    __del__ = lambda self : None;
    def value(*args):
        """value(self) -> PyObject"""
        return apply(_AriaPy.PySwigIterator_value, args)

    def incr(*args):
        """
        incr(self, size_t n=1) -> PySwigIterator
        incr(self) -> PySwigIterator
        """
        return apply(_AriaPy.PySwigIterator_incr, args)

    def decr(*args):
        """
        decr(self, size_t n=1) -> PySwigIterator
        decr(self) -> PySwigIterator
        """
        return apply(_AriaPy.PySwigIterator_decr, args)

    def distance(*args):
        """distance(self, PySwigIterator x) -> ptrdiff_t"""
        return apply(_AriaPy.PySwigIterator_distance, args)

    def equal(*args):
        """equal(self, PySwigIterator x) -> bool"""
        return apply(_AriaPy.PySwigIterator_equal, args)

    def copy(*args):
        """copy(self) -> PySwigIterator"""
        return apply(_AriaPy.PySwigIterator_copy, args)

    def next(*args):
        """next(self) -> PyObject"""
        return apply(_AriaPy.PySwigIterator_next, args)

    def previous(*args):
        """previous(self) -> PyObject"""
        return apply(_AriaPy.PySwigIterator_previous, args)

    def advance(*args):
        """advance(self, ptrdiff_t n) -> PySwigIterator"""
        return apply(_AriaPy.PySwigIterator_advance, args)

    def __eq__(*args):
        """__eq__(self, PySwigIterator x) -> bool"""
        return apply(_AriaPy.PySwigIterator___eq__, args)

    def __ne__(*args):
        """__ne__(self, PySwigIterator x) -> bool"""
        return apply(_AriaPy.PySwigIterator___ne__, args)

    def __iadd__(*args):
        """__iadd__(self, ptrdiff_t n) -> PySwigIterator"""
        return apply(_AriaPy.PySwigIterator___iadd__, args)

    def __isub__(*args):
        """__isub__(self, ptrdiff_t n) -> PySwigIterator"""
        return apply(_AriaPy.PySwigIterator___isub__, args)

    def __add__(*args):
        """__add__(self, ptrdiff_t n) -> PySwigIterator"""
        return apply(_AriaPy.PySwigIterator___add__, args)

    def __sub__(*args):
        """
        __sub__(self, ptrdiff_t n) -> PySwigIterator
        __sub__(self, PySwigIterator x) -> ptrdiff_t
        """
        return apply(_AriaPy.PySwigIterator___sub__, args)

    def __iter__(self): return self
PySwigIterator_swigregister = _AriaPy.PySwigIterator_swigregister
PySwigIterator_swigregister(PySwigIterator)

class ArPoseWithTimeVector:
    """Proxy of C++ ArPoseWithTimeVector class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPoseWithTimeVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArPoseWithTimeVector, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.ArPoseWithTimeVector_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.ArPoseWithTimeVector___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.ArPoseWithTimeVector___len__, args)

    def pop(*args):
        """pop(self) -> value_type"""
        return apply(_AriaPy.ArPoseWithTimeVector_pop, args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> ArPoseWithTimeVector"""
        return apply(_AriaPy.ArPoseWithTimeVector___getslice__, args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, ArPoseWithTimeVector v)"""
        return apply(_AriaPy.ArPoseWithTimeVector___setslice__, args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return apply(_AriaPy.ArPoseWithTimeVector___delslice__, args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return apply(_AriaPy.ArPoseWithTimeVector___delitem__, args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return apply(_AriaPy.ArPoseWithTimeVector___getitem__, args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimeVector___setitem__, args)

    def append(*args):
        """append(self, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimeVector_append, args)

    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.ArPoseWithTimeVector_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.ArPoseWithTimeVector_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArPoseWithTimeVector_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.ArPoseWithTimeVector_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.ArPoseWithTimeVector_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.ArPoseWithTimeVector_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArPoseWithTimeVector_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArPoseWithTimeVector_rend, args)

    def pop_back(*args):
        """pop_back(self)"""
        return apply(_AriaPy.ArPoseWithTimeVector_pop_back, args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return apply(_AriaPy.ArPoseWithTimeVector_erase, args)

    def __init__(self, *args): 
        """
        __init__(self) -> ArPoseWithTimeVector
        __init__(self, ArPoseWithTimeVector ?) -> ArPoseWithTimeVector
        __init__(self, size_type size) -> ArPoseWithTimeVector
        __init__(self, size_type size, value_type value) -> ArPoseWithTimeVector
        """
        this = apply(_AriaPy.new_ArPoseWithTimeVector, args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimeVector_push_back, args)

    def front(*args):
        """front(self) -> value_type"""
        return apply(_AriaPy.ArPoseWithTimeVector_front, args)

    def back(*args):
        """back(self) -> value_type"""
        return apply(_AriaPy.ArPoseWithTimeVector_back, args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimeVector_assign, args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return apply(_AriaPy.ArPoseWithTimeVector_resize, args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return apply(_AriaPy.ArPoseWithTimeVector_insert, args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return apply(_AriaPy.ArPoseWithTimeVector_reserve, args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return apply(_AriaPy.ArPoseWithTimeVector_capacity, args)

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

class ArSensorReadingVector:
    """Proxy of C++ ArSensorReadingVector class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSensorReadingVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArSensorReadingVector, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.ArSensorReadingVector_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.ArSensorReadingVector___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.ArSensorReadingVector___len__, args)

    def pop(*args):
        """pop(self) -> value_type"""
        return apply(_AriaPy.ArSensorReadingVector_pop, args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> ArSensorReadingVector"""
        return apply(_AriaPy.ArSensorReadingVector___getslice__, args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, ArSensorReadingVector v)"""
        return apply(_AriaPy.ArSensorReadingVector___setslice__, args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return apply(_AriaPy.ArSensorReadingVector___delslice__, args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return apply(_AriaPy.ArSensorReadingVector___delitem__, args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return apply(_AriaPy.ArSensorReadingVector___getitem__, args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return apply(_AriaPy.ArSensorReadingVector___setitem__, args)

    def append(*args):
        """append(self, value_type x)"""
        return apply(_AriaPy.ArSensorReadingVector_append, args)

    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.ArSensorReadingVector_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.ArSensorReadingVector_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArSensorReadingVector_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.ArSensorReadingVector_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.ArSensorReadingVector_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.ArSensorReadingVector_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArSensorReadingVector_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArSensorReadingVector_rend, args)

    def pop_back(*args):
        """pop_back(self)"""
        return apply(_AriaPy.ArSensorReadingVector_pop_back, args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return apply(_AriaPy.ArSensorReadingVector_erase, args)

    def __init__(self, *args): 
        """
        __init__(self) -> ArSensorReadingVector
        __init__(self, ArSensorReadingVector ?) -> ArSensorReadingVector
        __init__(self, size_type size) -> ArSensorReadingVector
        __init__(self, size_type size, value_type value) -> ArSensorReadingVector
        """
        this = apply(_AriaPy.new_ArSensorReadingVector, args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return apply(_AriaPy.ArSensorReadingVector_push_back, args)

    def front(*args):
        """front(self) -> value_type"""
        return apply(_AriaPy.ArSensorReadingVector_front, args)

    def back(*args):
        """back(self) -> value_type"""
        return apply(_AriaPy.ArSensorReadingVector_back, args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return apply(_AriaPy.ArSensorReadingVector_assign, args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return apply(_AriaPy.ArSensorReadingVector_resize, args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return apply(_AriaPy.ArSensorReadingVector_insert, args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return apply(_AriaPy.ArSensorReadingVector_reserve, args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return apply(_AriaPy.ArSensorReadingVector_capacity, args)

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

class DoubleVector:
    """Proxy of C++ DoubleVector class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.DoubleVector_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.DoubleVector___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.DoubleVector___len__, args)

    def pop(*args):
        """pop(self) -> value_type"""
        return apply(_AriaPy.DoubleVector_pop, args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> DoubleVector"""
        return apply(_AriaPy.DoubleVector___getslice__, args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, DoubleVector v)"""
        return apply(_AriaPy.DoubleVector___setslice__, args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return apply(_AriaPy.DoubleVector___delslice__, args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return apply(_AriaPy.DoubleVector___delitem__, args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return apply(_AriaPy.DoubleVector___getitem__, args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return apply(_AriaPy.DoubleVector___setitem__, args)

    def append(*args):
        """append(self, value_type x)"""
        return apply(_AriaPy.DoubleVector_append, args)

    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.DoubleVector_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.DoubleVector_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.DoubleVector_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.DoubleVector_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.DoubleVector_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.DoubleVector_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.DoubleVector_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.DoubleVector_rend, args)

    def pop_back(*args):
        """pop_back(self)"""
        return apply(_AriaPy.DoubleVector_pop_back, args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return apply(_AriaPy.DoubleVector_erase, args)

    def __init__(self, *args): 
        """
        __init__(self) -> DoubleVector
        __init__(self, DoubleVector ?) -> DoubleVector
        __init__(self, size_type size) -> DoubleVector
        __init__(self, size_type size, value_type value) -> DoubleVector
        """
        this = apply(_AriaPy.new_DoubleVector, args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return apply(_AriaPy.DoubleVector_push_back, args)

    def front(*args):
        """front(self) -> value_type"""
        return apply(_AriaPy.DoubleVector_front, args)

    def back(*args):
        """back(self) -> value_type"""
        return apply(_AriaPy.DoubleVector_back, args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return apply(_AriaPy.DoubleVector_assign, args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return apply(_AriaPy.DoubleVector_resize, args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return apply(_AriaPy.DoubleVector_insert, args)

    def reserve(*args):
        """reserve(self, size_type n)"""
        return apply(_AriaPy.DoubleVector_reserve, args)

    def capacity(*args):
        """capacity(self) -> size_type"""
        return apply(_AriaPy.DoubleVector_capacity, args)

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

class ArMapObjectPtrList:
    """Proxy of C++ ArMapObjectPtrList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMapObjectPtrList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArMapObjectPtrList, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.ArMapObjectPtrList_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.ArMapObjectPtrList___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.ArMapObjectPtrList___len__, args)

    def pop(*args):
        """pop(self) -> value_type"""
        return apply(_AriaPy.ArMapObjectPtrList_pop, args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> ArMapObjectPtrList"""
        return apply(_AriaPy.ArMapObjectPtrList___getslice__, args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, ArMapObjectPtrList v)"""
        return apply(_AriaPy.ArMapObjectPtrList___setslice__, args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return apply(_AriaPy.ArMapObjectPtrList___delslice__, args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return apply(_AriaPy.ArMapObjectPtrList___delitem__, args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return apply(_AriaPy.ArMapObjectPtrList___getitem__, args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return apply(_AriaPy.ArMapObjectPtrList___setitem__, args)

    def append(*args):
        """append(self, value_type x)"""
        return apply(_AriaPy.ArMapObjectPtrList_append, args)

    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.ArMapObjectPtrList_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.ArMapObjectPtrList_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArMapObjectPtrList_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.ArMapObjectPtrList_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.ArMapObjectPtrList_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.ArMapObjectPtrList_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArMapObjectPtrList_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArMapObjectPtrList_rend, args)

    def pop_back(*args):
        """pop_back(self)"""
        return apply(_AriaPy.ArMapObjectPtrList_pop_back, args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return apply(_AriaPy.ArMapObjectPtrList_erase, args)

    def __init__(self, *args): 
        """
        __init__(self) -> ArMapObjectPtrList
        __init__(self, ArMapObjectPtrList ?) -> ArMapObjectPtrList
        __init__(self, size_type size) -> ArMapObjectPtrList
        __init__(self, size_type size, value_type value) -> ArMapObjectPtrList
        """
        this = apply(_AriaPy.new_ArMapObjectPtrList, args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return apply(_AriaPy.ArMapObjectPtrList_push_back, args)

    def front(*args):
        """front(self) -> value_type"""
        return apply(_AriaPy.ArMapObjectPtrList_front, args)

    def back(*args):
        """back(self) -> value_type"""
        return apply(_AriaPy.ArMapObjectPtrList_back, args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return apply(_AriaPy.ArMapObjectPtrList_assign, args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return apply(_AriaPy.ArMapObjectPtrList_resize, args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return apply(_AriaPy.ArMapObjectPtrList_insert, args)

    def pop_front(*args):
        """pop_front(self)"""
        return apply(_AriaPy.ArMapObjectPtrList_pop_front, args)

    def push_front(*args):
        """push_front(self, value_type x)"""
        return apply(_AriaPy.ArMapObjectPtrList_push_front, args)

    def remove(*args):
        """remove(self, value_type x)"""
        return apply(_AriaPy.ArMapObjectPtrList_remove, args)

    def unique(*args):
        """unique(self)"""
        return apply(_AriaPy.ArMapObjectPtrList_unique, args)

    def reverse(*args):
        """reverse(self)"""
        return apply(_AriaPy.ArMapObjectPtrList_reverse, args)

    def sort(*args):
        """sort(self)"""
        return apply(_AriaPy.ArMapObjectPtrList_sort, args)

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

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

class ArFunctorPtrList:
    """Proxy of C++ ArFunctorPtrList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArFunctorPtrList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArFunctorPtrList, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.ArFunctorPtrList_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.ArFunctorPtrList___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.ArFunctorPtrList___len__, args)

    def pop(*args):
        """pop(self) -> value_type"""
        return apply(_AriaPy.ArFunctorPtrList_pop, args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> ArFunctorPtrList"""
        return apply(_AriaPy.ArFunctorPtrList___getslice__, args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, ArFunctorPtrList v)"""
        return apply(_AriaPy.ArFunctorPtrList___setslice__, args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return apply(_AriaPy.ArFunctorPtrList___delslice__, args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return apply(_AriaPy.ArFunctorPtrList___delitem__, args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return apply(_AriaPy.ArFunctorPtrList___getitem__, args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return apply(_AriaPy.ArFunctorPtrList___setitem__, args)

    def append(*args):
        """append(self, value_type x)"""
        return apply(_AriaPy.ArFunctorPtrList_append, args)

    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.ArFunctorPtrList_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.ArFunctorPtrList_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArFunctorPtrList_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.ArFunctorPtrList_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.ArFunctorPtrList_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.ArFunctorPtrList_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArFunctorPtrList_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArFunctorPtrList_rend, args)

    def pop_back(*args):
        """pop_back(self)"""
        return apply(_AriaPy.ArFunctorPtrList_pop_back, args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return apply(_AriaPy.ArFunctorPtrList_erase, args)

    def __init__(self, *args): 
        """
        __init__(self) -> ArFunctorPtrList
        __init__(self, ArFunctorPtrList ?) -> ArFunctorPtrList
        __init__(self, size_type size) -> ArFunctorPtrList
        __init__(self, size_type size, value_type value) -> ArFunctorPtrList
        """
        this = apply(_AriaPy.new_ArFunctorPtrList, args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return apply(_AriaPy.ArFunctorPtrList_push_back, args)

    def front(*args):
        """front(self) -> value_type"""
        return apply(_AriaPy.ArFunctorPtrList_front, args)

    def back(*args):
        """back(self) -> value_type"""
        return apply(_AriaPy.ArFunctorPtrList_back, args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return apply(_AriaPy.ArFunctorPtrList_assign, args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return apply(_AriaPy.ArFunctorPtrList_resize, args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return apply(_AriaPy.ArFunctorPtrList_insert, args)

    def pop_front(*args):
        """pop_front(self)"""
        return apply(_AriaPy.ArFunctorPtrList_pop_front, args)

    def push_front(*args):
        """push_front(self, value_type x)"""
        return apply(_AriaPy.ArFunctorPtrList_push_front, args)

    def remove(*args):
        """remove(self, value_type x)"""
        return apply(_AriaPy.ArFunctorPtrList_remove, args)

    def unique(*args):
        """unique(self)"""
        return apply(_AriaPy.ArFunctorPtrList_unique, args)

    def reverse(*args):
        """reverse(self)"""
        return apply(_AriaPy.ArFunctorPtrList_reverse, args)

    def sort(*args):
        """sort(self)"""
        return apply(_AriaPy.ArFunctorPtrList_sort, args)

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

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

class ArPoseList:
    """Proxy of C++ ArPoseList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPoseList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArPoseList, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.ArPoseList_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.ArPoseList___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.ArPoseList___len__, args)

    def pop(*args):
        """pop(self) -> value_type"""
        return apply(_AriaPy.ArPoseList_pop, args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> ArPoseList"""
        return apply(_AriaPy.ArPoseList___getslice__, args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, ArPoseList v)"""
        return apply(_AriaPy.ArPoseList___setslice__, args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return apply(_AriaPy.ArPoseList___delslice__, args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return apply(_AriaPy.ArPoseList___delitem__, args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return apply(_AriaPy.ArPoseList___getitem__, args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return apply(_AriaPy.ArPoseList___setitem__, args)

    def append(*args):
        """append(self, value_type x)"""
        return apply(_AriaPy.ArPoseList_append, args)

    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.ArPoseList_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.ArPoseList_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArPoseList_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.ArPoseList_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.ArPoseList_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.ArPoseList_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArPoseList_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArPoseList_rend, args)

    def pop_back(*args):
        """pop_back(self)"""
        return apply(_AriaPy.ArPoseList_pop_back, args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return apply(_AriaPy.ArPoseList_erase, args)

    def __init__(self, *args): 
        """
        __init__(self) -> ArPoseList
        __init__(self, ArPoseList ?) -> ArPoseList
        __init__(self, size_type size) -> ArPoseList
        __init__(self, size_type size, value_type value) -> ArPoseList
        """
        this = apply(_AriaPy.new_ArPoseList, args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return apply(_AriaPy.ArPoseList_push_back, args)

    def front(*args):
        """front(self) -> value_type"""
        return apply(_AriaPy.ArPoseList_front, args)

    def back(*args):
        """back(self) -> value_type"""
        return apply(_AriaPy.ArPoseList_back, args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return apply(_AriaPy.ArPoseList_assign, args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return apply(_AriaPy.ArPoseList_resize, args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return apply(_AriaPy.ArPoseList_insert, args)

    def pop_front(*args):
        """pop_front(self)"""
        return apply(_AriaPy.ArPoseList_pop_front, args)

    def push_front(*args):
        """push_front(self, value_type x)"""
        return apply(_AriaPy.ArPoseList_push_front, args)

    def reverse(*args):
        """reverse(self)"""
        return apply(_AriaPy.ArPoseList_reverse, args)

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

class ArPosePtrList:
    """Proxy of C++ ArPosePtrList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPosePtrList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArPosePtrList, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.ArPosePtrList_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.ArPosePtrList___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.ArPosePtrList___len__, args)

    def pop(*args):
        """pop(self) -> value_type"""
        return apply(_AriaPy.ArPosePtrList_pop, args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> ArPosePtrList"""
        return apply(_AriaPy.ArPosePtrList___getslice__, args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, ArPosePtrList v)"""
        return apply(_AriaPy.ArPosePtrList___setslice__, args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return apply(_AriaPy.ArPosePtrList___delslice__, args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return apply(_AriaPy.ArPosePtrList___delitem__, args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return apply(_AriaPy.ArPosePtrList___getitem__, args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return apply(_AriaPy.ArPosePtrList___setitem__, args)

    def append(*args):
        """append(self, value_type x)"""
        return apply(_AriaPy.ArPosePtrList_append, args)

    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.ArPosePtrList_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.ArPosePtrList_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArPosePtrList_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.ArPosePtrList_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.ArPosePtrList_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.ArPosePtrList_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArPosePtrList_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArPosePtrList_rend, args)

    def pop_back(*args):
        """pop_back(self)"""
        return apply(_AriaPy.ArPosePtrList_pop_back, args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return apply(_AriaPy.ArPosePtrList_erase, args)

    def __init__(self, *args): 
        """
        __init__(self) -> ArPosePtrList
        __init__(self, ArPosePtrList ?) -> ArPosePtrList
        __init__(self, size_type size) -> ArPosePtrList
        __init__(self, size_type size, value_type value) -> ArPosePtrList
        """
        this = apply(_AriaPy.new_ArPosePtrList, args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return apply(_AriaPy.ArPosePtrList_push_back, args)

    def front(*args):
        """front(self) -> value_type"""
        return apply(_AriaPy.ArPosePtrList_front, args)

    def back(*args):
        """back(self) -> value_type"""
        return apply(_AriaPy.ArPosePtrList_back, args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return apply(_AriaPy.ArPosePtrList_assign, args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return apply(_AriaPy.ArPosePtrList_resize, args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return apply(_AriaPy.ArPosePtrList_insert, args)

    def pop_front(*args):
        """pop_front(self)"""
        return apply(_AriaPy.ArPosePtrList_pop_front, args)

    def push_front(*args):
        """push_front(self, value_type x)"""
        return apply(_AriaPy.ArPosePtrList_push_front, args)

    def remove(*args):
        """remove(self, value_type x)"""
        return apply(_AriaPy.ArPosePtrList_remove, args)

    def unique(*args):
        """unique(self)"""
        return apply(_AriaPy.ArPosePtrList_unique, args)

    def reverse(*args):
        """reverse(self)"""
        return apply(_AriaPy.ArPosePtrList_reverse, args)

    def sort(*args):
        """sort(self)"""
        return apply(_AriaPy.ArPosePtrList_sort, args)

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

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

class ArPoseWithTimeList:
    """Proxy of C++ ArPoseWithTimeList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPoseWithTimeList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArPoseWithTimeList, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.ArPoseWithTimeList_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.ArPoseWithTimeList___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.ArPoseWithTimeList___len__, args)

    def pop(*args):
        """pop(self) -> value_type"""
        return apply(_AriaPy.ArPoseWithTimeList_pop, args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> ArPoseWithTimeList"""
        return apply(_AriaPy.ArPoseWithTimeList___getslice__, args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, ArPoseWithTimeList v)"""
        return apply(_AriaPy.ArPoseWithTimeList___setslice__, args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return apply(_AriaPy.ArPoseWithTimeList___delslice__, args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return apply(_AriaPy.ArPoseWithTimeList___delitem__, args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return apply(_AriaPy.ArPoseWithTimeList___getitem__, args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimeList___setitem__, args)

    def append(*args):
        """append(self, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimeList_append, args)

    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.ArPoseWithTimeList_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.ArPoseWithTimeList_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArPoseWithTimeList_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.ArPoseWithTimeList_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.ArPoseWithTimeList_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.ArPoseWithTimeList_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArPoseWithTimeList_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArPoseWithTimeList_rend, args)

    def pop_back(*args):
        """pop_back(self)"""
        return apply(_AriaPy.ArPoseWithTimeList_pop_back, args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return apply(_AriaPy.ArPoseWithTimeList_erase, args)

    def __init__(self, *args): 
        """
        __init__(self) -> ArPoseWithTimeList
        __init__(self, ArPoseWithTimeList ?) -> ArPoseWithTimeList
        __init__(self, size_type size) -> ArPoseWithTimeList
        __init__(self, size_type size, value_type value) -> ArPoseWithTimeList
        """
        this = apply(_AriaPy.new_ArPoseWithTimeList, args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimeList_push_back, args)

    def front(*args):
        """front(self) -> value_type"""
        return apply(_AriaPy.ArPoseWithTimeList_front, args)

    def back(*args):
        """back(self) -> value_type"""
        return apply(_AriaPy.ArPoseWithTimeList_back, args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimeList_assign, args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return apply(_AriaPy.ArPoseWithTimeList_resize, args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return apply(_AriaPy.ArPoseWithTimeList_insert, args)

    def pop_front(*args):
        """pop_front(self)"""
        return apply(_AriaPy.ArPoseWithTimeList_pop_front, args)

    def push_front(*args):
        """push_front(self, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimeList_push_front, args)

    def reverse(*args):
        """reverse(self)"""
        return apply(_AriaPy.ArPoseWithTimeList_reverse, args)

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

class ArPoseWithTimePtrList:
    """Proxy of C++ ArPoseWithTimePtrList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPoseWithTimePtrList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArPoseWithTimePtrList, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.ArPoseWithTimePtrList_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.ArPoseWithTimePtrList___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.ArPoseWithTimePtrList___len__, args)

    def pop(*args):
        """pop(self) -> value_type"""
        return apply(_AriaPy.ArPoseWithTimePtrList_pop, args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> ArPoseWithTimePtrList"""
        return apply(_AriaPy.ArPoseWithTimePtrList___getslice__, args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, ArPoseWithTimePtrList v)"""
        return apply(_AriaPy.ArPoseWithTimePtrList___setslice__, args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return apply(_AriaPy.ArPoseWithTimePtrList___delslice__, args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return apply(_AriaPy.ArPoseWithTimePtrList___delitem__, args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return apply(_AriaPy.ArPoseWithTimePtrList___getitem__, args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimePtrList___setitem__, args)

    def append(*args):
        """append(self, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimePtrList_append, args)

    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.ArPoseWithTimePtrList_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.ArPoseWithTimePtrList_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArPoseWithTimePtrList_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.ArPoseWithTimePtrList_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.ArPoseWithTimePtrList_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.ArPoseWithTimePtrList_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArPoseWithTimePtrList_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArPoseWithTimePtrList_rend, args)

    def pop_back(*args):
        """pop_back(self)"""
        return apply(_AriaPy.ArPoseWithTimePtrList_pop_back, args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return apply(_AriaPy.ArPoseWithTimePtrList_erase, args)

    def __init__(self, *args): 
        """
        __init__(self) -> ArPoseWithTimePtrList
        __init__(self, ArPoseWithTimePtrList ?) -> ArPoseWithTimePtrList
        __init__(self, size_type size) -> ArPoseWithTimePtrList
        __init__(self, size_type size, value_type value) -> ArPoseWithTimePtrList
        """
        this = apply(_AriaPy.new_ArPoseWithTimePtrList, args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimePtrList_push_back, args)

    def front(*args):
        """front(self) -> value_type"""
        return apply(_AriaPy.ArPoseWithTimePtrList_front, args)

    def back(*args):
        """back(self) -> value_type"""
        return apply(_AriaPy.ArPoseWithTimePtrList_back, args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimePtrList_assign, args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return apply(_AriaPy.ArPoseWithTimePtrList_resize, args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return apply(_AriaPy.ArPoseWithTimePtrList_insert, args)

    def pop_front(*args):
        """pop_front(self)"""
        return apply(_AriaPy.ArPoseWithTimePtrList_pop_front, args)

    def push_front(*args):
        """push_front(self, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimePtrList_push_front, args)

    def remove(*args):
        """remove(self, value_type x)"""
        return apply(_AriaPy.ArPoseWithTimePtrList_remove, args)

    def unique(*args):
        """unique(self)"""
        return apply(_AriaPy.ArPoseWithTimePtrList_unique, args)

    def reverse(*args):
        """reverse(self)"""
        return apply(_AriaPy.ArPoseWithTimePtrList_reverse, args)

    def sort(*args):
        """sort(self)"""
        return apply(_AriaPy.ArPoseWithTimePtrList_sort, args)

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

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

class ArRangeDevicePtrList:
    """Proxy of C++ ArRangeDevicePtrList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRangeDevicePtrList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArRangeDevicePtrList, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.ArRangeDevicePtrList_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.ArRangeDevicePtrList___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.ArRangeDevicePtrList___len__, args)

    def pop(*args):
        """pop(self) -> value_type"""
        return apply(_AriaPy.ArRangeDevicePtrList_pop, args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> ArRangeDevicePtrList"""
        return apply(_AriaPy.ArRangeDevicePtrList___getslice__, args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, ArRangeDevicePtrList v)"""
        return apply(_AriaPy.ArRangeDevicePtrList___setslice__, args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return apply(_AriaPy.ArRangeDevicePtrList___delslice__, args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return apply(_AriaPy.ArRangeDevicePtrList___delitem__, args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return apply(_AriaPy.ArRangeDevicePtrList___getitem__, args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return apply(_AriaPy.ArRangeDevicePtrList___setitem__, args)

    def append(*args):
        """append(self, value_type x)"""
        return apply(_AriaPy.ArRangeDevicePtrList_append, args)

    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.ArRangeDevicePtrList_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.ArRangeDevicePtrList_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArRangeDevicePtrList_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.ArRangeDevicePtrList_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.ArRangeDevicePtrList_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.ArRangeDevicePtrList_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArRangeDevicePtrList_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArRangeDevicePtrList_rend, args)

    def pop_back(*args):
        """pop_back(self)"""
        return apply(_AriaPy.ArRangeDevicePtrList_pop_back, args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return apply(_AriaPy.ArRangeDevicePtrList_erase, args)

    def __init__(self, *args): 
        """
        __init__(self) -> ArRangeDevicePtrList
        __init__(self, ArRangeDevicePtrList ?) -> ArRangeDevicePtrList
        __init__(self, size_type size) -> ArRangeDevicePtrList
        __init__(self, size_type size, value_type value) -> ArRangeDevicePtrList
        """
        this = apply(_AriaPy.new_ArRangeDevicePtrList, args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return apply(_AriaPy.ArRangeDevicePtrList_push_back, args)

    def front(*args):
        """front(self) -> value_type"""
        return apply(_AriaPy.ArRangeDevicePtrList_front, args)

    def back(*args):
        """back(self) -> value_type"""
        return apply(_AriaPy.ArRangeDevicePtrList_back, args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return apply(_AriaPy.ArRangeDevicePtrList_assign, args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return apply(_AriaPy.ArRangeDevicePtrList_resize, args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return apply(_AriaPy.ArRangeDevicePtrList_insert, args)

    def pop_front(*args):
        """pop_front(self)"""
        return apply(_AriaPy.ArRangeDevicePtrList_pop_front, args)

    def push_front(*args):
        """push_front(self, value_type x)"""
        return apply(_AriaPy.ArRangeDevicePtrList_push_front, args)

    def remove(*args):
        """remove(self, value_type x)"""
        return apply(_AriaPy.ArRangeDevicePtrList_remove, args)

    def unique(*args):
        """unique(self)"""
        return apply(_AriaPy.ArRangeDevicePtrList_unique, args)

    def reverse(*args):
        """reverse(self)"""
        return apply(_AriaPy.ArRangeDevicePtrList_reverse, args)

    def sort(*args):
        """sort(self)"""
        return apply(_AriaPy.ArRangeDevicePtrList_sort, args)

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

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

class ArArgumentBuilderPtrList:
    """Proxy of C++ ArArgumentBuilderPtrList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArArgumentBuilderPtrList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArArgumentBuilderPtrList, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.ArArgumentBuilderPtrList___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.ArArgumentBuilderPtrList___len__, args)

    def pop(*args):
        """pop(self) -> value_type"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_pop, args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> ArArgumentBuilderPtrList"""
        return apply(_AriaPy.ArArgumentBuilderPtrList___getslice__, args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, ArArgumentBuilderPtrList v)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList___setslice__, args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList___delslice__, args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList___delitem__, args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return apply(_AriaPy.ArArgumentBuilderPtrList___getitem__, args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList___setitem__, args)

    def append(*args):
        """append(self, value_type x)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_append, args)

    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.ArArgumentBuilderPtrList_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.ArArgumentBuilderPtrList_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArArgumentBuilderPtrList_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArArgumentBuilderPtrList_rend, args)

    def pop_back(*args):
        """pop_back(self)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_pop_back, args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return apply(_AriaPy.ArArgumentBuilderPtrList_erase, args)

    def __init__(self, *args): 
        """
        __init__(self) -> ArArgumentBuilderPtrList
        __init__(self, ArArgumentBuilderPtrList ?) -> ArArgumentBuilderPtrList
        __init__(self, size_type size) -> ArArgumentBuilderPtrList
        __init__(self, size_type size, value_type value) -> ArArgumentBuilderPtrList
        """
        this = apply(_AriaPy.new_ArArgumentBuilderPtrList, args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_push_back, args)

    def front(*args):
        """front(self) -> value_type"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_front, args)

    def back(*args):
        """back(self) -> value_type"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_back, args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_assign, args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return apply(_AriaPy.ArArgumentBuilderPtrList_resize, args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return apply(_AriaPy.ArArgumentBuilderPtrList_insert, args)

    def pop_front(*args):
        """pop_front(self)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_pop_front, args)

    def push_front(*args):
        """push_front(self, value_type x)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_push_front, args)

    def remove(*args):
        """remove(self, value_type x)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_remove, args)

    def unique(*args):
        """unique(self)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_unique, args)

    def reverse(*args):
        """reverse(self)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_reverse, args)

    def sort(*args):
        """sort(self)"""
        return apply(_AriaPy.ArArgumentBuilderPtrList_sort, args)

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

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

class ArLineSegmentList:
    """Proxy of C++ ArLineSegmentList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLineSegmentList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArLineSegmentList, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.ArLineSegmentList_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.ArLineSegmentList___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.ArLineSegmentList___len__, args)

    def pop(*args):
        """pop(self) -> value_type"""
        return apply(_AriaPy.ArLineSegmentList_pop, args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> ArLineSegmentList"""
        return apply(_AriaPy.ArLineSegmentList___getslice__, args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, ArLineSegmentList v)"""
        return apply(_AriaPy.ArLineSegmentList___setslice__, args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return apply(_AriaPy.ArLineSegmentList___delslice__, args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return apply(_AriaPy.ArLineSegmentList___delitem__, args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return apply(_AriaPy.ArLineSegmentList___getitem__, args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return apply(_AriaPy.ArLineSegmentList___setitem__, args)

    def append(*args):
        """append(self, value_type x)"""
        return apply(_AriaPy.ArLineSegmentList_append, args)

    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.ArLineSegmentList_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.ArLineSegmentList_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArLineSegmentList_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.ArLineSegmentList_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.ArLineSegmentList_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.ArLineSegmentList_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArLineSegmentList_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArLineSegmentList_rend, args)

    def pop_back(*args):
        """pop_back(self)"""
        return apply(_AriaPy.ArLineSegmentList_pop_back, args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return apply(_AriaPy.ArLineSegmentList_erase, args)

    def __init__(self, *args): 
        """
        __init__(self) -> ArLineSegmentList
        __init__(self, ArLineSegmentList ?) -> ArLineSegmentList
        __init__(self, size_type size) -> ArLineSegmentList
        __init__(self, size_type size, value_type value) -> ArLineSegmentList
        """
        this = apply(_AriaPy.new_ArLineSegmentList, args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return apply(_AriaPy.ArLineSegmentList_push_back, args)

    def front(*args):
        """front(self) -> value_type"""
        return apply(_AriaPy.ArLineSegmentList_front, args)

    def back(*args):
        """back(self) -> value_type"""
        return apply(_AriaPy.ArLineSegmentList_back, args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return apply(_AriaPy.ArLineSegmentList_assign, args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return apply(_AriaPy.ArLineSegmentList_resize, args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return apply(_AriaPy.ArLineSegmentList_insert, args)

    def pop_front(*args):
        """pop_front(self)"""
        return apply(_AriaPy.ArLineSegmentList_pop_front, args)

    def push_front(*args):
        """push_front(self, value_type x)"""
        return apply(_AriaPy.ArLineSegmentList_push_front, args)

    def reverse(*args):
        """reverse(self)"""
        return apply(_AriaPy.ArLineSegmentList_reverse, args)

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

class ArLineSegmentPtrList:
    """Proxy of C++ ArLineSegmentPtrList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLineSegmentPtrList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArLineSegmentPtrList, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.ArLineSegmentPtrList_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.ArLineSegmentPtrList___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.ArLineSegmentPtrList___len__, args)

    def pop(*args):
        """pop(self) -> value_type"""
        return apply(_AriaPy.ArLineSegmentPtrList_pop, args)

    def __getslice__(*args):
        """__getslice__(self, difference_type i, difference_type j) -> ArLineSegmentPtrList"""
        return apply(_AriaPy.ArLineSegmentPtrList___getslice__, args)

    def __setslice__(*args):
        """__setslice__(self, difference_type i, difference_type j, ArLineSegmentPtrList v)"""
        return apply(_AriaPy.ArLineSegmentPtrList___setslice__, args)

    def __delslice__(*args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return apply(_AriaPy.ArLineSegmentPtrList___delslice__, args)

    def __delitem__(*args):
        """__delitem__(self, difference_type i)"""
        return apply(_AriaPy.ArLineSegmentPtrList___delitem__, args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return apply(_AriaPy.ArLineSegmentPtrList___getitem__, args)

    def __setitem__(*args):
        """__setitem__(self, difference_type i, value_type x)"""
        return apply(_AriaPy.ArLineSegmentPtrList___setitem__, args)

    def append(*args):
        """append(self, value_type x)"""
        return apply(_AriaPy.ArLineSegmentPtrList_append, args)

    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.ArLineSegmentPtrList_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.ArLineSegmentPtrList_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArLineSegmentPtrList_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.ArLineSegmentPtrList_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.ArLineSegmentPtrList_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.ArLineSegmentPtrList_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArLineSegmentPtrList_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.ArLineSegmentPtrList_rend, args)

    def pop_back(*args):
        """pop_back(self)"""
        return apply(_AriaPy.ArLineSegmentPtrList_pop_back, args)

    def erase(*args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return apply(_AriaPy.ArLineSegmentPtrList_erase, args)

    def __init__(self, *args): 
        """
        __init__(self) -> ArLineSegmentPtrList
        __init__(self, ArLineSegmentPtrList ?) -> ArLineSegmentPtrList
        __init__(self, size_type size) -> ArLineSegmentPtrList
        __init__(self, size_type size, value_type value) -> ArLineSegmentPtrList
        """
        this = apply(_AriaPy.new_ArLineSegmentPtrList, args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args):
        """push_back(self, value_type x)"""
        return apply(_AriaPy.ArLineSegmentPtrList_push_back, args)

    def front(*args):
        """front(self) -> value_type"""
        return apply(_AriaPy.ArLineSegmentPtrList_front, args)

    def back(*args):
        """back(self) -> value_type"""
        return apply(_AriaPy.ArLineSegmentPtrList_back, args)

    def assign(*args):
        """assign(self, size_type n, value_type x)"""
        return apply(_AriaPy.ArLineSegmentPtrList_assign, args)

    def resize(*args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return apply(_AriaPy.ArLineSegmentPtrList_resize, args)

    def insert(*args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return apply(_AriaPy.ArLineSegmentPtrList_insert, args)

    def pop_front(*args):
        """pop_front(self)"""
        return apply(_AriaPy.ArLineSegmentPtrList_pop_front, args)

    def push_front(*args):
        """push_front(self, value_type x)"""
        return apply(_AriaPy.ArLineSegmentPtrList_push_front, args)

    def remove(*args):
        """remove(self, value_type x)"""
        return apply(_AriaPy.ArLineSegmentPtrList_remove, args)

    def unique(*args):
        """unique(self)"""
        return apply(_AriaPy.ArLineSegmentPtrList_unique, args)

    def reverse(*args):
        """reverse(self)"""
        return apply(_AriaPy.ArLineSegmentPtrList_reverse, args)

    def sort(*args):
        """sort(self)"""
        return apply(_AriaPy.ArLineSegmentPtrList_sort, args)

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

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

class IntSet:
    """Proxy of C++ IntSet class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntSet, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.IntSet_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.IntSet___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.IntSet___len__, args)

    def append(*args):
        """append(self, value_type x)"""
        return apply(_AriaPy.IntSet_append, args)

    def __contains__(*args):
        """__contains__(self, value_type x) -> bool"""
        return apply(_AriaPy.IntSet___contains__, args)

    def __getitem__(*args):
        """__getitem__(self, difference_type i) -> value_type"""
        return apply(_AriaPy.IntSet___getitem__, args)

    def __init__(self, *args): 
        """
        __init__(self) -> IntSet
        __init__(self, IntSet ?) -> IntSet
        """
        this = apply(_AriaPy.new_IntSet, args)
        try: self.this.append(this)
        except: self.this = this
    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.IntSet_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.IntSet_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.IntSet_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.IntSet_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.IntSet_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.IntSet_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.IntSet_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.IntSet_rend, args)

    def count(*args):
        """count(self, key_type x) -> size_type"""
        return apply(_AriaPy.IntSet_count, args)

    def erase(*args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator pos)
        erase(self, iterator first, iterator last)
        """
        return apply(_AriaPy.IntSet_erase, args)

    def find(*args):
        """find(self, key_type x) -> iterator"""
        return apply(_AriaPy.IntSet_find, args)

    def lower_bound(*args):
        """lower_bound(self, key_type x) -> iterator"""
        return apply(_AriaPy.IntSet_lower_bound, args)

    def upper_bound(*args):
        """upper_bound(self, key_type x) -> iterator"""
        return apply(_AriaPy.IntSet_upper_bound, args)

    def equal_range(*args):
        """equal_range(self, key_type x) -> std::pair<(std::set<(int)>::iterator,std::set<(int)>::iterator)>"""
        return apply(_AriaPy.IntSet_equal_range, args)

    def insert(*args):
        """insert(self, value_type __x) -> std::pair<(std::set<(int)>::iterator,bool)>"""
        return apply(_AriaPy.IntSet_insert, args)

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

class IntArPoseMap:
    """Proxy of C++ IntArPoseMap class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntArPoseMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntArPoseMap, name)
    __repr__ = _swig_repr
    def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.IntArPoseMap_iterator, args)

    def __iter__(self): return self.iterator()
    def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return apply(_AriaPy.IntArPoseMap___nonzero__, args)

    def __len__(*args):
        """__len__(self) -> size_type"""
        return apply(_AriaPy.IntArPoseMap___len__, args)

    def __getitem__(*args):
        """__getitem__(self, key_type key) -> mapped_type"""
        return apply(_AriaPy.IntArPoseMap___getitem__, args)

    def __setitem__(*args):
        """__setitem__(self, key_type key, mapped_type x)"""
        return apply(_AriaPy.IntArPoseMap___setitem__, args)

    def __delitem__(*args):
        """__delitem__(self, key_type key)"""
        return apply(_AriaPy.IntArPoseMap___delitem__, args)

    def has_key(*args):
        """has_key(self, key_type key) -> bool"""
        return apply(_AriaPy.IntArPoseMap_has_key, args)

    def keys(*args):
        """keys(self) -> PyObject"""
        return apply(_AriaPy.IntArPoseMap_keys, args)

    def values(*args):
        """values(self) -> PyObject"""
        return apply(_AriaPy.IntArPoseMap_values, args)

    def items(*args):
        """items(self) -> PyObject"""
        return apply(_AriaPy.IntArPoseMap_items, args)

    def __contains__(*args):
        """__contains__(self, key_type key) -> bool"""
        return apply(_AriaPy.IntArPoseMap___contains__, args)

    def key_iterator(*args):
        """key_iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.IntArPoseMap_key_iterator, args)

    def value_iterator(*args):
        """value_iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return apply(_AriaPy.IntArPoseMap_value_iterator, args)

    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 __init__(self, *args): 
        """
        __init__(self) -> IntArPoseMap
        __init__(self, IntArPoseMap ?) -> IntArPoseMap
        """
        this = apply(_AriaPy.new_IntArPoseMap, args)
        try: self.this.append(this)
        except: self.this = this
    def empty(*args):
        """empty(self) -> bool"""
        return apply(_AriaPy.IntArPoseMap_empty, args)

    def size(*args):
        """size(self) -> size_type"""
        return apply(_AriaPy.IntArPoseMap_size, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.IntArPoseMap_clear, args)

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

    def get_allocator(*args):
        """get_allocator(self) -> allocator_type"""
        return apply(_AriaPy.IntArPoseMap_get_allocator, args)

    def begin(*args):
        """
        begin(self) -> iterator
        begin(self) -> const_iterator
        """
        return apply(_AriaPy.IntArPoseMap_begin, args)

    def end(*args):
        """
        end(self) -> iterator
        end(self) -> const_iterator
        """
        return apply(_AriaPy.IntArPoseMap_end, args)

    def rbegin(*args):
        """
        rbegin(self) -> reverse_iterator
        rbegin(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.IntArPoseMap_rbegin, args)

    def rend(*args):
        """
        rend(self) -> reverse_iterator
        rend(self) -> const_reverse_iterator
        """
        return apply(_AriaPy.IntArPoseMap_rend, args)

    def count(*args):
        """count(self, key_type x) -> size_type"""
        return apply(_AriaPy.IntArPoseMap_count, args)

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

    def find(*args):
        """
        find(self, key_type x) -> iterator
        find(self, key_type x) -> const_iterator
        """
        return apply(_AriaPy.IntArPoseMap_find, args)

    def lower_bound(*args):
        """
        lower_bound(self, key_type x) -> iterator
        lower_bound(self, key_type x) -> const_iterator
        """
        return apply(_AriaPy.IntArPoseMap_lower_bound, args)

    def upper_bound(*args):
        """
        upper_bound(self, key_type x) -> iterator
        upper_bound(self, key_type x) -> const_iterator
        """
        return apply(_AriaPy.IntArPoseMap_upper_bound, args)

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

class ArListPos:
    """Proxy of C++ ArListPos class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArListPos, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArListPos, name)
    __repr__ = _swig_repr
    FIRST = _AriaPy.ArListPos_FIRST
    LAST = _AriaPy.ArListPos_LAST
    def __init__(self, *args): 
        """__init__(self) -> ArListPos"""
        this = apply(_AriaPy.new_ArListPos, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArListPos
    __del__ = lambda self : None;
ArListPos_swigregister = _AriaPy.ArListPos_swigregister
ArListPos_swigregister(ArListPos)

class ArTypes:
    """Proxy of C++ ArTypes class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArTypes, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArTypes, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArTypes"""
        this = apply(_AriaPy.new_ArTypes, args)
        try: self.this.append(this)
        except: 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:
    """Proxy of C++ ArUtil class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArUtil, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArUtil, name)
    __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
    __swig_getmethods__["sleep"] = lambda x: _AriaPy.ArUtil_sleep
    __swig_getmethods__["getTime"] = lambda x: _AriaPy.ArUtil_getTime
    __swig_getmethods__["findMin"] = lambda x: _AriaPy.ArUtil_findMin
    __swig_getmethods__["findMax"] = lambda x: _AriaPy.ArUtil_findMax
    __swig_getmethods__["sizeFile"] = lambda x: _AriaPy.ArUtil_sizeFile
    __swig_getmethods__["findFile"] = lambda x: _AriaPy.ArUtil_findFile
    __swig_getmethods__["appendSlash"] = lambda x: _AriaPy.ArUtil_appendSlash
    __swig_getmethods__["fixSlashes"] = lambda x: _AriaPy.ArUtil_fixSlashes
    __swig_getmethods__["fixSlashesForward"] = lambda x: _AriaPy.ArUtil_fixSlashesForward
    __swig_getmethods__["fixSlashesBackward"] = lambda x: _AriaPy.ArUtil_fixSlashesBackward
    __swig_getmethods__["addDirectories"] = lambda x: _AriaPy.ArUtil_addDirectories
    __swig_getmethods__["strcmp"] = lambda x: _AriaPy.ArUtil_strcmp
    __swig_getmethods__["strcasecmp"] = lambda x: _AriaPy.ArUtil_strcasecmp
    __swig_getmethods__["strcasequotecmp"] = lambda x: _AriaPy.ArUtil_strcasequotecmp
    __swig_getmethods__["escapeSpaces"] = lambda x: _AriaPy.ArUtil_escapeSpaces
    __swig_getmethods__["stripQuotes"] = lambda x: _AriaPy.ArUtil_stripQuotes
    __swig_getmethods__["lower"] = lambda x: _AriaPy.ArUtil_lower
    __swig_getmethods__["isOnlyAlphaNumeric"] = lambda x: _AriaPy.ArUtil_isOnlyAlphaNumeric
    __swig_getmethods__["isStrEmpty"] = lambda x: _AriaPy.ArUtil_isStrEmpty
    __swig_getmethods__["atof"] = lambda x: _AriaPy.ArUtil_atof
    __swig_getmethods__["convertBool"] = lambda x: _AriaPy.ArUtil_convertBool
    __swig_getmethods__["writeToFile"] = lambda x: _AriaPy.ArUtil_writeToFile
    __swig_getmethods__["getStringFromFile"] = lambda x: _AriaPy.ArUtil_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
    __swig_getmethods__["getStringFromRegistry"] = lambda x: _AriaPy.ArUtil_getStringFromRegistry
    __swig_getmethods__["findFirstStringInRegistry"] = lambda x: _AriaPy.ArUtil_findFirstStringInRegistry
    __swig_setmethods__["COM1"] = _AriaPy.ArUtil_COM1_set
    __swig_getmethods__["COM1"] = _AriaPy.ArUtil_COM1_get
    __swig_setmethods__["COM2"] = _AriaPy.ArUtil_COM2_set
    __swig_getmethods__["COM2"] = _AriaPy.ArUtil_COM2_get
    __swig_setmethods__["COM3"] = _AriaPy.ArUtil_COM3_set
    __swig_getmethods__["COM3"] = _AriaPy.ArUtil_COM3_get
    __swig_setmethods__["COM4"] = _AriaPy.ArUtil_COM4_set
    __swig_getmethods__["COM4"] = _AriaPy.ArUtil_COM4_get
    __swig_setmethods__["COM5"] = _AriaPy.ArUtil_COM5_set
    __swig_getmethods__["COM5"] = _AriaPy.ArUtil_COM5_get
    __swig_setmethods__["COM6"] = _AriaPy.ArUtil_COM6_set
    __swig_getmethods__["COM6"] = _AriaPy.ArUtil_COM6_get
    __swig_setmethods__["COM7"] = _AriaPy.ArUtil_COM7_set
    __swig_getmethods__["COM7"] = _AriaPy.ArUtil_COM7_get
    __swig_setmethods__["COM8"] = _AriaPy.ArUtil_COM8_set
    __swig_getmethods__["COM8"] = _AriaPy.ArUtil_COM8_get
    __swig_setmethods__["COM9"] = _AriaPy.ArUtil_COM9_set
    __swig_getmethods__["COM9"] = _AriaPy.ArUtil_COM9_get
    __swig_setmethods__["COM10"] = _AriaPy.ArUtil_COM10_set
    __swig_getmethods__["COM10"] = _AriaPy.ArUtil_COM10_get
    __swig_setmethods__["COM11"] = _AriaPy.ArUtil_COM11_set
    __swig_getmethods__["COM11"] = _AriaPy.ArUtil_COM11_get
    __swig_setmethods__["COM12"] = _AriaPy.ArUtil_COM12_set
    __swig_getmethods__["COM12"] = _AriaPy.ArUtil_COM12_get
    __swig_setmethods__["COM13"] = _AriaPy.ArUtil_COM13_set
    __swig_getmethods__["COM13"] = _AriaPy.ArUtil_COM13_get
    __swig_setmethods__["COM14"] = _AriaPy.ArUtil_COM14_set
    __swig_getmethods__["COM14"] = _AriaPy.ArUtil_COM14_get
    __swig_setmethods__["COM15"] = _AriaPy.ArUtil_COM15_set
    __swig_getmethods__["COM15"] = _AriaPy.ArUtil_COM15_get
    __swig_setmethods__["COM16"] = _AriaPy.ArUtil_COM16_set
    __swig_getmethods__["COM16"] = _AriaPy.ArUtil_COM16_get
    __swig_setmethods__["TRUESTRING"] = _AriaPy.ArUtil_TRUESTRING_set
    __swig_getmethods__["TRUESTRING"] = _AriaPy.ArUtil_TRUESTRING_get
    __swig_setmethods__["FALSESTRING"] = _AriaPy.ArUtil_FALSESTRING_set
    __swig_getmethods__["FALSESTRING"] = _AriaPy.ArUtil_FALSESTRING_get
    __swig_getmethods__["putCurrentYearInString"] = lambda x: _AriaPy.ArUtil_putCurrentYearInString
    __swig_getmethods__["putCurrentMonthInString"] = lambda x: _AriaPy.ArUtil_putCurrentMonthInString
    __swig_getmethods__["putCurrentDayInString"] = lambda x: _AriaPy.ArUtil_putCurrentDayInString
    __swig_getmethods__["putCurrentHourInString"] = lambda x: _AriaPy.ArUtil_putCurrentHourInString
    __swig_getmethods__["putCurrentMinuteInString"] = lambda x: _AriaPy.ArUtil_putCurrentMinuteInString
    __swig_getmethods__["putCurrentSecondInString"] = lambda x: _AriaPy.ArUtil_putCurrentSecondInString
    __swig_getmethods__["localtime"] = lambda x: _AriaPy.ArUtil_localtime
    __swig_getmethods__["matchCase"] = lambda x: _AriaPy.ArUtil_matchCase
    __swig_getmethods__["getDirectory"] = lambda x: _AriaPy.ArUtil_getDirectory
    __swig_getmethods__["getFileName"] = lambda x: _AriaPy.ArUtil_getFileName
    __swig_getmethods__["changeFileTimestamp"] = lambda x: _AriaPy.ArUtil_changeFileTimestamp
    __swig_getmethods__["fopen"] = lambda x: _AriaPy.ArUtil_fopen
    __swig_getmethods__["open"] = lambda x: _AriaPy.ArUtil_open
    __swig_getmethods__["creat"] = lambda x: _AriaPy.ArUtil_creat
    __swig_getmethods__["popen"] = lambda x: _AriaPy.ArUtil_popen
    __swig_getmethods__["setFileCloseOnExec"] = lambda x: _AriaPy.ArUtil_setFileCloseOnExec
    __swig_getmethods__["floatIsNormal"] = lambda x: _AriaPy.ArUtil_floatIsNormal
    def __init__(self, *args): 
        """__init__(self) -> ArUtil"""
        this = apply(_AriaPy.new_ArUtil, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArUtil
    __del__ = lambda self : None;
ArUtil_swigregister = _AriaPy.ArUtil_swigregister
ArUtil_swigregister(ArUtil)

def ArUtil_sleep(*args):
  """ArUtil_sleep(unsigned int ms)"""
  return apply(_AriaPy.ArUtil_sleep, args)

def ArUtil_getTime(*args):
  """ArUtil_getTime() -> unsigned int"""
  return apply(_AriaPy.ArUtil_getTime, args)

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

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

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

def ArUtil_findFile(*args):
  """ArUtil_findFile(char fileName) -> bool"""
  return apply(_AriaPy.ArUtil_findFile, args)

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

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

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

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

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

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

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

def ArUtil_strcasequotecmp(*args):
  """ArUtil_strcasequotecmp(std::string str1, std::string str2) -> int"""
  return apply(_AriaPy.ArUtil_strcasequotecmp, args)

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

def ArUtil_stripQuotes(*args):
  """ArUtil_stripQuotes(char dest, char src, size_t destLen) -> bool"""
  return apply(_AriaPy.ArUtil_stripQuotes, args)

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

def ArUtil_isOnlyAlphaNumeric(*args):
  """ArUtil_isOnlyAlphaNumeric(char str) -> bool"""
  return apply(_AriaPy.ArUtil_isOnlyAlphaNumeric, args)

def ArUtil_isStrEmpty(*args):
  """ArUtil_isStrEmpty(char str) -> bool"""
  return apply(_AriaPy.ArUtil_isStrEmpty, args)

def ArUtil_atof(*args):
  """ArUtil_atof(char nptr) -> double"""
  return apply(_AriaPy.ArUtil_atof, args)

def ArUtil_convertBool(*args):
  """ArUtil_convertBool(int val) -> char"""
  return apply(_AriaPy.ArUtil_convertBool, args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def ArUtil_floatIsNormal(*args):
  """ArUtil_floatIsNormal(double f) -> bool"""
  return apply(_AriaPy.ArUtil_floatIsNormal, args)

class ArMath:
    """Proxy of C++ ArMath class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMath, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArMath, name)
    __repr__ = _swig_repr
    __swig_getmethods__["epsilon"] = lambda x: _AriaPy.ArMath_epsilon
    __swig_getmethods__["addAngle"] = lambda x: _AriaPy.ArMath_addAngle
    __swig_getmethods__["subAngle"] = lambda x: _AriaPy.ArMath_subAngle
    __swig_getmethods__["fixAngle"] = lambda x: _AriaPy.ArMath_fixAngle
    __swig_getmethods__["degToRad"] = lambda x: _AriaPy.ArMath_degToRad
    __swig_getmethods__["radToDeg"] = lambda x: _AriaPy.ArMath_radToDeg
    __swig_getmethods__["cos"] = lambda x: _AriaPy.ArMath_cos
    __swig_getmethods__["sin"] = lambda x: _AriaPy.ArMath_sin
    __swig_getmethods__["tan"] = lambda x: _AriaPy.ArMath_tan
    __swig_getmethods__["atan2"] = lambda x: _AriaPy.ArMath_atan2
    __swig_getmethods__["angleBetween"] = lambda x: _AriaPy.ArMath_angleBetween
    __swig_getmethods__["fabs"] = lambda x: _AriaPy.ArMath_fabs
    __swig_getmethods__["roundInt"] = lambda x: _AriaPy.ArMath_roundInt
    __swig_getmethods__["roundShort"] = lambda x: _AriaPy.ArMath_roundShort
    __swig_getmethods__["pointRotate"] = lambda x: _AriaPy.ArMath_pointRotate
    __swig_getmethods__["random"] = lambda x: _AriaPy.ArMath_random
    __swig_getmethods__["getRandMax"] = lambda x: _AriaPy.ArMath_getRandMax
    __swig_getmethods__["randomInRange"] = lambda x: _AriaPy.ArMath_randomInRange
    __swig_getmethods__["distanceBetween"] = lambda x: _AriaPy.ArMath_distanceBetween
    __swig_getmethods__["squaredDistanceBetween"] = lambda x: _AriaPy.ArMath_squaredDistanceBetween
    __swig_getmethods__["log2"] = lambda x: _AriaPy.ArMath_log2
    def __init__(self, *args): 
        """__init__(self) -> ArMath"""
        this = apply(_AriaPy.new_ArMath, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMath
    __del__ = lambda self : None;
ArMath_swigregister = _AriaPy.ArMath_swigregister
ArMath_swigregister(ArMath)

def ArMath_epsilon(*args):
  """ArMath_epsilon() -> double"""
  return apply(_AriaPy.ArMath_epsilon, args)

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

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

def ArMath_fixAngle(*args):
  """ArMath_fixAngle(double angle) -> double"""
  return apply(_AriaPy.ArMath_fixAngle, args)

def ArMath_degToRad(*args):
  """ArMath_degToRad(double deg) -> double"""
  return apply(_AriaPy.ArMath_degToRad, args)

def ArMath_radToDeg(*args):
  """ArMath_radToDeg(double rad) -> double"""
  return apply(_AriaPy.ArMath_radToDeg, args)

def ArMath_cos(*args):
  """ArMath_cos(double angle) -> double"""
  return apply(_AriaPy.ArMath_cos, args)

def ArMath_sin(*args):
  """ArMath_sin(double angle) -> double"""
  return apply(_AriaPy.ArMath_sin, args)

def ArMath_tan(*args):
  """ArMath_tan(double angle) -> double"""
  return apply(_AriaPy.ArMath_tan, args)

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

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

def ArMath_fabs(*args):
  """ArMath_fabs(double val) -> double"""
  return apply(_AriaPy.ArMath_fabs, args)

def ArMath_roundInt(*args):
  """ArMath_roundInt(double val) -> int"""
  return apply(_AriaPy.ArMath_roundInt, args)

def ArMath_roundShort(*args):
  """ArMath_roundShort(double val) -> short"""
  return apply(_AriaPy.ArMath_roundShort, args)

def ArMath_pointRotate(*args):
  """ArMath_pointRotate(double x, double y, double th)"""
  return apply(_AriaPy.ArMath_pointRotate, args)

def ArMath_random(*args):
  """ArMath_random() -> long"""
  return apply(_AriaPy.ArMath_random, args)

def ArMath_getRandMax(*args):
  """ArMath_getRandMax() -> long"""
  return apply(_AriaPy.ArMath_getRandMax, args)

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

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

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

def ArMath_log2(*args):
  """ArMath_log2(double x) -> double"""
  return apply(_AriaPy.ArMath_log2, args)

class ArPose:
    """Proxy of C++ ArPose class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPose, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArPose, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, double x=0, double y=0, double th=0) -> ArPose
        __init__(self, double x=0, double y=0) -> ArPose
        __init__(self, double x=0) -> ArPose
        __init__(self) -> ArPose
        __init__(self, ArPose pose) -> ArPose
        """
        this = apply(_AriaPy.new_ArPose, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArPose
    __del__ = lambda self : None;
    def setPose(*args):
        """
        setPose(self, double x, double y, double th=0)
        setPose(self, double x, double y)
        setPose(self, ArPose position)
        """
        return apply(_AriaPy.ArPose_setPose, args)

    def setX(*args):
        """setX(self, double x)"""
        return apply(_AriaPy.ArPose_setX, args)

    def setY(*args):
        """setY(self, double y)"""
        return apply(_AriaPy.ArPose_setY, args)

    def setTh(*args):
        """setTh(self, double th)"""
        return apply(_AriaPy.ArPose_setTh, args)

    def setThRad(*args):
        """setThRad(self, double th)"""
        return apply(_AriaPy.ArPose_setThRad, args)

    def getX(*args):
        """getX(self) -> double"""
        return apply(_AriaPy.ArPose_getX, args)

    def getY(*args):
        """getY(self) -> double"""
        return apply(_AriaPy.ArPose_getY, args)

    def getTh(*args):
        """getTh(self) -> double"""
        return apply(_AriaPy.ArPose_getTh, args)

    def getThRad(*args):
        """getThRad(self) -> double"""
        return apply(_AriaPy.ArPose_getThRad, args)

    def getPose(*args):
        """
        getPose(self, double x, double y, double th=None)
        getPose(self, double x, double y)
        """
        return apply(_AriaPy.ArPose_getPose, args)

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

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

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

    def log(*args):
        """log(self)"""
        return apply(_AriaPy.ArPose_log, args)

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

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

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

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

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

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

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

    def __str__(*args):
        """__str__(self) -> char"""
        return apply(_AriaPy.ArPose___str__, args)

    __swig_setmethods__["x"] = _AriaPy.ArPose_x_set
    __swig_getmethods__["x"] = _AriaPy.ArPose_x_get
    __swig_setmethods__["y"] = _AriaPy.ArPose_y_set
    __swig_getmethods__["y"] = _AriaPy.ArPose_y_get
    __swig_setmethods__["th"] = _AriaPy.ArPose_th_set
    __swig_getmethods__["th"] = _AriaPy.ArPose_th_get
ArPose_swigregister = _AriaPy.ArPose_swigregister
ArPose_swigregister(ArPose)

class ArTime:
    """Proxy of C++ ArTime class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArTime, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArTime, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArTime"""
        this = apply(_AriaPy.new_ArTime, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArTime
    __del__ = lambda self : None;
    def mSecTo(*args):
        """mSecTo(self) -> long"""
        return apply(_AriaPy.ArTime_mSecTo, args)

    def secTo(*args):
        """secTo(self) -> long"""
        return apply(_AriaPy.ArTime_secTo, args)

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

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

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

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

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

    def setToNow(*args):
        """setToNow(self)"""
        return apply(_AriaPy.ArTime_setToNow, args)

    def addMSec(*args):
        """addMSec(self, long ms)"""
        return apply(_AriaPy.ArTime_addMSec, args)

    def setSec(*args):
        """setSec(self, time_t sec)"""
        return apply(_AriaPy.ArTime_setSec, args)

    def setMSec(*args):
        """setMSec(self, time_t msec)"""
        return apply(_AriaPy.ArTime_setMSec, args)

    def getSec(*args):
        """getSec(self) -> time_t"""
        return apply(_AriaPy.ArTime_getSec, args)

    def getMSec(*args):
        """getMSec(self) -> time_t"""
        return apply(_AriaPy.ArTime_getMSec, args)

    def log(*args):
        """log(self)"""
        return apply(_AriaPy.ArTime_log, args)

    __swig_getmethods__["usingMonotonicClock"] = lambda x: _AriaPy.ArTime_usingMonotonicClock
ArTime_swigregister = _AriaPy.ArTime_swigregister
ArTime_swigregister(ArTime)

def ArTime_usingMonotonicClock(*args):
  """ArTime_usingMonotonicClock() -> bool"""
  return apply(_AriaPy.ArTime_usingMonotonicClock, args)

class ArPoseWithTime(ArPose):
    """Proxy of C++ ArPoseWithTime class"""
    __swig_setmethods__ = {}
    for _s in [ArPose]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPoseWithTime, name, value)
    __swig_getmethods__ = {}
    for _s in [ArPose]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArPoseWithTime, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, double x=0, double y=0, double th=0, ArTime thisTime=ArTime()) -> ArPoseWithTime
        __init__(self, double x=0, double y=0, double th=0) -> ArPoseWithTime
        __init__(self, double x=0, double y=0) -> ArPoseWithTime
        __init__(self, double x=0) -> ArPoseWithTime
        __init__(self) -> ArPoseWithTime
        __init__(self, ArPose pose) -> ArPoseWithTime
        """
        this = apply(_AriaPy.new_ArPoseWithTime, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArPoseWithTime
    __del__ = lambda self : None;
    def setTime(*args):
        """setTime(self, ArTime newTime)"""
        return apply(_AriaPy.ArPoseWithTime_setTime, args)

    def setTimeToNow(*args):
        """setTimeToNow(self)"""
        return apply(_AriaPy.ArPoseWithTime_setTimeToNow, args)

    def getTime(*args):
        """getTime(self) -> ArTime"""
        return apply(_AriaPy.ArPoseWithTime_getTime, args)

ArPoseWithTime_swigregister = _AriaPy.ArPoseWithTime_swigregister
ArPoseWithTime_swigregister(ArPoseWithTime)

class ArSectors:
    """Proxy of C++ ArSectors class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSectors, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArSectors, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, int numSectors=8) -> ArSectors
        __init__(self) -> ArSectors
        """
        this = apply(_AriaPy.new_ArSectors, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSectors
    __del__ = lambda self : None;
    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArSectors_clear, args)

    def update(*args):
        """update(self, double angle)"""
        return apply(_AriaPy.ArSectors_update, args)

    def didAll(*args):
        """didAll(self) -> bool"""
        return apply(_AriaPy.ArSectors_didAll, args)

ArSectors_swigregister = _AriaPy.ArSectors_swigregister
ArSectors_swigregister(ArSectors)

class ArLine:
    """Proxy of C++ ArLine class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLine, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArLine, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> ArLine
        __init__(self, double a, double b, double c) -> ArLine
        __init__(self, double x1, double y1, double x2, double y2) -> ArLine
        """
        this = apply(_AriaPy.new_ArLine, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLine
    __del__ = lambda self : None;
    def newParameters(*args):
        """newParameters(self, double a, double b, double c)"""
        return apply(_AriaPy.ArLine_newParameters, args)

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

    def getA(*args):
        """getA(self) -> double"""
        return apply(_AriaPy.ArLine_getA, args)

    def getB(*args):
        """getB(self) -> double"""
        return apply(_AriaPy.ArLine_getB, args)

    def getC(*args):
        """getC(self) -> double"""
        return apply(_AriaPy.ArLine_getC, args)

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

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

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

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

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

ArLine_swigregister = _AriaPy.ArLine_swigregister
ArLine_swigregister(ArLine)

class ArLineSegment:
    """Proxy of C++ ArLineSegment class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLineSegment, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArLineSegment, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArPose pose1, ArPose pose2) -> ArLineSegment"""
        this = apply(_AriaPy.new_ArLineSegment, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLineSegment
    __del__ = lambda self : None;
    def newEndPoints(*args):
        """
        newEndPoints(self, double x1, double y1, double x2, double y2)
        newEndPoints(self, ArPose pt1, ArPose pt2)
        """
        return apply(_AriaPy.ArLineSegment_newEndPoints, args)

    def getEndPoint1(*args):
        """getEndPoint1(self) -> ArPose"""
        return apply(_AriaPy.ArLineSegment_getEndPoint1, args)

    def getEndPoint2(*args):
        """getEndPoint2(self) -> ArPose"""
        return apply(_AriaPy.ArLineSegment_getEndPoint2, args)

    def intersects(*args):
        """
        intersects(self, ArLine line, ArPose pose) -> bool
        intersects(self, ArLineSegment line, ArPose pose) -> bool
        """
        return apply(_AriaPy.ArLineSegment_intersects, args)

    def getPerpPoint(*args):
        """getPerpPoint(self, ArPose pose, ArPose perpPoint) -> bool"""
        return apply(_AriaPy.ArLineSegment_getPerpPoint, args)

    def getPerpDist(*args):
        """getPerpDist(self, ArPose pose) -> double"""
        return apply(_AriaPy.ArLineSegment_getPerpDist, args)

    def getPerpSquaredDist(*args):
        """getPerpSquaredDist(self, ArPose pose) -> double"""
        return apply(_AriaPy.ArLineSegment_getPerpSquaredDist, args)

    def getDistToLine(*args):
        """getDistToLine(self, ArPose pose) -> double"""
        return apply(_AriaPy.ArLineSegment_getDistToLine, args)

    def getLengthOf(*args):
        """getLengthOf(self) -> double"""
        return apply(_AriaPy.ArLineSegment_getLengthOf, args)

    def getX1(*args):
        """getX1(self) -> double"""
        return apply(_AriaPy.ArLineSegment_getX1, args)

    def getY1(*args):
        """getY1(self) -> double"""
        return apply(_AriaPy.ArLineSegment_getY1, args)

    def getX2(*args):
        """getX2(self) -> double"""
        return apply(_AriaPy.ArLineSegment_getX2, args)

    def getY2(*args):
        """getY2(self) -> double"""
        return apply(_AriaPy.ArLineSegment_getY2, args)

    def getA(*args):
        """getA(self) -> double"""
        return apply(_AriaPy.ArLineSegment_getA, args)

    def getB(*args):
        """getB(self) -> double"""
        return apply(_AriaPy.ArLineSegment_getB, args)

    def getC(*args):
        """getC(self) -> double"""
        return apply(_AriaPy.ArLineSegment_getC, args)

    def linePointIsInSegment(*args):
        """linePointIsInSegment(self, ArPose pose) -> bool"""
        return apply(_AriaPy.ArLineSegment_linePointIsInSegment, args)

    def getLine(*args):
        """getLine(self) -> ArLine"""
        return apply(_AriaPy.ArLineSegment_getLine, args)

    def __eq__(*args):
        """__eq__(self, ArLineSegment other) -> bool"""
        return apply(_AriaPy.ArLineSegment___eq__, args)

    def __ne__(*args):
        """__ne__(self, ArLineSegment other) -> bool"""
        return apply(_AriaPy.ArLineSegment___ne__, args)

    def __lt__(*args):
        """__lt__(self, ArLineSegment other) -> bool"""
        return apply(_AriaPy.ArLineSegment___lt__, args)

ArLineSegment_swigregister = _AriaPy.ArLineSegment_swigregister
ArLineSegment_swigregister(ArLineSegment)

class ArRunningAverage:
    """Proxy of C++ ArRunningAverage class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRunningAverage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArRunningAverage, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, size_t numToAverage) -> ArRunningAverage"""
        this = apply(_AriaPy.new_ArRunningAverage, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRunningAverage
    __del__ = lambda self : None;
    def getAverage(*args):
        """getAverage(self) -> double"""
        return apply(_AriaPy.ArRunningAverage_getAverage, args)

    def add(*args):
        """add(self, double val)"""
        return apply(_AriaPy.ArRunningAverage_add, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArRunningAverage_clear, args)

    def getNumToAverage(*args):
        """getNumToAverage(self) -> size_t"""
        return apply(_AriaPy.ArRunningAverage_getNumToAverage, args)

    def setNumToAverage(*args):
        """setNumToAverage(self, size_t numToAverage)"""
        return apply(_AriaPy.ArRunningAverage_setNumToAverage, args)

    def getCurrentNumAveraged(*args):
        """getCurrentNumAveraged(self) -> size_t"""
        return apply(_AriaPy.ArRunningAverage_getCurrentNumAveraged, args)

ArRunningAverage_swigregister = _AriaPy.ArRunningAverage_swigregister
ArRunningAverage_swigregister(ArRunningAverage)

class ArStrCaseCmpOp:
    """Proxy of C++ ArStrCaseCmpOp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArStrCaseCmpOp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArStrCaseCmpOp, name)
    __repr__ = _swig_repr
    def __call__(*args):
        """__call__(self, std::string s1, std::string s2) -> bool"""
        return apply(_AriaPy.ArStrCaseCmpOp___call__, args)

    def __init__(self, *args): 
        """__init__(self) -> ArStrCaseCmpOp"""
        this = apply(_AriaPy.new_ArStrCaseCmpOp, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArStrCaseCmpOp
    __del__ = lambda self : None;
ArStrCaseCmpOp_swigregister = _AriaPy.ArStrCaseCmpOp_swigregister
ArStrCaseCmpOp_swigregister(ArStrCaseCmpOp)

class ArPoseCmpOp:
    """Proxy of C++ ArPoseCmpOp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPoseCmpOp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArPoseCmpOp, name)
    __repr__ = _swig_repr
    def __call__(*args):
        """__call__(self, ArPose pose1, ArPose pose2) -> bool"""
        return apply(_AriaPy.ArPoseCmpOp___call__, args)

    def __init__(self, *args): 
        """__init__(self) -> ArPoseCmpOp"""
        this = apply(_AriaPy.new_ArPoseCmpOp, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArPoseCmpOp
    __del__ = lambda self : None;
ArPoseCmpOp_swigregister = _AriaPy.ArPoseCmpOp_swigregister
ArPoseCmpOp_swigregister(ArPoseCmpOp)

class ArLineSegmentCmpOp:
    """Proxy of C++ ArLineSegmentCmpOp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLineSegmentCmpOp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArLineSegmentCmpOp, name)
    __repr__ = _swig_repr
    def __call__(*args):
        """__call__(self, ArLineSegment line1, ArLineSegment line2) -> bool"""
        return apply(_AriaPy.ArLineSegmentCmpOp___call__, args)

    def __init__(self, *args): 
        """__init__(self) -> ArLineSegmentCmpOp"""
        this = apply(_AriaPy.new_ArLineSegmentCmpOp, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLineSegmentCmpOp
    __del__ = lambda self : None;
ArLineSegmentCmpOp_swigregister = _AriaPy.ArLineSegmentCmpOp_swigregister
ArLineSegmentCmpOp_swigregister(ArLineSegmentCmpOp)

class ArPriority:
    """Proxy of C++ ArPriority class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPriority, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArPriority, name)
    __repr__ = _swig_repr
    IMPORTANT = _AriaPy.ArPriority_IMPORTANT
    BASIC = _AriaPy.ArPriority_BASIC
    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
    LAST_PRIORITY = _AriaPy.ArPriority_LAST_PRIORITY
    PRIORITY_COUNT = _AriaPy.ArPriority_PRIORITY_COUNT
    __swig_getmethods__["getPriorityName"] = lambda x: _AriaPy.ArPriority_getPriorityName
    def __init__(self, *args): 
        """__init__(self) -> ArPriority"""
        this = apply(_AriaPy.new_ArPriority, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArPriority
    __del__ = lambda self : None;
ArPriority_swigregister = _AriaPy.ArPriority_swigregister
ArPriority_swigregister(ArPriority)

def ArPriority_getPriorityName(*args):
  """ArPriority_getPriorityName(Priority priority) -> char"""
  return apply(_AriaPy.ArPriority_getPriorityName, args)

class ArStringInfoHolder:
    """Proxy of C++ ArStringInfoHolder class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArStringInfoHolder, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArStringInfoHolder, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, char name, UByte2 maxLength, ArFunctor2<(p.char,ArTypes::UByte2)> functor) -> ArStringInfoHolder"""
        this = apply(_AriaPy.new_ArStringInfoHolder, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArStringInfoHolder
    __del__ = lambda self : None;
    def getName(*args):
        """getName(self) -> char"""
        return apply(_AriaPy.ArStringInfoHolder_getName, args)

    def getMaxLength(*args):
        """getMaxLength(self) -> UByte2"""
        return apply(_AriaPy.ArStringInfoHolder_getMaxLength, args)

    def getFunctor(*args):
        """getFunctor(self) -> ArFunctor2<(p.char,ArTypes::UByte2)>"""
        return apply(_AriaPy.ArStringInfoHolder_getFunctor, args)

ArStringInfoHolder_swigregister = _AriaPy.ArStringInfoHolder_swigregister
ArStringInfoHolder_swigregister(ArStringInfoHolder)

class ArStringInfoHolderFunctions:
    """Proxy of C++ ArStringInfoHolderFunctions class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArStringInfoHolderFunctions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArStringInfoHolderFunctions, name)
    __repr__ = _swig_repr
    __swig_getmethods__["intWrapper"] = lambda x: _AriaPy.ArStringInfoHolderFunctions_intWrapper
    __swig_getmethods__["doubleWrapper"] = lambda x: _AriaPy.ArStringInfoHolderFunctions_doubleWrapper
    __swig_getmethods__["boolWrapper"] = lambda x: _AriaPy.ArStringInfoHolderFunctions_boolWrapper
    __swig_getmethods__["stringWrapper"] = lambda x: _AriaPy.ArStringInfoHolderFunctions_stringWrapper
    def __init__(self, *args): 
        """__init__(self) -> ArStringInfoHolderFunctions"""
        this = apply(_AriaPy.new_ArStringInfoHolderFunctions, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArStringInfoHolderFunctions
    __del__ = lambda self : None;
ArStringInfoHolderFunctions_swigregister = _AriaPy.ArStringInfoHolderFunctions_swigregister
ArStringInfoHolderFunctions_swigregister(ArStringInfoHolderFunctions)

def ArStringInfoHolderFunctions_intWrapper(*args):
  """
    ArStringInfoHolderFunctions_intWrapper(char buffer, UByte2 bufferLen, ArRetFunctor_Int functor, 
        char format)
    """
  return apply(_AriaPy.ArStringInfoHolderFunctions_intWrapper, args)

def ArStringInfoHolderFunctions_doubleWrapper(*args):
  """
    ArStringInfoHolderFunctions_doubleWrapper(char buffer, UByte2 bufferLen, ArRetFunctor_Double functor, 
        char format)
    """
  return apply(_AriaPy.ArStringInfoHolderFunctions_doubleWrapper, args)

def ArStringInfoHolderFunctions_boolWrapper(*args):
  """
    ArStringInfoHolderFunctions_boolWrapper(char buffer, UByte2 bufferLen, ArRetFunctor_Bool functor, 
        char format)
    """
  return apply(_AriaPy.ArStringInfoHolderFunctions_boolWrapper, args)

def ArStringInfoHolderFunctions_stringWrapper(*args):
  """
    ArStringInfoHolderFunctions_stringWrapper(char buffer, UByte2 bufferLen, ArRetFunctor<(p.q(const).char)> functor, 
        char format)
    """
  return apply(_AriaPy.ArStringInfoHolderFunctions_stringWrapper, args)

class ArCallbackList:
    """Proxy of C++ ArCallbackList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArCallbackList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArCallbackList, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="", LogLevel logLevel=Verbose, bool singleShot=False) -> ArCallbackList
        __init__(self, char name="", LogLevel logLevel=Verbose) -> ArCallbackList
        __init__(self, char name="") -> ArCallbackList
        __init__(self) -> ArCallbackList
        """
        this = apply(_AriaPy.new_ArCallbackList, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArCallbackList
    __del__ = lambda self : None;
    def addCallback(*args):
        """
        addCallback(self, ArFunctor functor, int position=50)
        addCallback(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArCallbackList_addCallback, args)

    def remCallback(*args):
        """remCallback(self, ArFunctor functor)"""
        return apply(_AriaPy.ArCallbackList_remCallback, args)

    def setName(*args):
        """setName(self, char name)"""
        return apply(_AriaPy.ArCallbackList_setName, args)

    def setLogLevel(*args):
        """setLogLevel(self, LogLevel logLevel)"""
        return apply(_AriaPy.ArCallbackList_setLogLevel, args)

    def setSingleShot(*args):
        """setSingleShot(self, bool singleShot)"""
        return apply(_AriaPy.ArCallbackList_setSingleShot, args)

    def invoke(*args):
        """invoke(self)"""
        return apply(_AriaPy.ArCallbackList_invoke, args)

ArCallbackList_swigregister = _AriaPy.ArCallbackList_swigregister
ArCallbackList_swigregister(ArCallbackList)

class md5_state_t:
    """Proxy of C++ md5_state_t class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, md5_state_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, md5_state_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["count"] = _AriaPy.md5_state_t_count_set
    __swig_getmethods__["count"] = _AriaPy.md5_state_t_count_get
    __swig_setmethods__["abcd"] = _AriaPy.md5_state_t_abcd_set
    __swig_getmethods__["abcd"] = _AriaPy.md5_state_t_abcd_get
    __swig_setmethods__["buf"] = _AriaPy.md5_state_t_buf_set
    __swig_getmethods__["buf"] = _AriaPy.md5_state_t_buf_get
    def __init__(self, *args): 
        """__init__(self) -> md5_state_t"""
        this = apply(_AriaPy.new_md5_state_t, args)
        try: self.this.append(this)
        except: 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(*args):
  """md5_init( pms)"""
  return apply(_AriaPy.md5_init, args)

def md5_append(*args):
  """md5_append( pms, md5_byte_t data, int nbytes)"""
  return apply(_AriaPy.md5_append, args)

def md5_finish(*args):
  """md5_finish( pms, md5_byte_t digest)"""
  return apply(_AriaPy.md5_finish, args)
class ArBasePacket:
    """Proxy of C++ ArBasePacket class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArBasePacket, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArBasePacket, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, UByte2 bufferSize=0, UByte2 headerLength=0, char buf=None, 
            UByte2 footerLength=0) -> ArBasePacket
        __init__(self, UByte2 bufferSize=0, UByte2 headerLength=0, char buf=None) -> ArBasePacket
        __init__(self, UByte2 bufferSize=0, UByte2 headerLength=0) -> ArBasePacket
        __init__(self, UByte2 bufferSize=0) -> ArBasePacket
        __init__(self) -> ArBasePacket
        __init__(self, ArBasePacket other) -> ArBasePacket
        """
        this = apply(_AriaPy.new_ArBasePacket, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArBasePacket
    __del__ = lambda self : None;
    def empty(*args):
        """empty(self)"""
        return apply(_AriaPy.ArBasePacket_empty, args)

    def finalizePacket(*args):
        """finalizePacket(self)"""
        return apply(_AriaPy.ArBasePacket_finalizePacket, args)

    def log(*args):
        """log(self)"""
        return apply(_AriaPy.ArBasePacket_log, args)

    def printHex(*args):
        """printHex(self)"""
        return apply(_AriaPy.ArBasePacket_printHex, args)

    def isValid(*args):
        """isValid(self) -> bool"""
        return apply(_AriaPy.ArBasePacket_isValid, args)

    def resetValid(*args):
        """resetValid(self)"""
        return apply(_AriaPy.ArBasePacket_resetValid, args)

    def byteToBuf(*args):
        """byteToBuf(self, Byte val)"""
        return apply(_AriaPy.ArBasePacket_byteToBuf, args)

    def byte2ToBuf(*args):
        """byte2ToBuf(self, Byte2 val)"""
        return apply(_AriaPy.ArBasePacket_byte2ToBuf, args)

    def byte4ToBuf(*args):
        """byte4ToBuf(self, Byte4 val)"""
        return apply(_AriaPy.ArBasePacket_byte4ToBuf, args)

    def uByteToBuf(*args):
        """uByteToBuf(self, UByte val)"""
        return apply(_AriaPy.ArBasePacket_uByteToBuf, args)

    def uByte2ToBuf(*args):
        """uByte2ToBuf(self, UByte2 val)"""
        return apply(_AriaPy.ArBasePacket_uByte2ToBuf, args)

    def uByte4ToBuf(*args):
        """uByte4ToBuf(self, UByte4 val)"""
        return apply(_AriaPy.ArBasePacket_uByte4ToBuf, args)

    def strToBuf(*args):
        """strToBuf(self, char str)"""
        return apply(_AriaPy.ArBasePacket_strToBuf, args)

    def strNToBuf(*args):
        """strNToBuf(self, char str, int length)"""
        return apply(_AriaPy.ArBasePacket_strNToBuf, args)

    def strToBufPadded(*args):
        """strToBufPadded(self, char str, int length)"""
        return apply(_AriaPy.ArBasePacket_strToBufPadded, args)

    def dataToBuf(*args):
        """
        dataToBuf(self, char data, int length)
        dataToBuf(self, unsigned char data, int length)
        """
        return apply(_AriaPy.ArBasePacket_dataToBuf, args)

    def bufToByte(*args):
        """bufToByte(self) -> Byte"""
        return apply(_AriaPy.ArBasePacket_bufToByte, args)

    def bufToByte2(*args):
        """bufToByte2(self) -> Byte2"""
        return apply(_AriaPy.ArBasePacket_bufToByte2, args)

    def bufToByte4(*args):
        """bufToByte4(self) -> Byte4"""
        return apply(_AriaPy.ArBasePacket_bufToByte4, args)

    def bufToUByte(*args):
        """bufToUByte(self) -> UByte"""
        return apply(_AriaPy.ArBasePacket_bufToUByte, args)

    def bufToUByte2(*args):
        """bufToUByte2(self) -> UByte2"""
        return apply(_AriaPy.ArBasePacket_bufToUByte2, args)

    def bufToUByte4(*args):
        """bufToUByte4(self) -> UByte4"""
        return apply(_AriaPy.ArBasePacket_bufToUByte4, args)

    def bufToStr(*args):
        """bufToStr(self, char buf, int len)"""
        return apply(_AriaPy.ArBasePacket_bufToStr, args)

    def bufToData(*args):
        """
        bufToData(self, char data, int length)
        bufToData(self, unsigned char data, int length)
        """
        return apply(_AriaPy.ArBasePacket_bufToData, args)

    def resetRead(*args):
        """resetRead(self)"""
        return apply(_AriaPy.ArBasePacket_resetRead, args)

    def getLength(*args):
        """getLength(self) -> UByte2"""
        return apply(_AriaPy.ArBasePacket_getLength, args)

    def getDataLength(*args):
        """getDataLength(self) -> UByte2"""
        return apply(_AriaPy.ArBasePacket_getDataLength, args)

    def getReadLength(*args):
        """getReadLength(self) -> UByte2"""
        return apply(_AriaPy.ArBasePacket_getReadLength, args)

    def getDataReadLength(*args):
        """getDataReadLength(self) -> UByte2"""
        return apply(_AriaPy.ArBasePacket_getDataReadLength, args)

    def getHeaderLength(*args):
        """getHeaderLength(self) -> UByte2"""
        return apply(_AriaPy.ArBasePacket_getHeaderLength, args)

    def getFooterLength(*args):
        """getFooterLength(self) -> UByte2"""
        return apply(_AriaPy.ArBasePacket_getFooterLength, args)

    def getMaxLength(*args):
        """getMaxLength(self) -> UByte2"""
        return apply(_AriaPy.ArBasePacket_getMaxLength, args)

    def getBuf(*args):
        """getBuf(self) -> char"""
        return apply(_AriaPy.ArBasePacket_getBuf, args)

    def setBuf(*args):
        """setBuf(self, char buf, UByte2 bufferSize)"""
        return apply(_AriaPy.ArBasePacket_setBuf, args)

    def setMaxLength(*args):
        """setMaxLength(self, UByte2 bufferSize)"""
        return apply(_AriaPy.ArBasePacket_setMaxLength, args)

    def setLength(*args):
        """setLength(self, UByte2 length) -> bool"""
        return apply(_AriaPy.ArBasePacket_setLength, args)

    def setReadLength(*args):
        """setReadLength(self, UByte2 readLength)"""
        return apply(_AriaPy.ArBasePacket_setReadLength, args)

    def setHeaderLength(*args):
        """setHeaderLength(self, UByte2 length) -> bool"""
        return apply(_AriaPy.ArBasePacket_setHeaderLength, args)

    def duplicatePacket(*args):
        """duplicatePacket(self, ArBasePacket packet)"""
        return apply(_AriaPy.ArBasePacket_duplicatePacket, args)

ArBasePacket_swigregister = _AriaPy.ArBasePacket_swigregister
ArBasePacket_swigregister(ArBasePacket)

class ArPTZ:
    """Proxy of C++ ArPTZ class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPTZ, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArPTZ, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArPTZ
    __del__ = lambda self : None;
    def init(*args):
        """init(self) -> bool"""
        return apply(_AriaPy.ArPTZ_init, args)

    def reset(*args):
        """reset(self)"""
        return apply(_AriaPy.ArPTZ_reset, args)

    def pan(*args):
        """pan(self, double degrees) -> bool"""
        return apply(_AriaPy.ArPTZ_pan, args)

    def panRel(*args):
        """panRel(self, double degrees) -> bool"""
        return apply(_AriaPy.ArPTZ_panRel, args)

    def tilt(*args):
        """tilt(self, double degrees) -> bool"""
        return apply(_AriaPy.ArPTZ_tilt, args)

    def tiltRel(*args):
        """tiltRel(self, double degrees) -> bool"""
        return apply(_AriaPy.ArPTZ_tiltRel, args)

    def panTilt(*args):
        """panTilt(self, double degreesPan, double degreesTilt) -> bool"""
        return apply(_AriaPy.ArPTZ_panTilt, args)

    def panTiltRel(*args):
        """panTiltRel(self, double degreesPan, double degreesTilt) -> bool"""
        return apply(_AriaPy.ArPTZ_panTiltRel, args)

    def canZoom(*args):
        """canZoom(self) -> bool"""
        return apply(_AriaPy.ArPTZ_canZoom, args)

    def zoom(*args):
        """zoom(self, int zoomValue) -> bool"""
        return apply(_AriaPy.ArPTZ_zoom, args)

    def zoomRel(*args):
        """zoomRel(self, int zoomValue) -> bool"""
        return apply(_AriaPy.ArPTZ_zoomRel, args)

    def getPan(*args):
        """getPan(self) -> double"""
        return apply(_AriaPy.ArPTZ_getPan, args)

    def getTilt(*args):
        """getTilt(self) -> double"""
        return apply(_AriaPy.ArPTZ_getTilt, args)

    def getZoom(*args):
        """getZoom(self) -> int"""
        return apply(_AriaPy.ArPTZ_getZoom, args)

    def canGetRealPanTilt(*args):
        """canGetRealPanTilt(self) -> bool"""
        return apply(_AriaPy.ArPTZ_canGetRealPanTilt, args)

    def canGetRealZoom(*args):
        """canGetRealZoom(self) -> bool"""
        return apply(_AriaPy.ArPTZ_canGetRealZoom, args)

    def getMaxPosPan(*args):
        """getMaxPosPan(self) -> double"""
        return apply(_AriaPy.ArPTZ_getMaxPosPan, args)

    def getMaxNegPan(*args):
        """getMaxNegPan(self) -> double"""
        return apply(_AriaPy.ArPTZ_getMaxNegPan, args)

    def getMaxPosTilt(*args):
        """getMaxPosTilt(self) -> double"""
        return apply(_AriaPy.ArPTZ_getMaxPosTilt, args)

    def getMaxNegTilt(*args):
        """getMaxNegTilt(self) -> double"""
        return apply(_AriaPy.ArPTZ_getMaxNegTilt, args)

    def getMaxZoom(*args):
        """getMaxZoom(self) -> int"""
        return apply(_AriaPy.ArPTZ_getMaxZoom, args)

    def getMinZoom(*args):
        """getMinZoom(self) -> int"""
        return apply(_AriaPy.ArPTZ_getMinZoom, args)

    def canGetFOV(*args):
        """canGetFOV(self) -> bool"""
        return apply(_AriaPy.ArPTZ_canGetFOV, args)

    def getFOVAtMaxZoom(*args):
        """getFOVAtMaxZoom(self) -> double"""
        return apply(_AriaPy.ArPTZ_getFOVAtMaxZoom, args)

    def getFOVAtMinZoom(*args):
        """getFOVAtMinZoom(self) -> double"""
        return apply(_AriaPy.ArPTZ_getFOVAtMinZoom, args)

    def setGain(*args):
        """setGain(self, double gain) -> bool"""
        return apply(_AriaPy.ArPTZ_setGain, args)

    def getGain(*args):
        """getGain(self, double gain) -> double"""
        return apply(_AriaPy.ArPTZ_getGain, args)

    def canSetGain(*args):
        """canSetGain(self) -> bool"""
        return apply(_AriaPy.ArPTZ_canSetGain, args)

    def setFocus(*args):
        """setFocus(self, double focus) -> bool"""
        return apply(_AriaPy.ArPTZ_setFocus, args)

    def getFocus(*args):
        """getFocus(self, double focus) -> double"""
        return apply(_AriaPy.ArPTZ_getFocus, args)

    def canSetFocus(*args):
        """canSetFocus(self) -> bool"""
        return apply(_AriaPy.ArPTZ_canSetFocus, args)

    def setDeviceConnection(*args):
        """
        setDeviceConnection(self, ArDeviceConnection connection, bool driveFromRobotLoop=True) -> bool
        setDeviceConnection(self, ArDeviceConnection connection) -> bool
        """
        return apply(_AriaPy.ArPTZ_setDeviceConnection, args)

    def getDeviceConnection(*args):
        """getDeviceConnection(self) -> ArDeviceConnection"""
        return apply(_AriaPy.ArPTZ_getDeviceConnection, args)

    def setAuxPort(*args):
        """setAuxPort(self, int auxPort) -> bool"""
        return apply(_AriaPy.ArPTZ_setAuxPort, args)

    def getAuxPort(*args):
        """getAuxPort(self) -> int"""
        return apply(_AriaPy.ArPTZ_getAuxPort, args)

    def readPacket(*args):
        """readPacket(self) -> ArBasePacket"""
        return apply(_AriaPy.ArPTZ_readPacket, args)

    def sendPacket(*args):
        """sendPacket(self, ArBasePacket packet) -> bool"""
        return apply(_AriaPy.ArPTZ_sendPacket, args)

    def packetHandler(*args):
        """packetHandler(self, ArBasePacket packet) -> bool"""
        return apply(_AriaPy.ArPTZ_packetHandler, args)

    def robotPacketHandler(*args):
        """robotPacketHandler(self, ArRobotPacket packet) -> bool"""
        return apply(_AriaPy.ArPTZ_robotPacketHandler, args)

    def connectHandler(*args):
        """connectHandler(self)"""
        return apply(_AriaPy.ArPTZ_connectHandler, args)

    def sensorInterpHandler(*args):
        """sensorInterpHandler(self)"""
        return apply(_AriaPy.ArPTZ_sensorInterpHandler, args)

ArPTZ_swigregister = _AriaPy.ArPTZ_swigregister
ArPTZ_swigregister(ArPTZ)

class ArRangeDevice:
    """Proxy of C++ ArRangeDevice class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRangeDevice, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArRangeDevice, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, size_t currentBufferSize, size_t cumulativeBufferSize, 
            char name, unsigned int maxRange, int maxSecondsToKeepCurrent=0, 
            int maxSecondsToKeepCumulative=0, 
            double maxDistToKeepCumulative=0, 
            bool locationDependent=False) -> ArRangeDevice
        __init__(self, size_t currentBufferSize, size_t cumulativeBufferSize, 
            char name, unsigned int maxRange, int maxSecondsToKeepCurrent=0, 
            int maxSecondsToKeepCumulative=0, 
            double maxDistToKeepCumulative=0) -> ArRangeDevice
        __init__(self, size_t currentBufferSize, size_t cumulativeBufferSize, 
            char name, unsigned int maxRange, int maxSecondsToKeepCurrent=0, 
            int maxSecondsToKeepCumulative=0) -> ArRangeDevice
        __init__(self, size_t currentBufferSize, size_t cumulativeBufferSize, 
            char name, unsigned int maxRange, int maxSecondsToKeepCurrent=0) -> ArRangeDevice
        __init__(self, size_t currentBufferSize, size_t cumulativeBufferSize, 
            char name, unsigned int maxRange) -> ArRangeDevice
        """
        this = apply(_AriaPy.new_ArRangeDevice, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRangeDevice
    __del__ = lambda self : None;
    def getName(*args):
        """getName(self) -> char"""
        return apply(_AriaPy.ArRangeDevice_getName, args)

    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArRangeDevice_setRobot, args)

    def getRobot(*args):
        """getRobot(self) -> ArRobot"""
        return apply(_AriaPy.ArRangeDevice_getRobot, args)

    def setCurrentBufferSize(*args):
        """setCurrentBufferSize(self, size_t size)"""
        return apply(_AriaPy.ArRangeDevice_setCurrentBufferSize, args)

    def setCumulativeBufferSize(*args):
        """setCumulativeBufferSize(self, size_t size)"""
        return apply(_AriaPy.ArRangeDevice_setCumulativeBufferSize, args)

    def addReading(*args):
        """addReading(self, double x, double y)"""
        return apply(_AriaPy.ArRangeDevice_addReading, args)

    def isLocationDependent(*args):
        """isLocationDependent(self) -> bool"""
        return apply(_AriaPy.ArRangeDevice_isLocationDependent, args)

    def currentReadingPolar(*args):
        """
        currentReadingPolar(self, double startAngle, double endAngle, double angle=None) -> double
        currentReadingPolar(self, double startAngle, double endAngle) -> double
        """
        return apply(_AriaPy.ArRangeDevice_currentReadingPolar, args)

    def cumulativeReadingPolar(*args):
        """
        cumulativeReadingPolar(self, double startAngle, double endAngle, double angle=None) -> double
        cumulativeReadingPolar(self, double startAngle, double endAngle) -> double
        """
        return apply(_AriaPy.ArRangeDevice_cumulativeReadingPolar, args)

    def currentReadingBox(*args):
        """
        currentReadingBox(self, double x1, double y1, double x2, double y2, ArPose readingPos=None) -> double
        currentReadingBox(self, double x1, double y1, double x2, double y2) -> double
        """
        return apply(_AriaPy.ArRangeDevice_currentReadingBox, args)

    def cumulativeReadingBox(*args):
        """
        cumulativeReadingBox(self, double x1, double y1, double x2, double y2, ArPose readingPos=None) -> double
        cumulativeReadingBox(self, double x1, double y1, double x2, double y2) -> double
        """
        return apply(_AriaPy.ArRangeDevice_cumulativeReadingBox, args)

    def getCurrentRangeBuffer(*args):
        """getCurrentRangeBuffer(self) -> ArRangeBuffer"""
        return apply(_AriaPy.ArRangeDevice_getCurrentRangeBuffer, args)

    def getCumulativeRangeBuffer(*args):
        """getCumulativeRangeBuffer(self) -> ArRangeBuffer"""
        return apply(_AriaPy.ArRangeDevice_getCumulativeRangeBuffer, args)

    def getCurrentBuffer(*args):
        """getCurrentBuffer(self) -> ArPoseWithTimePtrList"""
        return apply(_AriaPy.ArRangeDevice_getCurrentBuffer, args)

    def getCurrentBufferAsVector(*args):
        """getCurrentBufferAsVector(self) -> ArPoseWithTimeVector"""
        return apply(_AriaPy.ArRangeDevice_getCurrentBufferAsVector, args)

    def getCumulativeBuffer(*args):
        """getCumulativeBuffer(self) -> ArPoseWithTimePtrList"""
        return apply(_AriaPy.ArRangeDevice_getCumulativeBuffer, args)

    def getCumulativeBufferAsVector(*args):
        """getCumulativeBufferAsVector(self) -> ArPoseWithTimeVector"""
        return apply(_AriaPy.ArRangeDevice_getCumulativeBufferAsVector, args)

    def getRawReadings(*args):
        """getRawReadings(self) -> std::list<(p.ArSensorReading,std::allocator<(p.ArSensorReading)>)>"""
        return apply(_AriaPy.ArRangeDevice_getRawReadings, args)

    def getRawReadingsAsVector(*args):
        """getRawReadingsAsVector(self) -> ArSensorReadingVector"""
        return apply(_AriaPy.ArRangeDevice_getRawReadingsAsVector, args)

    def getAdjustedRawReadings(*args):
        """getAdjustedRawReadings(self) -> std::list<(p.ArSensorReading,std::allocator<(p.ArSensorReading)>)>"""
        return apply(_AriaPy.ArRangeDevice_getAdjustedRawReadings, args)

    def getAdjustedRawReadingsAsVector(*args):
        """getAdjustedRawReadingsAsVector(self) -> ArSensorReadingVector"""
        return apply(_AriaPy.ArRangeDevice_getAdjustedRawReadingsAsVector, args)

    def setMaxSecondsToKeepCurrent(*args):
        """setMaxSecondsToKeepCurrent(self, int maxSecondsToKeepCurrent)"""
        return apply(_AriaPy.ArRangeDevice_setMaxSecondsToKeepCurrent, args)

    def getMaxSecondsToKeepCurrent(*args):
        """getMaxSecondsToKeepCurrent(self) -> int"""
        return apply(_AriaPy.ArRangeDevice_getMaxSecondsToKeepCurrent, args)

    def setMinDistBetweenCurrent(*args):
        """setMinDistBetweenCurrent(self, double minDistBetweenCurrent)"""
        return apply(_AriaPy.ArRangeDevice_setMinDistBetweenCurrent, args)

    def getMinDistBetweenCurrent(*args):
        """getMinDistBetweenCurrent(self) -> double"""
        return apply(_AriaPy.ArRangeDevice_getMinDistBetweenCurrent, args)

    def setMaxSecondsToKeepCumulative(*args):
        """setMaxSecondsToKeepCumulative(self, int maxSecondsToKeepCumulative)"""
        return apply(_AriaPy.ArRangeDevice_setMaxSecondsToKeepCumulative, args)

    def getMaxSecondsToKeepCumulative(*args):
        """getMaxSecondsToKeepCumulative(self) -> int"""
        return apply(_AriaPy.ArRangeDevice_getMaxSecondsToKeepCumulative, args)

    def setMaxDistToKeepCumulative(*args):
        """setMaxDistToKeepCumulative(self, double maxDistToKeepCumulative)"""
        return apply(_AriaPy.ArRangeDevice_setMaxDistToKeepCumulative, args)

    def getMaxDistToKeepCumulative(*args):
        """getMaxDistToKeepCumulative(self) -> double"""
        return apply(_AriaPy.ArRangeDevice_getMaxDistToKeepCumulative, args)

    def setMinDistBetweenCumulative(*args):
        """setMinDistBetweenCumulative(self, double minDistBetweenCumulative)"""
        return apply(_AriaPy.ArRangeDevice_setMinDistBetweenCumulative, args)

    def getMinDistBetweenCumulative(*args):
        """getMinDistBetweenCumulative(self) -> double"""
        return apply(_AriaPy.ArRangeDevice_getMinDistBetweenCumulative, args)

    def setMaxInsertDistCumulative(*args):
        """setMaxInsertDistCumulative(self, double maxInsertDistCumulative)"""
        return apply(_AriaPy.ArRangeDevice_setMaxInsertDistCumulative, args)

    def getMaxInsertDistCumulative(*args):
        """getMaxInsertDistCumulative(self) -> double"""
        return apply(_AriaPy.ArRangeDevice_getMaxInsertDistCumulative, args)

    def clearCurrentReadings(*args):
        """clearCurrentReadings(self)"""
        return apply(_AriaPy.ArRangeDevice_clearCurrentReadings, args)

    def clearCumulativeReadings(*args):
        """clearCumulativeReadings(self)"""
        return apply(_AriaPy.ArRangeDevice_clearCumulativeReadings, args)

    def clearCumulativeOlderThan(*args):
        """clearCumulativeOlderThan(self, int milliSeconds)"""
        return apply(_AriaPy.ArRangeDevice_clearCumulativeOlderThan, args)

    def clearCumulativeOlderThanSeconds(*args):
        """clearCumulativeOlderThanSeconds(self, int seconds)"""
        return apply(_AriaPy.ArRangeDevice_clearCumulativeOlderThanSeconds, args)

    def getMaxRange(*args):
        """getMaxRange(self) -> unsigned int"""
        return apply(_AriaPy.ArRangeDevice_getMaxRange, args)

    def setMaxRange(*args):
        """setMaxRange(self, unsigned int maxRange)"""
        return apply(_AriaPy.ArRangeDevice_setMaxRange, args)

    def applyTransform(*args):
        """
        applyTransform(self, ArTransform trans, bool doCumulative=True)
        applyTransform(self, ArTransform trans)
        """
        return apply(_AriaPy.ArRangeDevice_applyTransform, args)

    def getCurrentDrawingData(*args):
        """getCurrentDrawingData(self) -> ArDrawingData"""
        return apply(_AriaPy.ArRangeDevice_getCurrentDrawingData, args)

    def getCumulativeDrawingData(*args):
        """getCumulativeDrawingData(self) -> ArDrawingData"""
        return apply(_AriaPy.ArRangeDevice_getCumulativeDrawingData, args)

    def setCurrentDrawingData(*args):
        """setCurrentDrawingData(self, ArDrawingData data, bool takeOwnershipOfData)"""
        return apply(_AriaPy.ArRangeDevice_setCurrentDrawingData, args)

    def setCumulativeDrawingData(*args):
        """setCumulativeDrawingData(self, ArDrawingData data, bool takeOwnershipOfData)"""
        return apply(_AriaPy.ArRangeDevice_setCumulativeDrawingData, args)

    def lockDevice(*args):
        """lockDevice(self) -> int"""
        return apply(_AriaPy.ArRangeDevice_lockDevice, args)

    def tryLockDevice(*args):
        """tryLockDevice(self) -> int"""
        return apply(_AriaPy.ArRangeDevice_tryLockDevice, args)

    def unlockDevice(*args):
        """unlockDevice(self) -> int"""
        return apply(_AriaPy.ArRangeDevice_unlockDevice, args)

ArRangeDevice_swigregister = _AriaPy.ArRangeDevice_swigregister
ArRangeDevice_swigregister(ArRangeDevice)

class ArRangeDeviceThreaded(ArRangeDevice):
    """Proxy of C++ ArRangeDeviceThreaded class"""
    __swig_setmethods__ = {}
    for _s in [ArRangeDevice]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRangeDeviceThreaded, name, value)
    __swig_getmethods__ = {}
    for _s in [ArRangeDevice]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRangeDeviceThreaded, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArRangeDeviceThreaded
    __del__ = lambda self : None;
    def runThread(*args):
        """runThread(self, void arg) -> void"""
        return apply(_AriaPy.ArRangeDeviceThreaded_runThread, args)

    def run(*args):
        """run(self)"""
        return apply(_AriaPy.ArRangeDeviceThreaded_run, args)

    def runAsync(*args):
        """runAsync(self)"""
        return apply(_AriaPy.ArRangeDeviceThreaded_runAsync, args)

    def stopRunning(*args):
        """stopRunning(self)"""
        return apply(_AriaPy.ArRangeDeviceThreaded_stopRunning, args)

    def getRunning(*args):
        """getRunning(self) -> bool"""
        return apply(_AriaPy.ArRangeDeviceThreaded_getRunning, args)

    def getRunningWithLock(*args):
        """getRunningWithLock(self) -> bool"""
        return apply(_AriaPy.ArRangeDeviceThreaded_getRunningWithLock, args)

    def lockDevice(*args):
        """lockDevice(self) -> int"""
        return apply(_AriaPy.ArRangeDeviceThreaded_lockDevice, args)

    def tryLockDevice(*args):
        """tryLockDevice(self) -> int"""
        return apply(_AriaPy.ArRangeDeviceThreaded_tryLockDevice, args)

    def unlockDevice(*args):
        """unlockDevice(self) -> int"""
        return apply(_AriaPy.ArRangeDeviceThreaded_unlockDevice, args)

ArRangeDeviceThreaded_swigregister = _AriaPy.ArRangeDeviceThreaded_swigregister
ArRangeDeviceThreaded_swigregister(ArRangeDeviceThreaded)

class ArLaser(ArRangeDeviceThreaded):
    """Proxy of C++ ArLaser class"""
    __swig_setmethods__ = {}
    for _s in [ArRangeDeviceThreaded]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLaser, name, value)
    __swig_getmethods__ = {}
    for _s in [ArRangeDeviceThreaded]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArLaser, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArLaser
    __del__ = lambda self : None;
    def blockingConnect(*args):
        """blockingConnect(self) -> bool"""
        return apply(_AriaPy.ArLaser_blockingConnect, args)

    def asyncConnect(*args):
        """asyncConnect(self) -> bool"""
        return apply(_AriaPy.ArLaser_asyncConnect, args)

    def disconnect(*args):
        """disconnect(self) -> bool"""
        return apply(_AriaPy.ArLaser_disconnect, args)

    def isConnected(*args):
        """isConnected(self) -> bool"""
        return apply(_AriaPy.ArLaser_isConnected, args)

    def isTryingToConnect(*args):
        """isTryingToConnect(self) -> bool"""
        return apply(_AriaPy.ArLaser_isTryingToConnect, args)

    def setConnectionTimeoutSeconds(*args):
        """setConnectionTimeoutSeconds(self, double seconds)"""
        return apply(_AriaPy.ArLaser_setConnectionTimeoutSeconds, args)

    def getConnectionTimeoutSeconds(*args):
        """getConnectionTimeoutSeconds(self) -> double"""
        return apply(_AriaPy.ArLaser_getConnectionTimeoutSeconds, args)

    def getLastReadingTime(*args):
        """getLastReadingTime(self) -> ArTime"""
        return apply(_AriaPy.ArLaser_getLastReadingTime, args)

    def getReadingCount(*args):
        """getReadingCount(self) -> int"""
        return apply(_AriaPy.ArLaser_getReadingCount, args)

    def setDeviceConnection(*args):
        """setDeviceConnection(self, ArDeviceConnection conn)"""
        return apply(_AriaPy.ArLaser_setDeviceConnection, args)

    def getDeviceConnection(*args):
        """getDeviceConnection(self) -> ArDeviceConnection"""
        return apply(_AriaPy.ArLaser_getDeviceConnection, args)

    def setSensorPosition(*args):
        """
        setSensorPosition(self, double x, double y, double th)
        setSensorPosition(self, ArPose pose)
        """
        return apply(_AriaPy.ArLaser_setSensorPosition, args)

    def hasSensorPosition(*args):
        """hasSensorPosition(self) -> bool"""
        return apply(_AriaPy.ArLaser_hasSensorPosition, args)

    def getSensorPosition(*args):
        """getSensorPosition(self) -> ArPose"""
        return apply(_AriaPy.ArLaser_getSensorPosition, args)

    def getSensorPositionX(*args):
        """getSensorPositionX(self) -> double"""
        return apply(_AriaPy.ArLaser_getSensorPositionX, args)

    def getSensorPositionY(*args):
        """getSensorPositionY(self) -> double"""
        return apply(_AriaPy.ArLaser_getSensorPositionY, args)

    def getSensorPositionTh(*args):
        """getSensorPositionTh(self) -> double"""
        return apply(_AriaPy.ArLaser_getSensorPositionTh, args)

    def getLaserNumber(*args):
        """getLaserNumber(self) -> int"""
        return apply(_AriaPy.ArLaser_getLaserNumber, args)

    def setInfoLogLevel(*args):
        """setInfoLogLevel(self, LogLevel infoLogLevel)"""
        return apply(_AriaPy.ArLaser_setInfoLogLevel, args)

    def getInfoLogLevel(*args):
        """getInfoLogLevel(self) -> int"""
        return apply(_AriaPy.ArLaser_getInfoLogLevel, args)

    def setCumulativeCleanDist(*args):
        """setCumulativeCleanDist(self, double dist)"""
        return apply(_AriaPy.ArLaser_setCumulativeCleanDist, args)

    def getCumulativeCleanDist(*args):
        """getCumulativeCleanDist(self) -> double"""
        return apply(_AriaPy.ArLaser_getCumulativeCleanDist, args)

    def setCumulativeCleanInterval(*args):
        """setCumulativeCleanInterval(self, int milliSeconds)"""
        return apply(_AriaPy.ArLaser_setCumulativeCleanInterval, args)

    def getCumulativeCleanInterval(*args):
        """getCumulativeCleanInterval(self) -> int"""
        return apply(_AriaPy.ArLaser_getCumulativeCleanInterval, args)

    def setCumulativeCleanOffset(*args):
        """setCumulativeCleanOffset(self, int milliSeconds)"""
        return apply(_AriaPy.ArLaser_setCumulativeCleanOffset, args)

    def getCumulativeCleanOffset(*args):
        """getCumulativeCleanOffset(self) -> int"""
        return apply(_AriaPy.ArLaser_getCumulativeCleanOffset, args)

    def resetLastCumulativeCleanTime(*args):
        """resetLastCumulativeCleanTime(self)"""
        return apply(_AriaPy.ArLaser_resetLastCumulativeCleanTime, args)

    def addIgnoreReadings(*args):
        """addIgnoreReadings(self, char ignoreReadings) -> bool"""
        return apply(_AriaPy.ArLaser_addIgnoreReadings, args)

    def addIgnoreReading(*args):
        """addIgnoreReading(self, double ignoreReading)"""
        return apply(_AriaPy.ArLaser_addIgnoreReading, args)

    def clearIgnoreReadings(*args):
        """clearIgnoreReadings(self)"""
        return apply(_AriaPy.ArLaser_clearIgnoreReadings, args)

    def getIgnoreReadings(*args):
        """getIgnoreReadings(self) -> IntSet"""
        return apply(_AriaPy.ArLaser_getIgnoreReadings, args)

    def getFlipped(*args):
        """getFlipped(self) -> bool"""
        return apply(_AriaPy.ArLaser_getFlipped, args)

    def setFlipped(*args):
        """setFlipped(self, bool flipped) -> bool"""
        return apply(_AriaPy.ArLaser_setFlipped, args)

    def getDefaultTcpPort(*args):
        """getDefaultTcpPort(self) -> int"""
        return apply(_AriaPy.ArLaser_getDefaultTcpPort, args)

    def getDefaultPortType(*args):
        """getDefaultPortType(self) -> char"""
        return apply(_AriaPy.ArLaser_getDefaultPortType, args)

    def canSetDegrees(*args):
        """canSetDegrees(self) -> bool"""
        return apply(_AriaPy.ArLaser_canSetDegrees, args)

    def getStartDegreesMin(*args):
        """getStartDegreesMin(self) -> double"""
        return apply(_AriaPy.ArLaser_getStartDegreesMin, args)

    def getStartDegreesMax(*args):
        """getStartDegreesMax(self) -> double"""
        return apply(_AriaPy.ArLaser_getStartDegreesMax, args)

    def getStartDegrees(*args):
        """getStartDegrees(self) -> double"""
        return apply(_AriaPy.ArLaser_getStartDegrees, args)

    def setStartDegrees(*args):
        """setStartDegrees(self, double startDegrees) -> bool"""
        return apply(_AriaPy.ArLaser_setStartDegrees, args)

    def getEndDegreesMin(*args):
        """getEndDegreesMin(self) -> double"""
        return apply(_AriaPy.ArLaser_getEndDegreesMin, args)

    def getEndDegreesMax(*args):
        """getEndDegreesMax(self) -> double"""
        return apply(_AriaPy.ArLaser_getEndDegreesMax, args)

    def getEndDegrees(*args):
        """getEndDegrees(self) -> double"""
        return apply(_AriaPy.ArLaser_getEndDegrees, args)

    def setEndDegrees(*args):
        """setEndDegrees(self, double endDegrees) -> bool"""
        return apply(_AriaPy.ArLaser_setEndDegrees, args)

    def canChooseDegrees(*args):
        """canChooseDegrees(self) -> bool"""
        return apply(_AriaPy.ArLaser_canChooseDegrees, args)

    def getDegreesChoices(*args):
        """getDegreesChoices(self) -> std::list<(std::string,std::allocator<(std::string)>)>"""
        return apply(_AriaPy.ArLaser_getDegreesChoices, args)

    def getDegreesChoicesString(*args):
        """getDegreesChoicesString(self) -> char"""
        return apply(_AriaPy.ArLaser_getDegreesChoicesString, args)

    def chooseDegrees(*args):
        """chooseDegrees(self, char range) -> bool"""
        return apply(_AriaPy.ArLaser_chooseDegrees, args)

    def getDegreesChoice(*args):
        """getDegreesChoice(self) -> char"""
        return apply(_AriaPy.ArLaser_getDegreesChoice, args)

    def getDegreesChoiceDouble(*args):
        """getDegreesChoiceDouble(self) -> double"""
        return apply(_AriaPy.ArLaser_getDegreesChoiceDouble, args)

    def getDegreesChoicesMap(*args):
        """getDegreesChoicesMap(self) -> std::map<(std::string,double,std::less<(std::string)>,std::allocator<(std::pair<(q(const).std::string,double)>)>)>"""
        return apply(_AriaPy.ArLaser_getDegreesChoicesMap, args)

    def canSetIncrement(*args):
        """canSetIncrement(self) -> bool"""
        return apply(_AriaPy.ArLaser_canSetIncrement, args)

    def getIncrementMin(*args):
        """getIncrementMin(self) -> double"""
        return apply(_AriaPy.ArLaser_getIncrementMin, args)

    def getIncrementMax(*args):
        """getIncrementMax(self) -> double"""
        return apply(_AriaPy.ArLaser_getIncrementMax, args)

    def getIncrement(*args):
        """getIncrement(self) -> double"""
        return apply(_AriaPy.ArLaser_getIncrement, args)

    def setIncrement(*args):
        """setIncrement(self, double increment) -> bool"""
        return apply(_AriaPy.ArLaser_setIncrement, args)

    def canChooseIncrement(*args):
        """canChooseIncrement(self) -> bool"""
        return apply(_AriaPy.ArLaser_canChooseIncrement, args)

    def getIncrementChoices(*args):
        """getIncrementChoices(self) -> std::list<(std::string,std::allocator<(std::string)>)>"""
        return apply(_AriaPy.ArLaser_getIncrementChoices, args)

    def getIncrementChoicesString(*args):
        """getIncrementChoicesString(self) -> char"""
        return apply(_AriaPy.ArLaser_getIncrementChoicesString, args)

    def chooseIncrement(*args):
        """chooseIncrement(self, char increment) -> bool"""
        return apply(_AriaPy.ArLaser_chooseIncrement, args)

    def getIncrementChoice(*args):
        """getIncrementChoice(self) -> char"""
        return apply(_AriaPy.ArLaser_getIncrementChoice, args)

    def getIncrementChoiceDouble(*args):
        """getIncrementChoiceDouble(self) -> double"""
        return apply(_AriaPy.ArLaser_getIncrementChoiceDouble, args)

    def getIncrementChoicesMap(*args):
        """getIncrementChoicesMap(self) -> std::map<(std::string,double,std::less<(std::string)>,std::allocator<(std::pair<(q(const).std::string,double)>)>)>"""
        return apply(_AriaPy.ArLaser_getIncrementChoicesMap, args)

    def canChooseUnits(*args):
        """canChooseUnits(self) -> bool"""
        return apply(_AriaPy.ArLaser_canChooseUnits, args)

    def getUnitsChoices(*args):
        """getUnitsChoices(self) -> std::list<(std::string,std::allocator<(std::string)>)>"""
        return apply(_AriaPy.ArLaser_getUnitsChoices, args)

    def getUnitsChoicesString(*args):
        """getUnitsChoicesString(self) -> char"""
        return apply(_AriaPy.ArLaser_getUnitsChoicesString, args)

    def chooseUnits(*args):
        """chooseUnits(self, char units) -> bool"""
        return apply(_AriaPy.ArLaser_chooseUnits, args)

    def getUnitsChoice(*args):
        """getUnitsChoice(self) -> char"""
        return apply(_AriaPy.ArLaser_getUnitsChoice, args)

    def canChooseReflectorBits(*args):
        """canChooseReflectorBits(self) -> bool"""
        return apply(_AriaPy.ArLaser_canChooseReflectorBits, args)

    def getReflectorBitsChoices(*args):
        """getReflectorBitsChoices(self) -> std::list<(std::string,std::allocator<(std::string)>)>"""
        return apply(_AriaPy.ArLaser_getReflectorBitsChoices, args)

    def getReflectorBitsChoicesString(*args):
        """getReflectorBitsChoicesString(self) -> char"""
        return apply(_AriaPy.ArLaser_getReflectorBitsChoicesString, args)

    def chooseReflectorBits(*args):
        """chooseReflectorBits(self, char reflectorBits) -> bool"""
        return apply(_AriaPy.ArLaser_chooseReflectorBits, args)

    def getReflectorBitsChoice(*args):
        """getReflectorBitsChoice(self) -> char"""
        return apply(_AriaPy.ArLaser_getReflectorBitsChoice, args)

    def canSetPowerControlled(*args):
        """canSetPowerControlled(self) -> bool"""
        return apply(_AriaPy.ArLaser_canSetPowerControlled, args)

    def setPowerControlled(*args):
        """setPowerControlled(self, bool powerControlled) -> bool"""
        return apply(_AriaPy.ArLaser_setPowerControlled, args)

    def getPowerControlled(*args):
        """getPowerControlled(self) -> bool"""
        return apply(_AriaPy.ArLaser_getPowerControlled, args)

    def canChooseStartingBaud(*args):
        """canChooseStartingBaud(self) -> bool"""
        return apply(_AriaPy.ArLaser_canChooseStartingBaud, args)

    def getStartingBaudChoices(*args):
        """getStartingBaudChoices(self) -> std::list<(std::string,std::allocator<(std::string)>)>"""
        return apply(_AriaPy.ArLaser_getStartingBaudChoices, args)

    def getStartingBaudChoicesString(*args):
        """getStartingBaudChoicesString(self) -> char"""
        return apply(_AriaPy.ArLaser_getStartingBaudChoicesString, args)

    def chooseStartingBaud(*args):
        """chooseStartingBaud(self, char reflectorBits) -> bool"""
        return apply(_AriaPy.ArLaser_chooseStartingBaud, args)

    def getStartingBaudChoice(*args):
        """getStartingBaudChoice(self) -> char"""
        return apply(_AriaPy.ArLaser_getStartingBaudChoice, args)

    def canChooseAutoBaud(*args):
        """canChooseAutoBaud(self) -> bool"""
        return apply(_AriaPy.ArLaser_canChooseAutoBaud, args)

    def getAutoBaudChoices(*args):
        """getAutoBaudChoices(self) -> std::list<(std::string,std::allocator<(std::string)>)>"""
        return apply(_AriaPy.ArLaser_getAutoBaudChoices, args)

    def getAutoBaudChoicesString(*args):
        """getAutoBaudChoicesString(self) -> char"""
        return apply(_AriaPy.ArLaser_getAutoBaudChoicesString, args)

    def chooseAutoBaud(*args):
        """chooseAutoBaud(self, char reflectorBits) -> bool"""
        return apply(_AriaPy.ArLaser_chooseAutoBaud, args)

    def getAutoBaudChoice(*args):
        """getAutoBaudChoice(self) -> char"""
        return apply(_AriaPy.ArLaser_getAutoBaudChoice, args)

    def addConnectCB(*args):
        """
        addConnectCB(self, ArFunctor functor, int position=50)
        addConnectCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArLaser_addConnectCB, args)

    def remConnectCB(*args):
        """remConnectCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArLaser_remConnectCB, args)

    def addFailedConnectCB(*args):
        """
        addFailedConnectCB(self, ArFunctor functor, int position=50)
        addFailedConnectCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArLaser_addFailedConnectCB, args)

    def remFailedConnectCB(*args):
        """remFailedConnectCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArLaser_remFailedConnectCB, args)

    def addDisconnectNormallyCB(*args):
        """
        addDisconnectNormallyCB(self, ArFunctor functor, int position=50)
        addDisconnectNormallyCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArLaser_addDisconnectNormallyCB, args)

    def remDisconnectNormallyCB(*args):
        """remDisconnectNormallyCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArLaser_remDisconnectNormallyCB, args)

    def addDisconnectOnErrorCB(*args):
        """
        addDisconnectOnErrorCB(self, ArFunctor functor, int position=50)
        addDisconnectOnErrorCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArLaser_addDisconnectOnErrorCB, args)

    def remDisconnectOnErrorCB(*args):
        """remDisconnectOnErrorCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArLaser_remDisconnectOnErrorCB, args)

    def addReadingCB(*args):
        """
        addReadingCB(self, ArFunctor functor, int position=50)
        addReadingCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArLaser_addReadingCB, args)

    def remReadingCB(*args):
        """remReadingCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArLaser_remReadingCB, args)

    def getAbsoluteMaxRange(*args):
        """getAbsoluteMaxRange(self) -> unsigned int"""
        return apply(_AriaPy.ArLaser_getAbsoluteMaxRange, args)

    def setMaxRange(*args):
        """setMaxRange(self, unsigned int maxRange)"""
        return apply(_AriaPy.ArLaser_setMaxRange, args)

    def setCumulativeBufferSize(*args):
        """setCumulativeBufferSize(self, size_t size)"""
        return apply(_AriaPy.ArLaser_setCumulativeBufferSize, args)

    def laserCheckParams(*args):
        """laserCheckParams(self) -> bool"""
        return apply(_AriaPy.ArLaser_laserCheckParams, args)

    def applyTransform(*args):
        """
        applyTransform(self, ArTransform trans, bool doCumulative=True)
        applyTransform(self, ArTransform trans)
        """
        return apply(_AriaPy.ArLaser_applyTransform, args)

ArLaser_swigregister = _AriaPy.ArLaser_swigregister
ArLaser_swigregister(ArLaser)

class ArResolver:
    """Proxy of C++ ArResolver class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArResolver, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArResolver, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArResolver
    __del__ = lambda self : None;
    def resolve(*args):
        """
        resolve(self, ActionMap actions, ArRobot robot, bool logActions=False) -> ArActionDesired
        resolve(self, ActionMap actions, ArRobot robot) -> ArActionDesired
        """
        return apply(_AriaPy.ArResolver_resolve, args)

    def getName(*args):
        """getName(self) -> char"""
        return apply(_AriaPy.ArResolver_getName, args)

    def getDescription(*args):
        """getDescription(self) -> char"""
        return apply(_AriaPy.ArResolver_getDescription, args)

ArResolver_swigregister = _AriaPy.ArResolver_swigregister
ArResolver_swigregister(ArResolver)

class ArThread:
    """Proxy of C++ ArThread class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArThread, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArThread, name)
    __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__(self, bool blockAllSignals=True) -> ArThread
        __init__(self) -> ArThread
        __init__(self, ThreadType thread, bool joinable, bool blockAllSignals=True) -> ArThread
        __init__(self, ThreadType thread, bool joinable) -> ArThread
        __init__(self, ArFunctor func, bool joinable=True, bool blockAllSignals=True) -> ArThread
        __init__(self, ArFunctor func, bool joinable=True) -> ArThread
        __init__(self, ArFunctor func) -> ArThread
        """
        this = apply(_AriaPy.new_ArThread, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArThread
    __del__ = lambda self : None;
    __swig_getmethods__["init"] = lambda x: _AriaPy.ArThread_init
    __swig_getmethods__["self"] = lambda x: _AriaPy.ArThread_self
    __swig_getmethods__["osSelf"] = lambda x: _AriaPy.ArThread_osSelf
    __swig_getmethods__["stopAll"] = lambda x: _AriaPy.ArThread_stopAll
    __swig_getmethods__["cancelAll"] = lambda x: _AriaPy.ArThread_cancelAll
    __swig_getmethods__["joinAll"] = lambda x: _AriaPy.ArThread_joinAll
    __swig_getmethods__["yieldProcessor"] = lambda x: _AriaPy.ArThread_yieldProcessor
    __swig_getmethods__["getLogLevel"] = lambda x: _AriaPy.ArThread_getLogLevel
    __swig_getmethods__["setLogLevel"] = lambda x: _AriaPy.ArThread_setLogLevel
    def create(*args):
        """
        create(self, ArFunctor func, bool joinable=True, bool lowerPriority=True) -> int
        create(self, ArFunctor func, bool joinable=True) -> int
        create(self, ArFunctor func) -> int
        """
        return apply(_AriaPy.ArThread_create, args)

    def stopRunning(*args):
        """stopRunning(self)"""
        return apply(_AriaPy.ArThread_stopRunning, args)

    def join(*args):
        """
        join(self, void ret=None) -> int
        join(self) -> int
        """
        return apply(_AriaPy.ArThread_join, args)

    def detach(*args):
        """detach(self) -> int"""
        return apply(_AriaPy.ArThread_detach, args)

    def cancel(*args):
        """cancel(self)"""
        return apply(_AriaPy.ArThread_cancel, args)

    def getRunning(*args):
        """getRunning(self) -> bool"""
        return apply(_AriaPy.ArThread_getRunning, args)

    def getRunningWithLock(*args):
        """getRunningWithLock(self) -> bool"""
        return apply(_AriaPy.ArThread_getRunningWithLock, args)

    def getJoinable(*args):
        """getJoinable(self) -> bool"""
        return apply(_AriaPy.ArThread_getJoinable, args)

    def getThread(*args):
        """getThread(self) -> ThreadType"""
        return apply(_AriaPy.ArThread_getThread, args)

    def getOSThread(*args):
        """getOSThread(self) -> ThreadType"""
        return apply(_AriaPy.ArThread_getOSThread, args)

    def getFunc(*args):
        """getFunc(self) -> ArFunctor"""
        return apply(_AriaPy.ArThread_getFunc, args)

    def setRunning(*args):
        """setRunning(self, bool running)"""
        return apply(_AriaPy.ArThread_setRunning, args)

    def getBlockAllSignals(*args):
        """getBlockAllSignals(self) -> bool"""
        return apply(_AriaPy.ArThread_getBlockAllSignals, args)

    def getThreadName(*args):
        """getThreadName(self) -> char"""
        return apply(_AriaPy.ArThread_getThreadName, args)

    def setThreadName(*args):
        """setThreadName(self, char name)"""
        return apply(_AriaPy.ArThread_setThreadName, args)

    def getThreadActivity(*args):
        """getThreadActivity(self) -> char"""
        return apply(_AriaPy.ArThread_getThreadActivity, args)

    def threadStarted(*args):
        """threadStarted(self)"""
        return apply(_AriaPy.ArThread_threadStarted, args)

    def threadFinished(*args):
        """threadFinished(self)"""
        return apply(_AriaPy.ArThread_threadFinished, args)

    def isThreadStarted(*args):
        """isThreadStarted(self) -> bool"""
        return apply(_AriaPy.ArThread_isThreadStarted, args)

    def isThreadFinished(*args):
        """isThreadFinished(self) -> bool"""
        return apply(_AriaPy.ArThread_isThreadFinished, args)

    def logThreadInfo(*args):
        """logThreadInfo(self)"""
        return apply(_AriaPy.ArThread_logThreadInfo, args)

    def getPID(*args):
        """getPID(self) -> pid_t"""
        return apply(_AriaPy.ArThread_getPID, args)

    __swig_getmethods__["getThisThreadName"] = lambda x: _AriaPy.ArThread_getThisThreadName
    __swig_getmethods__["getThisThread"] = lambda x: _AriaPy.ArThread_getThisThread
    __swig_getmethods__["getThisOSThread"] = lambda x: _AriaPy.ArThread_getThisOSThread
ArThread_swigregister = _AriaPy.ArThread_swigregister
ArThread_swigregister(ArThread)

def ArThread_init(*args):
  """ArThread_init()"""
  return apply(_AriaPy.ArThread_init, args)

def ArThread_self(*args):
  """ArThread_self() -> ArThread"""
  return apply(_AriaPy.ArThread_self, args)

def ArThread_osSelf(*args):
  """ArThread_osSelf() -> ThreadType"""
  return apply(_AriaPy.ArThread_osSelf, args)

def ArThread_stopAll(*args):
  """ArThread_stopAll()"""
  return apply(_AriaPy.ArThread_stopAll, args)

def ArThread_cancelAll(*args):
  """ArThread_cancelAll()"""
  return apply(_AriaPy.ArThread_cancelAll, args)

def ArThread_joinAll(*args):
  """ArThread_joinAll()"""
  return apply(_AriaPy.ArThread_joinAll, args)

def ArThread_yieldProcessor(*args):
  """ArThread_yieldProcessor()"""
  return apply(_AriaPy.ArThread_yieldProcessor, args)

def ArThread_getLogLevel(*args):
  """ArThread_getLogLevel() -> int"""
  return apply(_AriaPy.ArThread_getLogLevel, args)

def ArThread_setLogLevel(*args):
  """ArThread_setLogLevel(LogLevel level)"""
  return apply(_AriaPy.ArThread_setLogLevel, args)

def ArThread_getThisThreadName(*args):
  """ArThread_getThisThreadName() -> char"""
  return apply(_AriaPy.ArThread_getThisThreadName, args)

def ArThread_getThisThread(*args):
  """ArThread_getThisThread() -> ThreadType"""
  return apply(_AriaPy.ArThread_getThisThread, args)

def ArThread_getThisOSThread(*args):
  """ArThread_getThisOSThread() -> ThreadType"""
  return apply(_AriaPy.ArThread_getThisOSThread, args)

class ArFunctor:
    """Proxy of C++ ArFunctor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArFunctor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArFunctor, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArFunctor
    __del__ = lambda self : None;
    def invoke(*args):
        """invoke(self)"""
        return apply(_AriaPy.ArFunctor_invoke, args)

    def getName(*args):
        """getName(self) -> char"""
        return apply(_AriaPy.ArFunctor_getName, args)

    def setName(*args):
        """setName(self, char name)"""
        return apply(_AriaPy.ArFunctor_setName, args)

ArFunctor_swigregister = _AriaPy.ArFunctor_swigregister
ArFunctor_swigregister(ArFunctor)

class ArRetFunctor_VoidP(ArFunctor):
    """Proxy of C++ ArRetFunctor_VoidP class"""
    __swig_setmethods__ = {}
    for _s in [ArFunctor]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRetFunctor_VoidP, name, value)
    __swig_getmethods__ = {}
    for _s in [ArFunctor]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRetFunctor_VoidP, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArRetFunctor_VoidP
    __del__ = lambda self : None;
    def invoke(*args):
        """invoke(self)"""
        return apply(_AriaPy.ArRetFunctor_VoidP_invoke, args)

    def invokeR(*args):
        """invokeR(self) -> void"""
        return apply(_AriaPy.ArRetFunctor_VoidP_invokeR, args)

ArRetFunctor_VoidP_swigregister = _AriaPy.ArRetFunctor_VoidP_swigregister
ArRetFunctor_VoidP_swigregister(ArRetFunctor_VoidP)

class ArRetFunctor_Bool(ArFunctor):
    """Proxy of C++ ArRetFunctor_Bool class"""
    __swig_setmethods__ = {}
    for _s in [ArFunctor]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRetFunctor_Bool, name, value)
    __swig_getmethods__ = {}
    for _s in [ArFunctor]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRetFunctor_Bool, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArRetFunctor_Bool
    __del__ = lambda self : None;
    def invoke(*args):
        """invoke(self)"""
        return apply(_AriaPy.ArRetFunctor_Bool_invoke, args)

    def invokeR(*args):
        """invokeR(self) -> bool"""
        return apply(_AriaPy.ArRetFunctor_Bool_invokeR, args)

ArRetFunctor_Bool_swigregister = _AriaPy.ArRetFunctor_Bool_swigregister
ArRetFunctor_Bool_swigregister(ArRetFunctor_Bool)

class ArFunctor1_CString(ArFunctor):
    """Proxy of C++ ArFunctor1_CString class"""
    __swig_setmethods__ = {}
    for _s in [ArFunctor]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArFunctor1_CString, name, value)
    __swig_getmethods__ = {}
    for _s in [ArFunctor]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArFunctor1_CString, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArFunctor1_CString
    __del__ = lambda self : None;
    def invoke(*args):
        """
        invoke(self)
        invoke(self, char p1)
        """
        return apply(_AriaPy.ArFunctor1_CString_invoke, args)

ArFunctor1_CString_swigregister = _AriaPy.ArFunctor1_CString_swigregister
ArFunctor1_CString_swigregister(ArFunctor1_CString)

class ArFunctor1_Int(ArFunctor):
    """Proxy of C++ ArFunctor1_Int class"""
    __swig_setmethods__ = {}
    for _s in [ArFunctor]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArFunctor1_Int, name, value)
    __swig_getmethods__ = {}
    for _s in [ArFunctor]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArFunctor1_Int, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArFunctor1_Int
    __del__ = lambda self : None;
    def invoke(*args):
        """
        invoke(self)
        invoke(self, int p1)
        """
        return apply(_AriaPy.ArFunctor1_Int_invoke, args)

ArFunctor1_Int_swigregister = _AriaPy.ArFunctor1_Int_swigregister
ArFunctor1_Int_swigregister(ArFunctor1_Int)

class ArFunctor1_ArRobotPacketP(ArFunctor):
    """Proxy of C++ ArFunctor1_ArRobotPacketP class"""
    __swig_setmethods__ = {}
    for _s in [ArFunctor]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArFunctor1_ArRobotPacketP, name, value)
    __swig_getmethods__ = {}
    for _s in [ArFunctor]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArFunctor1_ArRobotPacketP, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArFunctor1_ArRobotPacketP
    __del__ = lambda self : None;
    def invoke(*args):
        """
        invoke(self)
        invoke(self, ArRobotPacket p1)
        """
        return apply(_AriaPy.ArFunctor1_ArRobotPacketP_invoke, args)

ArFunctor1_ArRobotPacketP_swigregister = _AriaPy.ArFunctor1_ArRobotPacketP_swigregister
ArFunctor1_ArRobotPacketP_swigregister(ArFunctor1_ArRobotPacketP)

class ArRetFunctor_Int(ArFunctor):
    """Proxy of C++ ArRetFunctor_Int class"""
    __swig_setmethods__ = {}
    for _s in [ArFunctor]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRetFunctor_Int, name, value)
    __swig_getmethods__ = {}
    for _s in [ArFunctor]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRetFunctor_Int, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArRetFunctor_Int
    __del__ = lambda self : None;
    def invoke(*args):
        """invoke(self)"""
        return apply(_AriaPy.ArRetFunctor_Int_invoke, args)

    def invokeR(*args):
        """invokeR(self) -> int"""
        return apply(_AriaPy.ArRetFunctor_Int_invokeR, args)

ArRetFunctor_Int_swigregister = _AriaPy.ArRetFunctor_Int_swigregister
ArRetFunctor_Int_swigregister(ArRetFunctor_Int)

class ArRetFunctor_Double(ArFunctor):
    """Proxy of C++ ArRetFunctor_Double class"""
    __swig_setmethods__ = {}
    for _s in [ArFunctor]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRetFunctor_Double, name, value)
    __swig_getmethods__ = {}
    for _s in [ArFunctor]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRetFunctor_Double, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArRetFunctor_Double
    __del__ = lambda self : None;
    def invoke(*args):
        """invoke(self)"""
        return apply(_AriaPy.ArRetFunctor_Double_invoke, args)

    def invokeR(*args):
        """invokeR(self) -> double"""
        return apply(_AriaPy.ArRetFunctor_Double_invokeR, args)

ArRetFunctor_Double_swigregister = _AriaPy.ArRetFunctor_Double_swigregister
ArRetFunctor_Double_swigregister(ArRetFunctor_Double)

class ArRetFunctor_UnsignedInt(ArFunctor):
    """Proxy of C++ ArRetFunctor_UnsignedInt class"""
    __swig_setmethods__ = {}
    for _s in [ArFunctor]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRetFunctor_UnsignedInt, name, value)
    __swig_getmethods__ = {}
    for _s in [ArFunctor]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRetFunctor_UnsignedInt, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArRetFunctor_UnsignedInt
    __del__ = lambda self : None;
    def invoke(*args):
        """invoke(self)"""
        return apply(_AriaPy.ArRetFunctor_UnsignedInt_invoke, args)

    def invokeR(*args):
        """invokeR(self) -> unsigned int"""
        return apply(_AriaPy.ArRetFunctor_UnsignedInt_invokeR, args)

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"""
    __swig_setmethods__ = {}
    for _s in [ArRetFunctor_Double]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRetFunctor1_Double_ArPoseWithTime, name, value)
    __swig_getmethods__ = {}
    for _s in [ArRetFunctor_Double]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRetFunctor1_Double_ArPoseWithTime, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArRetFunctor1_Double_ArPoseWithTime
    __del__ = lambda self : None;
    def invokeR(*args):
        """
        invokeR(self) -> double
        invokeR(self, ArPoseWithTime p1) -> double
        """
        return apply(_AriaPy.ArRetFunctor1_Double_ArPoseWithTime_invokeR, 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_ArRobotPacketP class"""
    __swig_setmethods__ = {}
    for _s in [ArRetFunctor_Bool]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRetFunctor1_Bool_ArRobotPacketP, name, value)
    __swig_getmethods__ = {}
    for _s in [ArRetFunctor_Bool]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRetFunctor1_Bool_ArRobotPacketP, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArRetFunctor1_Bool_ArRobotPacketP
    __del__ = lambda self : None;
    def invokeR(*args):
        """
        invokeR(self) -> bool
        invokeR(self, ArRobotPacket p1) -> bool
        """
        return apply(_AriaPy.ArRetFunctor1_Bool_ArRobotPacketP_invokeR, 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_ArgumentBuilder class"""
    __swig_setmethods__ = {}
    for _s in [ArRetFunctor_Bool]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRetFunctor1_Bool_ArgumentBuilder, name, value)
    __swig_getmethods__ = {}
    for _s in [ArRetFunctor_Bool]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRetFunctor1_Bool_ArgumentBuilder, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArRetFunctor1_Bool_ArgumentBuilder
    __del__ = lambda self : None;
    def invokeR(*args):
        """
        invokeR(self) -> bool
        invokeR(self, ArArgumentBuilder p1) -> bool
        """
        return apply(_AriaPy.ArRetFunctor1_Bool_ArgumentBuilder_invokeR, 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_ArgumentBuilderP class"""
    __swig_setmethods__ = {}
    for _s in [ArRetFunctor_Bool]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRetFunctor1_Bool_ArgumentBuilderP, name, value)
    __swig_getmethods__ = {}
    for _s in [ArRetFunctor_Bool]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRetFunctor1_Bool_ArgumentBuilderP, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArRetFunctor1_Bool_ArgumentBuilderP
    __del__ = lambda self : None;
    def invokeR(*args):
        """
        invokeR(self) -> bool
        invokeR(self, ArArgumentBuilder p1) -> bool
        """
        return apply(_AriaPy.ArRetFunctor1_Bool_ArgumentBuilderP_invokeR, 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_VoidP_VoidP class"""
    __swig_setmethods__ = {}
    for _s in [ArRetFunctor_VoidP]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRetFunctor1_VoidP_VoidP, name, value)
    __swig_getmethods__ = {}
    for _s in [ArRetFunctor_VoidP]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRetFunctor1_VoidP_VoidP, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArRetFunctor1_VoidP_VoidP
    __del__ = lambda self : None;
    def invokeR(*args):
        """
        invokeR(self) -> void
        invokeR(self, void p1) -> void
        """
        return apply(_AriaPy.ArRetFunctor1_VoidP_VoidP_invokeR, args)

ArRetFunctor1_VoidP_VoidP_swigregister = _AriaPy.ArRetFunctor1_VoidP_VoidP_swigregister
ArRetFunctor1_VoidP_VoidP_swigregister(ArRetFunctor1_VoidP_VoidP)

class ArACTSBlob:
    """Proxy of C++ ArACTSBlob class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArACTSBlob, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArACTSBlob, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArACTSBlob"""
        this = apply(_AriaPy.new_ArACTSBlob, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArACTSBlob
    __del__ = lambda self : None;
    def getArea(*args):
        """getArea(self) -> int"""
        return apply(_AriaPy.ArACTSBlob_getArea, args)

    def getXCG(*args):
        """getXCG(self) -> int"""
        return apply(_AriaPy.ArACTSBlob_getXCG, args)

    def getYCG(*args):
        """getYCG(self) -> int"""
        return apply(_AriaPy.ArACTSBlob_getYCG, args)

    def getLeft(*args):
        """getLeft(self) -> int"""
        return apply(_AriaPy.ArACTSBlob_getLeft, args)

    def getRight(*args):
        """getRight(self) -> int"""
        return apply(_AriaPy.ArACTSBlob_getRight, args)

    def getTop(*args):
        """getTop(self) -> int"""
        return apply(_AriaPy.ArACTSBlob_getTop, args)

    def getBottom(*args):
        """getBottom(self) -> int"""
        return apply(_AriaPy.ArACTSBlob_getBottom, args)

    def setArea(*args):
        """setArea(self, int area)"""
        return apply(_AriaPy.ArACTSBlob_setArea, args)

    def setXCG(*args):
        """setXCG(self, int xcg)"""
        return apply(_AriaPy.ArACTSBlob_setXCG, args)

    def setYCG(*args):
        """setYCG(self, int ycg)"""
        return apply(_AriaPy.ArACTSBlob_setYCG, args)

    def setLeft(*args):
        """setLeft(self, int left)"""
        return apply(_AriaPy.ArACTSBlob_setLeft, args)

    def setRight(*args):
        """setRight(self, int right)"""
        return apply(_AriaPy.ArACTSBlob_setRight, args)

    def setTop(*args):
        """setTop(self, int top)"""
        return apply(_AriaPy.ArACTSBlob_setTop, args)

    def setBottom(*args):
        """setBottom(self, int bottom)"""
        return apply(_AriaPy.ArACTSBlob_setBottom, args)

    def log(*args):
        """log(self)"""
        return apply(_AriaPy.ArACTSBlob_log, args)

ArACTSBlob_swigregister = _AriaPy.ArACTSBlob_swigregister
ArACTSBlob_swigregister(ArACTSBlob)

class ArACTS_1_2:
    """Proxy of C++ ArACTS_1_2 class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArACTS_1_2, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArACTS_1_2, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArACTS_1_2"""
        this = apply(_AriaPy.new_ArACTS_1_2, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArACTS_1_2
    __del__ = lambda self : None;
    def openPort(*args):
        """
        openPort(self, ArRobot robot, char host="localhost", int port=5001) -> bool
        openPort(self, ArRobot robot, char host="localhost") -> bool
        openPort(self, ArRobot robot) -> bool
        """
        return apply(_AriaPy.ArACTS_1_2_openPort, args)

    def closePort(*args):
        """closePort(self) -> bool"""
        return apply(_AriaPy.ArACTS_1_2_closePort, args)

    def isConnected(*args):
        """isConnected(self) -> bool"""
        return apply(_AriaPy.ArACTS_1_2_isConnected, args)

    def getRobot(*args):
        """getRobot(self) -> ArRobot"""
        return apply(_AriaPy.ArACTS_1_2_getRobot, args)

    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArACTS_1_2_setRobot, args)

    def requestPacket(*args):
        """requestPacket(self) -> bool"""
        return apply(_AriaPy.ArACTS_1_2_requestPacket, args)

    def requestQuit(*args):
        """requestQuit(self) -> bool"""
        return apply(_AriaPy.ArACTS_1_2_requestQuit, args)

    def receiveBlobInfo(*args):
        """receiveBlobInfo(self) -> bool"""
        return apply(_AriaPy.ArACTS_1_2_receiveBlobInfo, args)

    def getNumBlobs(*args):
        """getNumBlobs(self, int channel) -> int"""
        return apply(_AriaPy.ArACTS_1_2_getNumBlobs, args)

    def getBlob(*args):
        """getBlob(self, int channel, int blobNumber, ArACTSBlob blob) -> bool"""
        return apply(_AriaPy.ArACTS_1_2_getBlob, args)

    def actsHandler(*args):
        """actsHandler(self)"""
        return apply(_AriaPy.ArACTS_1_2_actsHandler, args)

    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(*args):
        """
        invert(self, int width=160, int height=120)
        invert(self, int width=160)
        invert(self)
        """
        return apply(_AriaPy.ArACTS_1_2_invert, args)

ArACTS_1_2_swigregister = _AriaPy.ArACTS_1_2_swigregister
ArACTS_1_2_swigregister(ArACTS_1_2)

class ArAMPTUCommands:
    """Proxy of C++ ArAMPTUCommands class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArAMPTUCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArAMPTUCommands, name)
    __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, *args): 
        """__init__(self) -> ArAMPTUCommands"""
        this = apply(_AriaPy.new_ArAMPTUCommands, args)
        try: self.this.append(this)
        except: 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"""
    __swig_setmethods__ = {}
    for _s in [ArBasePacket]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArAMPTUPacket, name, value)
    __swig_getmethods__ = {}
    for _s in [ArBasePacket]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArAMPTUPacket, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, UByte2 bufferSize=30) -> ArAMPTUPacket
        __init__(self) -> ArAMPTUPacket
        """
        this = apply(_AriaPy.new_ArAMPTUPacket, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArAMPTUPacket
    __del__ = lambda self : None;
    def getUnitNumber(*args):
        """getUnitNumber(self) -> unsigned char"""
        return apply(_AriaPy.ArAMPTUPacket_getUnitNumber, args)

    def setUnitNumber(*args):
        """setUnitNumber(self, unsigned char unitNumber) -> bool"""
        return apply(_AriaPy.ArAMPTUPacket_setUnitNumber, args)

    def byteToBuf(*args):
        """byteToBuf(self, Byte val)"""
        return apply(_AriaPy.ArAMPTUPacket_byteToBuf, args)

    def byte2ToBuf(*args):
        """byte2ToBuf(self, Byte2 val)"""
        return apply(_AriaPy.ArAMPTUPacket_byte2ToBuf, args)

    def finalizePacket(*args):
        """finalizePacket(self)"""
        return apply(_AriaPy.ArAMPTUPacket_finalizePacket, args)

ArAMPTUPacket_swigregister = _AriaPy.ArAMPTUPacket_swigregister
ArAMPTUPacket_swigregister(ArAMPTUPacket)

class ArAMPTU(ArPTZ):
    """Proxy of C++ ArAMPTU class"""
    __swig_setmethods__ = {}
    for _s in [ArPTZ]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArAMPTU, name, value)
    __swig_getmethods__ = {}
    for _s in [ArPTZ]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArAMPTU, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, int unitNumber=0) -> ArAMPTU
        __init__(self, ArRobot robot) -> ArAMPTU
        """
        this = apply(_AriaPy.new_ArAMPTU, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArAMPTU
    __del__ = lambda self : None;
    def init(*args):
        """init(self) -> bool"""
        return apply(_AriaPy.ArAMPTU_init, args)

    def pan(*args):
        """pan(self, double deg) -> bool"""
        return apply(_AriaPy.ArAMPTU_pan, args)

    def panRel(*args):
        """panRel(self, double deg) -> bool"""
        return apply(_AriaPy.ArAMPTU_panRel, args)

    def tilt(*args):
        """tilt(self, double deg) -> bool"""
        return apply(_AriaPy.ArAMPTU_tilt, args)

    def tiltRel(*args):
        """tiltRel(self, double deg) -> bool"""
        return apply(_AriaPy.ArAMPTU_tiltRel, args)

    def panTilt(*args):
        """panTilt(self, double panDeg, double tiltDeg) -> bool"""
        return apply(_AriaPy.ArAMPTU_panTilt, args)

    def panTiltRel(*args):
        """panTiltRel(self, double panDeg, double tiltDeg) -> bool"""
        return apply(_AriaPy.ArAMPTU_panTiltRel, args)

    def panSlew(*args):
        """panSlew(self, double deg) -> bool"""
        return apply(_AriaPy.ArAMPTU_panSlew, args)

    def tiltSlew(*args):
        """tiltSlew(self, double deg) -> bool"""
        return apply(_AriaPy.ArAMPTU_tiltSlew, args)

    def canZoom(*args):
        """canZoom(self) -> bool"""
        return apply(_AriaPy.ArAMPTU_canZoom, args)

    def getMaxPosPan(*args):
        """getMaxPosPan(self) -> double"""
        return apply(_AriaPy.ArAMPTU_getMaxPosPan, args)

    def getMaxNegPan(*args):
        """getMaxNegPan(self) -> double"""
        return apply(_AriaPy.ArAMPTU_getMaxNegPan, args)

    def getMaxPosTilt(*args):
        """getMaxPosTilt(self) -> double"""
        return apply(_AriaPy.ArAMPTU_getMaxPosTilt, args)

    def getMaxNegTilt(*args):
        """getMaxNegTilt(self) -> double"""
        return apply(_AriaPy.ArAMPTU_getMaxNegTilt, args)

    def pause(*args):
        """pause(self) -> bool"""
        return apply(_AriaPy.ArAMPTU_pause, args)

    def resume(*args):
        """resume(self) -> bool"""
        return apply(_AriaPy.ArAMPTU_resume, args)

    def purge(*args):
        """purge(self) -> bool"""
        return apply(_AriaPy.ArAMPTU_purge, args)

    def requestStatus(*args):
        """requestStatus(self) -> bool"""
        return apply(_AriaPy.ArAMPTU_requestStatus, args)

    def getPan(*args):
        """getPan(self) -> double"""
        return apply(_AriaPy.ArAMPTU_getPan, args)

    def getTilt(*args):
        """getTilt(self) -> double"""
        return apply(_AriaPy.ArAMPTU_getTilt, args)

    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"""
    __swig_setmethods__ = {}
    for _s in [ArThread]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArASyncTask, name, value)
    __swig_getmethods__ = {}
    for _s in [ArThread]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArASyncTask, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArASyncTask
    __del__ = lambda self : None;
    def runThread(*args):
        """runThread(self, void arg) -> void"""
        return apply(_AriaPy.ArASyncTask_runThread, args)

    def run(*args):
        """run(self)"""
        return apply(_AriaPy.ArASyncTask_run, args)

    def runAsync(*args):
        """runAsync(self)"""
        return apply(_AriaPy.ArASyncTask_runAsync, args)

    def stopRunning(*args):
        """stopRunning(self)"""
        return apply(_AriaPy.ArASyncTask_stopRunning, args)

    def create(*args):
        """
        create(self, bool joinable=True, bool lowerPriority=True) -> int
        create(self, bool joinable=True) -> int
        create(self) -> int
        """
        return apply(_AriaPy.ArASyncTask_create, args)

    def runInThisThread(*args):
        """
        runInThisThread(self, void arg=0)
        runInThisThread(self) -> void
        """
        return apply(_AriaPy.ArASyncTask_runInThisThread, args)

    def getThreadActivity(*args):
        """getThreadActivity(self) -> char"""
        return apply(_AriaPy.ArASyncTask_getThreadActivity, args)

ArASyncTask_swigregister = _AriaPy.ArASyncTask_swigregister
ArASyncTask_swigregister(ArASyncTask)

class ArAction:
    """Proxy of C++ ArAction class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArAction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArAction, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name, char description="") -> ArAction
        __init__(self, char name) -> ArAction
        """
        if self.__class__ == ArAction:
            args = (None,) + args
        else:
            args = (self,) + args
        this = apply(_AriaPy.new_ArAction, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArAction
    __del__ = lambda self : None;
    def isActive(*args):
        """isActive(self) -> bool"""
        return apply(_AriaPy.ArAction_isActive, args)

    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArAction_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArAction_deactivate, args)

    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArAction_fire, args)

    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArAction_setRobot, args)

    def getNumArgs(*args):
        """getNumArgs(self) -> int"""
        return apply(_AriaPy.ArAction_getNumArgs, args)

    def getArg(*args):
        """getArg(self, int number) -> ArArg"""
        return apply(_AriaPy.ArAction_getArg, args)

    def getName(*args):
        """getName(self) -> char"""
        return apply(_AriaPy.ArAction_getName, args)

    def getDescription(*args):
        """getDescription(self) -> char"""
        return apply(_AriaPy.ArAction_getDescription, args)

    def getDesired(*args):
        """
        getDesired(self) -> ArActionDesired
        getDesired(self) -> ArActionDesired
        """
        return apply(_AriaPy.ArAction_getDesired, args)

    def log(*args):
        """
        log(self, bool verbose=True)
        log(self)
        """
        return apply(_AriaPy.ArAction_log, args)

    def getRobot(*args):
        """getRobot(self) -> ArRobot"""
        return apply(_AriaPy.ArAction_getRobot, args)

    __swig_getmethods__["setDefaultActivationState"] = lambda x: _AriaPy.ArAction_setDefaultActivationState
    __swig_getmethods__["getDefaultActivationState"] = lambda x: _AriaPy.ArAction_getDefaultActivationState
    def setActionRobot(*args):
        """setActionRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArAction_setActionRobot, args)

    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(*args):
  """ArAction_setDefaultActivationState(bool defaultActivationState)"""
  return apply(_AriaPy.ArAction_setDefaultActivationState, args)

def ArAction_getDefaultActivationState(*args):
  """ArAction_getDefaultActivationState() -> bool"""
  return apply(_AriaPy.ArAction_getDefaultActivationState, args)

class ArActionAvoidFront(ArAction):
    """Proxy of C++ ArActionAvoidFront class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionAvoidFront, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionAvoidFront, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="avoid front obstacles", double obstacleDistance=450, 
            double avoidVelocity=200, double turnAmount=15, 
            bool useTableIRIfAvail=True) -> ArActionAvoidFront
        __init__(self, char name="avoid front obstacles", double obstacleDistance=450, 
            double avoidVelocity=200, double turnAmount=15) -> ArActionAvoidFront
        __init__(self, char name="avoid front obstacles", double obstacleDistance=450, 
            double avoidVelocity=200) -> ArActionAvoidFront
        __init__(self, char name="avoid front obstacles", double obstacleDistance=450) -> ArActionAvoidFront
        __init__(self, char name="avoid front obstacles") -> ArActionAvoidFront
        __init__(self) -> ArActionAvoidFront
        """
        this = apply(_AriaPy.new_ArActionAvoidFront, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionAvoidFront
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionAvoidFront_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionAvoidFront_getDesired, args)

ArActionAvoidFront_swigregister = _AriaPy.ArActionAvoidFront_swigregister
ArActionAvoidFront_swigregister(ArActionAvoidFront)

class ArActionAvoidSide(ArAction):
    """Proxy of C++ ArActionAvoidSide class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionAvoidSide, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionAvoidSide, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="Avoid side", double obstacleDistance=300, 
            double turnAmount=5) -> ArActionAvoidSide
        __init__(self, char name="Avoid side", double obstacleDistance=300) -> ArActionAvoidSide
        __init__(self, char name="Avoid side") -> ArActionAvoidSide
        __init__(self) -> ArActionAvoidSide
        """
        this = apply(_AriaPy.new_ArActionAvoidSide, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionAvoidSide
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionAvoidSide_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionAvoidSide_getDesired, args)

ArActionAvoidSide_swigregister = _AriaPy.ArActionAvoidSide_swigregister
ArActionAvoidSide_swigregister(ArActionAvoidSide)

class ArActionBumpers(ArAction):
    """Proxy of C++ ArActionBumpers class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionBumpers, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionBumpers, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="bumpers", double backOffSpeed=100, int backOffTime=3000, 
            int turnTime=3000, bool setMaximums=False) -> ArActionBumpers
        __init__(self, char name="bumpers", double backOffSpeed=100, int backOffTime=3000, 
            int turnTime=3000) -> ArActionBumpers
        __init__(self, char name="bumpers", double backOffSpeed=100, int backOffTime=3000) -> ArActionBumpers
        __init__(self, char name="bumpers", double backOffSpeed=100) -> ArActionBumpers
        __init__(self, char name="bumpers") -> ArActionBumpers
        __init__(self) -> ArActionBumpers
        """
        this = apply(_AriaPy.new_ArActionBumpers, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionBumpers
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionBumpers_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionBumpers_getDesired, args)

    def findDegreesToTurn(*args):
        """findDegreesToTurn(self, int bumpValue, int whichBumper) -> double"""
        return apply(_AriaPy.ArActionBumpers_findDegreesToTurn, args)

ArActionBumpers_swigregister = _AriaPy.ArActionBumpers_swigregister
ArActionBumpers_swigregister(ArActionBumpers)

class ArActionColorFollow(ArAction):
    """Proxy of C++ ArActionColorFollow class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionColorFollow, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionColorFollow, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name, ArACTS_1_2 acts, ArPTZ camera, double speed=200, 
            int width=160, int height=120) -> ArActionColorFollow
        __init__(self, char name, ArACTS_1_2 acts, ArPTZ camera, double speed=200, 
            int width=160) -> ArActionColorFollow
        __init__(self, char name, ArACTS_1_2 acts, ArPTZ camera, double speed=200) -> ArActionColorFollow
        __init__(self, char name, ArACTS_1_2 acts, ArPTZ camera) -> ArActionColorFollow
        """
        this = apply(_AriaPy.new_ArActionColorFollow, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionColorFollow
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionColorFollow_fire, args)

    def setChannel(*args):
        """setChannel(self, int channel) -> bool"""
        return apply(_AriaPy.ArActionColorFollow_setChannel, args)

    def setCamera(*args):
        """setCamera(self, ArPTZ camera)"""
        return apply(_AriaPy.ArActionColorFollow_setCamera, args)

    def setAcquire(*args):
        """setAcquire(self, bool acquire)"""
        return apply(_AriaPy.ArActionColorFollow_setAcquire, args)

    def stopMovement(*args):
        """stopMovement(self)"""
        return apply(_AriaPy.ArActionColorFollow_stopMovement, args)

    def startMovement(*args):
        """startMovement(self)"""
        return apply(_AriaPy.ArActionColorFollow_startMovement, args)

    def getChannel(*args):
        """getChannel(self) -> int"""
        return apply(_AriaPy.ArActionColorFollow_getChannel, args)

    def getAcquire(*args):
        """getAcquire(self) -> bool"""
        return apply(_AriaPy.ArActionColorFollow_getAcquire, args)

    def getMovement(*args):
        """getMovement(self) -> bool"""
        return apply(_AriaPy.ArActionColorFollow_getMovement, args)

    def getBlob(*args):
        """getBlob(self) -> bool"""
        return apply(_AriaPy.ArActionColorFollow_getBlob, args)

    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(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionColorFollow_getDesired, args)

ArActionColorFollow_swigregister = _AriaPy.ArActionColorFollow_swigregister
ArActionColorFollow_swigregister(ArActionColorFollow)

class ArActionConstantVelocity(ArAction):
    """Proxy of C++ ArActionConstantVelocity class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionConstantVelocity, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionConstantVelocity, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="Constant Velocity", double velocity=400) -> ArActionConstantVelocity
        __init__(self, char name="Constant Velocity") -> ArActionConstantVelocity
        __init__(self) -> ArActionConstantVelocity
        """
        this = apply(_AriaPy.new_ArActionConstantVelocity, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionConstantVelocity
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionConstantVelocity_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionConstantVelocity_getDesired, args)

ArActionConstantVelocity_swigregister = _AriaPy.ArActionConstantVelocity_swigregister
ArActionConstantVelocity_swigregister(ArActionConstantVelocity)

class ArActionDeceleratingLimiter(ArAction):
    """Proxy of C++ ArActionDeceleratingLimiter class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionDeceleratingLimiter, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionDeceleratingLimiter, name)
    __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__(self, char name="limitAndDecel", LimiterType type=FORWARDS) -> ArActionDeceleratingLimiter
        __init__(self, char name="limitAndDecel") -> ArActionDeceleratingLimiter
        __init__(self) -> ArActionDeceleratingLimiter
        """
        this = apply(_AriaPy.new_ArActionDeceleratingLimiter, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionDeceleratingLimiter
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionDeceleratingLimiter_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionDeceleratingLimiter_getDesired, args)

    def setParameters(*args):
        """
        setParameters(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(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(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(self, double clearance=100, double sideClearanceAtSlowSpeed=50, 
            double paddingAtSlowSpeed=50, double slowSpeed=200, 
            double sideClearanceAtFastSpeed=400, 
            double paddingAtFastSpeed=300, double fastSpeed=1000)
        setParameters(self, double clearance=100, double sideClearanceAtSlowSpeed=50, 
            double paddingAtSlowSpeed=50, double slowSpeed=200, 
            double sideClearanceAtFastSpeed=400, 
            double paddingAtFastSpeed=300)
        setParameters(self, double clearance=100, double sideClearanceAtSlowSpeed=50, 
            double paddingAtSlowSpeed=50, double slowSpeed=200, 
            double sideClearanceAtFastSpeed=400)
        setParameters(self, double clearance=100, double sideClearanceAtSlowSpeed=50, 
            double paddingAtSlowSpeed=50, double slowSpeed=200)
        setParameters(self, double clearance=100, double sideClearanceAtSlowSpeed=50, 
            double paddingAtSlowSpeed=50)
        setParameters(self, double clearance=100, double sideClearanceAtSlowSpeed=50)
        setParameters(self, double clearance=100)
        setParameters(self)
        """
        return apply(_AriaPy.ArActionDeceleratingLimiter_setParameters, args)

    def getType(*args):
        """getType(self) -> int"""
        return apply(_AriaPy.ArActionDeceleratingLimiter_getType, args)

    def setType(*args):
        """setType(self, LimiterType type)"""
        return apply(_AriaPy.ArActionDeceleratingLimiter_setType, args)

    def addToConfig(*args):
        """
        addToConfig(self, ArConfig config, char section, char prefix=None)
        addToConfig(self, ArConfig config, char section)
        """
        return apply(_AriaPy.ArActionDeceleratingLimiter_addToConfig, args)

    def getUseLocationDependentDevices(*args):
        """getUseLocationDependentDevices(self) -> bool"""
        return apply(_AriaPy.ArActionDeceleratingLimiter_getUseLocationDependentDevices, args)

    def setUseLocationDependentDevices(*args):
        """setUseLocationDependentDevices(self, bool useLocationDependentDevices)"""
        return apply(_AriaPy.ArActionDeceleratingLimiter_setUseLocationDependentDevices, args)

ArActionDeceleratingLimiter_swigregister = _AriaPy.ArActionDeceleratingLimiter_swigregister
ArActionDeceleratingLimiter_swigregister(ArActionDeceleratingLimiter)

class ArActionDesiredChannel:
    """Proxy of C++ ArActionDesiredChannel class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionDesiredChannel, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionDesiredChannel, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArActionDesiredChannel"""
        this = apply(_AriaPy.new_ArActionDesiredChannel, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionDesiredChannel
    __del__ = lambda self : None;
    def setOverrideDoesLessThan(*args):
        """setOverrideDoesLessThan(self, bool overrideDoesLessThan)"""
        return apply(_AriaPy.ArActionDesiredChannel_setOverrideDoesLessThan, args)

    def setDesired(*args):
        """
        setDesired(self, double desired, double desiredStrength, bool allowOverride=False)
        setDesired(self, double desired, double desiredStrength)
        """
        return apply(_AriaPy.ArActionDesiredChannel_setDesired, args)

    def getDesired(*args):
        """getDesired(self) -> double"""
        return apply(_AriaPy.ArActionDesiredChannel_getDesired, args)

    def getStrength(*args):
        """getStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesiredChannel_getStrength, args)

    def getAllowOverride(*args):
        """getAllowOverride(self) -> double"""
        return apply(_AriaPy.ArActionDesiredChannel_getAllowOverride, args)

    def reset(*args):
        """reset(self)"""
        return apply(_AriaPy.ArActionDesiredChannel_reset, args)

    def merge(*args):
        """merge(self, ArActionDesiredChannel desiredChannel)"""
        return apply(_AriaPy.ArActionDesiredChannel_merge, args)

    def startAverage(*args):
        """startAverage(self)"""
        return apply(_AriaPy.ArActionDesiredChannel_startAverage, args)

    def addAverage(*args):
        """addAverage(self, ArActionDesiredChannel desiredChannel)"""
        return apply(_AriaPy.ArActionDesiredChannel_addAverage, args)

    def endAverage(*args):
        """endAverage(self)"""
        return apply(_AriaPy.ArActionDesiredChannel_endAverage, args)

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:
    """Proxy of C++ ArActionDesired class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionDesired, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionDesired, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArActionDesired"""
        this = apply(_AriaPy.new_ArActionDesired, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionDesired
    __del__ = lambda self : None;
    def setVel(*args):
        """
        setVel(self, double vel, double strength=MAX_STRENGTH)
        setVel(self, double vel)
        """
        return apply(_AriaPy.ArActionDesired_setVel, args)

    def setDeltaHeading(*args):
        """
        setDeltaHeading(self, double deltaHeading, double strength=MAX_STRENGTH)
        setDeltaHeading(self, double deltaHeading)
        """
        return apply(_AriaPy.ArActionDesired_setDeltaHeading, args)

    def setHeading(*args):
        """
        setHeading(self, double heading, double strength=MAX_STRENGTH)
        setHeading(self, double heading)
        """
        return apply(_AriaPy.ArActionDesired_setHeading, args)

    def setRotVel(*args):
        """
        setRotVel(self, double rotVel, double strength=MAX_STRENGTH)
        setRotVel(self, double rotVel)
        """
        return apply(_AriaPy.ArActionDesired_setRotVel, args)

    def setMaxVel(*args):
        """
        setMaxVel(self, double maxVel, double strength=MAX_STRENGTH, bool useSlowest=True)
        setMaxVel(self, double maxVel, double strength=MAX_STRENGTH)
        setMaxVel(self, double maxVel)
        """
        return apply(_AriaPy.ArActionDesired_setMaxVel, args)

    def setMaxNegVel(*args):
        """
        setMaxNegVel(self, double maxVel, double strength=MAX_STRENGTH, bool useSlowest=True)
        setMaxNegVel(self, double maxVel, double strength=MAX_STRENGTH)
        setMaxNegVel(self, double maxVel)
        """
        return apply(_AriaPy.ArActionDesired_setMaxNegVel, args)

    def setTransAccel(*args):
        """
        setTransAccel(self, double transAccel, double strength=MAX_STRENGTH, bool useSlowest=True)
        setTransAccel(self, double transAccel, double strength=MAX_STRENGTH)
        setTransAccel(self, double transAccel)
        """
        return apply(_AriaPy.ArActionDesired_setTransAccel, args)

    def setTransDecel(*args):
        """
        setTransDecel(self, double transDecel, double strength=MAX_STRENGTH, bool useFastestDecel=True)
        setTransDecel(self, double transDecel, double strength=MAX_STRENGTH)
        setTransDecel(self, double transDecel)
        """
        return apply(_AriaPy.ArActionDesired_setTransDecel, args)

    def setMaxRotVel(*args):
        """
        setMaxRotVel(self, double maxVel, double strength=MAX_STRENGTH, bool useSlowest=True)
        setMaxRotVel(self, double maxVel, double strength=MAX_STRENGTH)
        setMaxRotVel(self, double maxVel)
        """
        return apply(_AriaPy.ArActionDesired_setMaxRotVel, args)

    def setRotAccel(*args):
        """
        setRotAccel(self, double rotAccel, double strength=MAX_STRENGTH, bool useSlowest=True)
        setRotAccel(self, double rotAccel, double strength=MAX_STRENGTH)
        setRotAccel(self, double rotAccel)
        """
        return apply(_AriaPy.ArActionDesired_setRotAccel, args)

    def setRotDecel(*args):
        """
        setRotDecel(self, double rotDecel, double strength=MAX_STRENGTH, bool useFastest=True)
        setRotDecel(self, double rotDecel, double strength=MAX_STRENGTH)
        setRotDecel(self, double rotDecel)
        """
        return apply(_AriaPy.ArActionDesired_setRotDecel, args)

    def setLeftLatVel(*args):
        """
        setLeftLatVel(self, double latVel, double strength=MAX_STRENGTH)
        setLeftLatVel(self, double latVel)
        """
        return apply(_AriaPy.ArActionDesired_setLeftLatVel, args)

    def setRightLatVel(*args):
        """
        setRightLatVel(self, double latVel, double strength=MAX_STRENGTH)
        setRightLatVel(self, double latVel)
        """
        return apply(_AriaPy.ArActionDesired_setRightLatVel, args)

    def setMaxLeftLatVel(*args):
        """
        setMaxLeftLatVel(self, double maxVel, double strength=MAX_STRENGTH, bool useSlowest=True)
        setMaxLeftLatVel(self, double maxVel, double strength=MAX_STRENGTH)
        setMaxLeftLatVel(self, double maxVel)
        """
        return apply(_AriaPy.ArActionDesired_setMaxLeftLatVel, args)

    def setMaxRightLatVel(*args):
        """
        setMaxRightLatVel(self, double maxVel, double strength=MAX_STRENGTH, bool useSlowest=True)
        setMaxRightLatVel(self, double maxVel, double strength=MAX_STRENGTH)
        setMaxRightLatVel(self, double maxVel)
        """
        return apply(_AriaPy.ArActionDesired_setMaxRightLatVel, args)

    def setLatAccel(*args):
        """
        setLatAccel(self, double latAccel, double strength=MAX_STRENGTH, bool useSlowest=True)
        setLatAccel(self, double latAccel, double strength=MAX_STRENGTH)
        setLatAccel(self, double latAccel)
        """
        return apply(_AriaPy.ArActionDesired_setLatAccel, args)

    def setLatDecel(*args):
        """
        setLatDecel(self, double latDecel, double strength=MAX_STRENGTH, bool useFastest=True)
        setLatDecel(self, double latDecel, double strength=MAX_STRENGTH)
        setLatDecel(self, double latDecel)
        """
        return apply(_AriaPy.ArActionDesired_setLatDecel, args)

    def reset(*args):
        """reset(self)"""
        return apply(_AriaPy.ArActionDesired_reset, args)

    def getVel(*args):
        """getVel(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getVel, args)

    def getVelStrength(*args):
        """getVelStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getVelStrength, args)

    def getHeading(*args):
        """getHeading(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getHeading, args)

    def getHeadingStrength(*args):
        """getHeadingStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getHeadingStrength, args)

    def getDeltaHeading(*args):
        """getDeltaHeading(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getDeltaHeading, args)

    def getDeltaHeadingStrength(*args):
        """getDeltaHeadingStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getDeltaHeadingStrength, args)

    def getRotVel(*args):
        """getRotVel(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getRotVel, args)

    def getRotVelStrength(*args):
        """getRotVelStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getRotVelStrength, args)

    def getMaxVel(*args):
        """getMaxVel(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxVel, args)

    def getMaxVelStrength(*args):
        """getMaxVelStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxVelStrength, args)

    def getMaxVelSlowestUsed(*args):
        """getMaxVelSlowestUsed(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxVelSlowestUsed, args)

    def getMaxNegVel(*args):
        """getMaxNegVel(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxNegVel, args)

    def getMaxNegVelStrength(*args):
        """getMaxNegVelStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxNegVelStrength, args)

    def getMaxNegVelSlowestUsed(*args):
        """getMaxNegVelSlowestUsed(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxNegVelSlowestUsed, args)

    def getTransAccel(*args):
        """getTransAccel(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getTransAccel, args)

    def getTransAccelStrength(*args):
        """getTransAccelStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getTransAccelStrength, args)

    def getTransAccelSlowestUsed(*args):
        """getTransAccelSlowestUsed(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getTransAccelSlowestUsed, args)

    def getTransDecel(*args):
        """getTransDecel(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getTransDecel, args)

    def getTransDecelStrength(*args):
        """getTransDecelStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getTransDecelStrength, args)

    def getTransDecelFastestUsed(*args):
        """getTransDecelFastestUsed(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getTransDecelFastestUsed, args)

    def getMaxRotVel(*args):
        """getMaxRotVel(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxRotVel, args)

    def getMaxRotVelStrength(*args):
        """getMaxRotVelStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxRotVelStrength, args)

    def getMaxRotVelSlowestUsed(*args):
        """getMaxRotVelSlowestUsed(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxRotVelSlowestUsed, args)

    def getRotAccel(*args):
        """getRotAccel(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getRotAccel, args)

    def getRotAccelStrength(*args):
        """getRotAccelStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getRotAccelStrength, args)

    def getRotAccelSlowestUsed(*args):
        """getRotAccelSlowestUsed(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getRotAccelSlowestUsed, args)

    def getRotDecel(*args):
        """getRotDecel(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getRotDecel, args)

    def getRotDecelStrength(*args):
        """getRotDecelStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getRotDecelStrength, args)

    def getRotDecelFastestUsed(*args):
        """getRotDecelFastestUsed(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getRotDecelFastestUsed, args)

    def getLatVel(*args):
        """getLatVel(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getLatVel, args)

    def getLatVelStrength(*args):
        """getLatVelStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getLatVelStrength, args)

    def getMaxLeftLatVel(*args):
        """getMaxLeftLatVel(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxLeftLatVel, args)

    def getMaxLeftLatVelStrength(*args):
        """getMaxLeftLatVelStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxLeftLatVelStrength, args)

    def getMaxLeftLatVelSlowestUsed(*args):
        """getMaxLeftLatVelSlowestUsed(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxLeftLatVelSlowestUsed, args)

    def getMaxRightLatVel(*args):
        """getMaxRightLatVel(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxRightLatVel, args)

    def getMaxRightLatVelStrength(*args):
        """getMaxRightLatVelStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxRightLatVelStrength, args)

    def getMaxRightLatVelSlowestUsed(*args):
        """getMaxRightLatVelSlowestUsed(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getMaxRightLatVelSlowestUsed, args)

    def getLatAccel(*args):
        """getLatAccel(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getLatAccel, args)

    def getLatAccelStrength(*args):
        """getLatAccelStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getLatAccelStrength, args)

    def getLatAccelSlowestUsed(*args):
        """getLatAccelSlowestUsed(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getLatAccelSlowestUsed, args)

    def getLatDecel(*args):
        """getLatDecel(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getLatDecel, args)

    def getLatDecelStrength(*args):
        """getLatDecelStrength(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getLatDecelStrength, args)

    def getLatDecelFastestUsed(*args):
        """getLatDecelFastestUsed(self) -> double"""
        return apply(_AriaPy.ArActionDesired_getLatDecelFastestUsed, args)

    def merge(*args):
        """merge(self, ArActionDesired actDesired)"""
        return apply(_AriaPy.ArActionDesired_merge, args)

    def startAverage(*args):
        """startAverage(self)"""
        return apply(_AriaPy.ArActionDesired_startAverage, args)

    def addAverage(*args):
        """addAverage(self, ArActionDesired actDesired)"""
        return apply(_AriaPy.ArActionDesired_addAverage, args)

    def endAverage(*args):
        """endAverage(self)"""
        return apply(_AriaPy.ArActionDesired_endAverage, args)

    def accountForRobotHeading(*args):
        """accountForRobotHeading(self, double robotHeading)"""
        return apply(_AriaPy.ArActionDesired_accountForRobotHeading, args)

    def log(*args):
        """log(self)"""
        return apply(_AriaPy.ArActionDesired_log, args)

    def isAnythingDesired(*args):
        """isAnythingDesired(self) -> bool"""
        return apply(_AriaPy.ArActionDesired_isAnythingDesired, args)

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"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionDriveDistance, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionDriveDistance, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="driveDistance", double speed=400, double deceleration=200) -> ArActionDriveDistance
        __init__(self, char name="driveDistance", double speed=400) -> ArActionDriveDistance
        __init__(self, char name="driveDistance") -> ArActionDriveDistance
        __init__(self) -> ArActionDriveDistance
        """
        this = apply(_AriaPy.new_ArActionDriveDistance, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionDriveDistance
    __del__ = lambda self : None;
    def haveAchievedDistance(*args):
        """haveAchievedDistance(self) -> bool"""
        return apply(_AriaPy.ArActionDriveDistance_haveAchievedDistance, args)

    def cancelDistance(*args):
        """cancelDistance(self)"""
        return apply(_AriaPy.ArActionDriveDistance_cancelDistance, args)

    def setDistance(*args):
        """
        setDistance(self, double distance, bool useEncoders=True)
        setDistance(self, double distance)
        """
        return apply(_AriaPy.ArActionDriveDistance_setDistance, args)

    def usingEncoders(*args):
        """usingEncoders(self) -> bool"""
        return apply(_AriaPy.ArActionDriveDistance_usingEncoders, args)

    def setSpeed(*args):
        """
        setSpeed(self, double speed=400)
        setSpeed(self)
        """
        return apply(_AriaPy.ArActionDriveDistance_setSpeed, args)

    def getSpeed(*args):
        """getSpeed(self) -> double"""
        return apply(_AriaPy.ArActionDriveDistance_getSpeed, args)

    def setDeceleration(*args):
        """
        setDeceleration(self, double deceleration=200)
        setDeceleration(self)
        """
        return apply(_AriaPy.ArActionDriveDistance_setDeceleration, args)

    def getDeceleration(*args):
        """getDeceleration(self) -> double"""
        return apply(_AriaPy.ArActionDriveDistance_getDeceleration, args)

    def setPrinting(*args):
        """setPrinting(self, bool printing)"""
        return apply(_AriaPy.ArActionDriveDistance_setPrinting, args)

    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionDriveDistance_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionDriveDistance_getDesired, args)

ArActionDriveDistance_swigregister = _AriaPy.ArActionDriveDistance_swigregister
ArActionDriveDistance_swigregister(ArActionDriveDistance)

class ArActionGoto(ArAction):
    """Proxy of C++ ArActionGoto class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionGoto, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionGoto, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="goto", ArPose goal=ArPose(0.0, 0.0, 0.0), 
            double closeDist=100, double speed=400, double speedToTurnAt=150, 
            double turnAmount=7) -> ArActionGoto
        __init__(self, char name="goto", ArPose goal=ArPose(0.0, 0.0, 0.0), 
            double closeDist=100, double speed=400, double speedToTurnAt=150) -> ArActionGoto
        __init__(self, char name="goto", ArPose goal=ArPose(0.0, 0.0, 0.0), 
            double closeDist=100, double speed=400) -> ArActionGoto
        __init__(self, char name="goto", ArPose goal=ArPose(0.0, 0.0, 0.0), 
            double closeDist=100) -> ArActionGoto
        __init__(self, char name="goto", ArPose goal=ArPose(0.0, 0.0, 0.0)) -> ArActionGoto
        __init__(self, char name="goto") -> ArActionGoto
        __init__(self) -> ArActionGoto
        """
        this = apply(_AriaPy.new_ArActionGoto, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGoto
    __del__ = lambda self : None;
    def haveAchievedGoal(*args):
        """haveAchievedGoal(self) -> bool"""
        return apply(_AriaPy.ArActionGoto_haveAchievedGoal, args)

    def cancelGoal(*args):
        """cancelGoal(self)"""
        return apply(_AriaPy.ArActionGoto_cancelGoal, args)

    def setGoal(*args):
        """setGoal(self, ArPose goal)"""
        return apply(_AriaPy.ArActionGoto_setGoal, args)

    def getGoal(*args):
        """getGoal(self) -> ArPose"""
        return apply(_AriaPy.ArActionGoto_getGoal, args)

    def setCloseDist(*args):
        """setCloseDist(self, double closeDist)"""
        return apply(_AriaPy.ArActionGoto_setCloseDist, args)

    def getCloseDist(*args):
        """getCloseDist(self) -> double"""
        return apply(_AriaPy.ArActionGoto_getCloseDist, args)

    def setSpeed(*args):
        """setSpeed(self, double speed)"""
        return apply(_AriaPy.ArActionGoto_setSpeed, args)

    def getSpeed(*args):
        """getSpeed(self) -> double"""
        return apply(_AriaPy.ArActionGoto_getSpeed, args)

    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionGoto_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionGoto_getDesired, args)

ArActionGoto_swigregister = _AriaPy.ArActionGoto_swigregister
ArActionGoto_swigregister(ArActionGoto)

class ArActionGotoStraight(ArAction):
    """Proxy of C++ ArActionGotoStraight class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionGotoStraight, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionGotoStraight, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="goto", double speed=400) -> ArActionGotoStraight
        __init__(self, char name="goto") -> ArActionGotoStraight
        __init__(self) -> ArActionGotoStraight
        """
        this = apply(_AriaPy.new_ArActionGotoStraight, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGotoStraight
    __del__ = lambda self : None;
    def haveAchievedGoal(*args):
        """haveAchievedGoal(self) -> bool"""
        return apply(_AriaPy.ArActionGotoStraight_haveAchievedGoal, args)

    def cancelGoal(*args):
        """cancelGoal(self)"""
        return apply(_AriaPy.ArActionGotoStraight_cancelGoal, args)

    def setGoal(*args):
        """
        setGoal(self, ArPose goal, bool backwards=False, bool justDistance=True)
        setGoal(self, ArPose goal, bool backwards=False)
        setGoal(self, ArPose goal)
        """
        return apply(_AriaPy.ArActionGotoStraight_setGoal, args)

    def setGoalRel(*args):
        """
        setGoalRel(self, double dist, double deltaHeading, bool backwards=False, 
            bool justDistance=True)
        setGoalRel(self, double dist, double deltaHeading, bool backwards=False)
        setGoalRel(self, double dist, double deltaHeading)
        """
        return apply(_AriaPy.ArActionGotoStraight_setGoalRel, args)

    def getGoal(*args):
        """getGoal(self) -> ArPose"""
        return apply(_AriaPy.ArActionGotoStraight_getGoal, args)

    def usingEncoderGoal(*args):
        """usingEncoderGoal(self) -> bool"""
        return apply(_AriaPy.ArActionGotoStraight_usingEncoderGoal, args)

    def setEncoderGoal(*args):
        """
        setEncoderGoal(self, ArPose encoderGoal, bool backwards=False, bool justDistance=True)
        setEncoderGoal(self, ArPose encoderGoal, bool backwards=False)
        setEncoderGoal(self, ArPose encoderGoal)
        """
        return apply(_AriaPy.ArActionGotoStraight_setEncoderGoal, args)

    def setEncoderGoalRel(*args):
        """
        setEncoderGoalRel(self, double dist, double deltaHeading, bool backwards=False, 
            bool justDistance=True)
        setEncoderGoalRel(self, double dist, double deltaHeading, bool backwards=False)
        setEncoderGoalRel(self, double dist, double deltaHeading)
        """
        return apply(_AriaPy.ArActionGotoStraight_setEncoderGoalRel, args)

    def getEncoderGoal(*args):
        """getEncoderGoal(self) -> ArPose"""
        return apply(_AriaPy.ArActionGotoStraight_getEncoderGoal, args)

    def setSpeed(*args):
        """setSpeed(self, double speed)"""
        return apply(_AriaPy.ArActionGotoStraight_setSpeed, args)

    def getSpeed(*args):
        """getSpeed(self) -> double"""
        return apply(_AriaPy.ArActionGotoStraight_getSpeed, args)

    def setCloseDist(*args):
        """
        setCloseDist(self, double closeDist=100)
        setCloseDist(self)
        """
        return apply(_AriaPy.ArActionGotoStraight_setCloseDist, args)

    def getCloseDist(*args):
        """getCloseDist(self) -> double"""
        return apply(_AriaPy.ArActionGotoStraight_getCloseDist, args)

    def getBacking(*args):
        """getBacking(self) -> bool"""
        return apply(_AriaPy.ArActionGotoStraight_getBacking, args)

    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionGotoStraight_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionGotoStraight_getDesired, args)

ArActionGotoStraight_swigregister = _AriaPy.ArActionGotoStraight_swigregister
ArActionGotoStraight_swigregister(ArActionGotoStraight)

class ArActionGroup:
    """Proxy of C++ ArActionGroup class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionGroup, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionGroup, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot) -> ArActionGroup"""
        this = apply(_AriaPy.new_ArActionGroup, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroup
    __del__ = lambda self : None;
    def addAction(*args):
        """addAction(self, ArAction action, int priority)"""
        return apply(_AriaPy.ArActionGroup_addAction, args)

    def remAction(*args):
        """remAction(self, ArAction action)"""
        return apply(_AriaPy.ArActionGroup_remAction, args)

    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArActionGroup_activate, args)

    def activateExclusive(*args):
        """activateExclusive(self)"""
        return apply(_AriaPy.ArActionGroup_activateExclusive, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArActionGroup_deactivate, args)

    def removeActions(*args):
        """removeActions(self)"""
        return apply(_AriaPy.ArActionGroup_removeActions, args)

    def deleteActions(*args):
        """deleteActions(self)"""
        return apply(_AriaPy.ArActionGroup_deleteActions, args)

    def getActionList(*args):
        """getActionList(self) -> std::list<(p.ArAction,std::allocator<(p.ArAction)>)>"""
        return apply(_AriaPy.ArActionGroup_getActionList, args)

ArActionGroup_swigregister = _AriaPy.ArActionGroup_swigregister
ArActionGroup_swigregister(ArActionGroup)

class ArActionGroupInput(ArActionGroup):
    """Proxy of C++ ArActionGroupInput class"""
    __swig_setmethods__ = {}
    for _s in [ArActionGroup]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionGroupInput, name, value)
    __swig_getmethods__ = {}
    for _s in [ArActionGroup]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionGroupInput, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot) -> ArActionGroupInput"""
        this = apply(_AriaPy.new_ArActionGroupInput, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupInput
    __del__ = lambda self : None;
    def setVel(*args):
        """setVel(self, double vel)"""
        return apply(_AriaPy.ArActionGroupInput_setVel, args)

    def setRotVel(*args):
        """setRotVel(self, double rotVel)"""
        return apply(_AriaPy.ArActionGroupInput_setRotVel, args)

    def setHeading(*args):
        """setHeading(self, double heading)"""
        return apply(_AriaPy.ArActionGroupInput_setHeading, args)

    def deltaHeadingFromCurrent(*args):
        """deltaHeadingFromCurrent(self, double delta)"""
        return apply(_AriaPy.ArActionGroupInput_deltaHeadingFromCurrent, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArActionGroupInput_clear, args)

    def getActionInput(*args):
        """getActionInput(self) -> ArActionInput"""
        return apply(_AriaPy.ArActionGroupInput_getActionInput, args)

ArActionGroupInput_swigregister = _AriaPy.ArActionGroupInput_swigregister
ArActionGroupInput_swigregister(ArActionGroupInput)

class ArActionGroupStop(ArActionGroup):
    """Proxy of C++ ArActionGroupStop class"""
    __swig_setmethods__ = {}
    for _s in [ArActionGroup]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionGroupStop, name, value)
    __swig_getmethods__ = {}
    for _s in [ArActionGroup]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionGroupStop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot) -> ArActionGroupStop"""
        this = apply(_AriaPy.new_ArActionGroupStop, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupStop
    __del__ = lambda self : None;
ArActionGroupStop_swigregister = _AriaPy.ArActionGroupStop_swigregister
ArActionGroupStop_swigregister(ArActionGroupStop)

class ArActionGroupTeleop(ArActionGroup):
    """Proxy of C++ ArActionGroupTeleop class"""
    __swig_setmethods__ = {}
    for _s in [ArActionGroup]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionGroupTeleop, name, value)
    __swig_getmethods__ = {}
    for _s in [ArActionGroup]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionGroupTeleop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot) -> ArActionGroupTeleop"""
        this = apply(_AriaPy.new_ArActionGroupTeleop, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupTeleop
    __del__ = lambda self : None;
    def setThrottleParams(*args):
        """setThrottleParams(self, int lowSpeed, int highSpeed)"""
        return apply(_AriaPy.ArActionGroupTeleop_setThrottleParams, args)

ArActionGroupTeleop_swigregister = _AriaPy.ArActionGroupTeleop_swigregister
ArActionGroupTeleop_swigregister(ArActionGroupTeleop)

class ArActionGroupUnguardedTeleop(ArActionGroup):
    """Proxy of C++ ArActionGroupUnguardedTeleop class"""
    __swig_setmethods__ = {}
    for _s in [ArActionGroup]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionGroupUnguardedTeleop, name, value)
    __swig_getmethods__ = {}
    for _s in [ArActionGroup]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionGroupUnguardedTeleop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot) -> ArActionGroupUnguardedTeleop"""
        this = apply(_AriaPy.new_ArActionGroupUnguardedTeleop, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupUnguardedTeleop
    __del__ = lambda self : None;
    def setThrottleParams(*args):
        """setThrottleParams(self, int lowSpeed, int highSpeed)"""
        return apply(_AriaPy.ArActionGroupUnguardedTeleop_setThrottleParams, args)

ArActionGroupUnguardedTeleop_swigregister = _AriaPy.ArActionGroupUnguardedTeleop_swigregister
ArActionGroupUnguardedTeleop_swigregister(ArActionGroupUnguardedTeleop)

class ArActionGroupWander(ArActionGroup):
    """Proxy of C++ ArActionGroupWander class"""
    __swig_setmethods__ = {}
    for _s in [ArActionGroup]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionGroupWander, name, value)
    __swig_getmethods__ = {}
    for _s in [ArActionGroup]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionGroupWander, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, int forwardVel=400, int avoidFrontDist=450, 
            int avoidVel=200, int avoidTurnAmt=15) -> ArActionGroupWander
        __init__(self, ArRobot robot, int forwardVel=400, int avoidFrontDist=450, 
            int avoidVel=200) -> ArActionGroupWander
        __init__(self, ArRobot robot, int forwardVel=400, int avoidFrontDist=450) -> ArActionGroupWander
        __init__(self, ArRobot robot, int forwardVel=400) -> ArActionGroupWander
        __init__(self, ArRobot robot) -> ArActionGroupWander
        """
        this = apply(_AriaPy.new_ArActionGroupWander, args)
        try: self.this.append(this)
        except: 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"""
    __swig_setmethods__ = {}
    for _s in [ArActionGroup]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionGroupColorFollow, name, value)
    __swig_getmethods__ = {}
    for _s in [ArActionGroup]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionGroupColorFollow, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot, ArACTS_1_2 acts, ArPTZ camera) -> ArActionGroupColorFollow"""
        this = apply(_AriaPy.new_ArActionGroupColorFollow, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupColorFollow
    __del__ = lambda self : None;
    def setCamera(*args):
        """setCamera(self, ArPTZ camera)"""
        return apply(_AriaPy.ArActionGroupColorFollow_setCamera, args)

    def setChannel(*args):
        """setChannel(self, int channel)"""
        return apply(_AriaPy.ArActionGroupColorFollow_setChannel, args)

    def startMovement(*args):
        """startMovement(self)"""
        return apply(_AriaPy.ArActionGroupColorFollow_startMovement, args)

    def stopMovement(*args):
        """stopMovement(self)"""
        return apply(_AriaPy.ArActionGroupColorFollow_stopMovement, args)

    def setAcquire(*args):
        """setAcquire(self, bool acquire)"""
        return apply(_AriaPy.ArActionGroupColorFollow_setAcquire, args)

    def getChannel(*args):
        """getChannel(self) -> int"""
        return apply(_AriaPy.ArActionGroupColorFollow_getChannel, args)

    def getAcquire(*args):
        """getAcquire(self) -> bool"""
        return apply(_AriaPy.ArActionGroupColorFollow_getAcquire, args)

    def getMovement(*args):
        """getMovement(self) -> bool"""
        return apply(_AriaPy.ArActionGroupColorFollow_getMovement, args)

    def getBlob(*args):
        """getBlob(self) -> bool"""
        return apply(_AriaPy.ArActionGroupColorFollow_getBlob, args)

ArActionGroupColorFollow_swigregister = _AriaPy.ArActionGroupColorFollow_swigregister
ArActionGroupColorFollow_swigregister(ArActionGroupColorFollow)

class ArActionGroupRatioDrive(ArActionGroup):
    """Proxy of C++ ArActionGroupRatioDrive class"""
    __swig_setmethods__ = {}
    for _s in [ArActionGroup]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionGroupRatioDrive, name, value)
    __swig_getmethods__ = {}
    for _s in [ArActionGroup]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionGroupRatioDrive, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot) -> ArActionGroupRatioDrive"""
        this = apply(_AriaPy.new_ArActionGroupRatioDrive, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupRatioDrive
    __del__ = lambda self : None;
    def getActionRatioInput(*args):
        """getActionRatioInput(self) -> ArActionRatioInput"""
        return apply(_AriaPy.ArActionGroupRatioDrive_getActionRatioInput, args)

    def addToConfig(*args):
        """addToConfig(self, ArConfig config, char section)"""
        return apply(_AriaPy.ArActionGroupRatioDrive_addToConfig, args)

ArActionGroupRatioDrive_swigregister = _AriaPy.ArActionGroupRatioDrive_swigregister
ArActionGroupRatioDrive_swigregister(ArActionGroupRatioDrive)

class ArActionGroupRatioDriveUnsafe(ArActionGroup):
    """Proxy of C++ ArActionGroupRatioDriveUnsafe class"""
    __swig_setmethods__ = {}
    for _s in [ArActionGroup]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionGroupRatioDriveUnsafe, name, value)
    __swig_getmethods__ = {}
    for _s in [ArActionGroup]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionGroupRatioDriveUnsafe, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot) -> ArActionGroupRatioDriveUnsafe"""
        this = apply(_AriaPy.new_ArActionGroupRatioDriveUnsafe, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionGroupRatioDriveUnsafe
    __del__ = lambda self : None;
    def getActionRatioInput(*args):
        """getActionRatioInput(self) -> ArActionRatioInput"""
        return apply(_AriaPy.ArActionGroupRatioDriveUnsafe_getActionRatioInput, args)

    def addToConfig(*args):
        """addToConfig(self, ArConfig config, char section)"""
        return apply(_AriaPy.ArActionGroupRatioDriveUnsafe_addToConfig, args)

ArActionGroupRatioDriveUnsafe_swigregister = _AriaPy.ArActionGroupRatioDriveUnsafe_swigregister
ArActionGroupRatioDriveUnsafe_swigregister(ArActionGroupRatioDriveUnsafe)

class ArActionIRs(ArAction):
    """Proxy of C++ ArActionIRs class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionIRs, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionIRs, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="IRs", double backOffSpeed=100, int backOffTime=5000, 
            int turnTime=3000, bool setMaximums=False) -> ArActionIRs
        __init__(self, char name="IRs", double backOffSpeed=100, int backOffTime=5000, 
            int turnTime=3000) -> ArActionIRs
        __init__(self, char name="IRs", double backOffSpeed=100, int backOffTime=5000) -> ArActionIRs
        __init__(self, char name="IRs", double backOffSpeed=100) -> ArActionIRs
        __init__(self, char name="IRs") -> ArActionIRs
        __init__(self) -> ArActionIRs
        """
        this = apply(_AriaPy.new_ArActionIRs, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionIRs
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionIRs_fire, args)

    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArActionIRs_setRobot, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionIRs_getDesired, args)

ArActionIRs_swigregister = _AriaPy.ArActionIRs_swigregister
ArActionIRs_swigregister(ArActionIRs)

class ArActionInput(ArAction):
    """Proxy of C++ ArActionInput class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionInput, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionInput, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="Input") -> ArActionInput
        __init__(self) -> ArActionInput
        """
        this = apply(_AriaPy.new_ArActionInput, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionInput
    __del__ = lambda self : None;
    def setVel(*args):
        """setVel(self, double vel)"""
        return apply(_AriaPy.ArActionInput_setVel, args)

    def deltaHeadingFromCurrent(*args):
        """deltaHeadingFromCurrent(self, double delta)"""
        return apply(_AriaPy.ArActionInput_deltaHeadingFromCurrent, args)

    def setRotVel(*args):
        """setRotVel(self, double rotVel)"""
        return apply(_AriaPy.ArActionInput_setRotVel, args)

    def setHeading(*args):
        """setHeading(self, double heading)"""
        return apply(_AriaPy.ArActionInput_setHeading, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArActionInput_clear, args)

    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionInput_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionInput_getDesired, args)

ArActionInput_swigregister = _AriaPy.ArActionInput_swigregister
ArActionInput_swigregister(ArActionInput)

class ArActionJoydrive(ArAction):
    """Proxy of C++ ArActionJoydrive class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionJoydrive, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionJoydrive, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="joydrive", double transVelMax=400, double turnAmountMax=15, 
            bool stopIfNoButtonPressed=True, 
            bool useOSCalForJoystick=True) -> ArActionJoydrive
        __init__(self, char name="joydrive", double transVelMax=400, double turnAmountMax=15, 
            bool stopIfNoButtonPressed=True) -> ArActionJoydrive
        __init__(self, char name="joydrive", double transVelMax=400, double turnAmountMax=15) -> ArActionJoydrive
        __init__(self, char name="joydrive", double transVelMax=400) -> ArActionJoydrive
        __init__(self, char name="joydrive") -> ArActionJoydrive
        __init__(self) -> ArActionJoydrive
        """
        this = apply(_AriaPy.new_ArActionJoydrive, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionJoydrive
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionJoydrive_fire, args)

    def joystickInited(*args):
        """joystickInited(self) -> bool"""
        return apply(_AriaPy.ArActionJoydrive_joystickInited, args)

    def setSpeeds(*args):
        """setSpeeds(self, double transVelMax, double turnAmountMax)"""
        return apply(_AriaPy.ArActionJoydrive_setSpeeds, args)

    def setStopIfNoButtonPressed(*args):
        """setStopIfNoButtonPressed(self, bool stopIfNoButtonPressed)"""
        return apply(_AriaPy.ArActionJoydrive_setStopIfNoButtonPressed, args)

    def getStopIfNoButtonPressed(*args):
        """getStopIfNoButtonPressed(self) -> bool"""
        return apply(_AriaPy.ArActionJoydrive_getStopIfNoButtonPressed, args)

    def setThrottleParams(*args):
        """setThrottleParams(self, double lowSpeed, double highSpeed)"""
        return apply(_AriaPy.ArActionJoydrive_setThrottleParams, args)

    def setUseOSCal(*args):
        """setUseOSCal(self, bool useOSCal)"""
        return apply(_AriaPy.ArActionJoydrive_setUseOSCal, args)

    def getUseOSCal(*args):
        """getUseOSCal(self) -> bool"""
        return apply(_AriaPy.ArActionJoydrive_getUseOSCal, args)

    def getJoyHandler(*args):
        """getJoyHandler(self) -> ArJoyHandler"""
        return apply(_AriaPy.ArActionJoydrive_getJoyHandler, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionJoydrive_getDesired, args)

ArActionJoydrive_swigregister = _AriaPy.ArActionJoydrive_swigregister
ArActionJoydrive_swigregister(ArActionJoydrive)

class ArActionKeydrive(ArAction):
    """Proxy of C++ ArActionKeydrive class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionKeydrive, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionKeydrive, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="keydrive", double transVelMax=400, double turnAmountMax=24, 
            double velIncrement=25, double turnIncrement=8) -> ArActionKeydrive
        __init__(self, char name="keydrive", double transVelMax=400, double turnAmountMax=24, 
            double velIncrement=25) -> ArActionKeydrive
        __init__(self, char name="keydrive", double transVelMax=400, double turnAmountMax=24) -> ArActionKeydrive
        __init__(self, char name="keydrive", double transVelMax=400) -> ArActionKeydrive
        __init__(self, char name="keydrive") -> ArActionKeydrive
        __init__(self) -> ArActionKeydrive
        """
        this = apply(_AriaPy.new_ArActionKeydrive, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionKeydrive
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionKeydrive_fire, args)

    def setSpeeds(*args):
        """setSpeeds(self, double transVelMax, double turnAmountMax)"""
        return apply(_AriaPy.ArActionKeydrive_setSpeeds, args)

    def setIncrements(*args):
        """setIncrements(self, double velIncrement, double turnIncrement)"""
        return apply(_AriaPy.ArActionKeydrive_setIncrements, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionKeydrive_getDesired, args)

    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArActionKeydrive_setRobot, args)

    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArActionKeydrive_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArActionKeydrive_deactivate, args)

    def takeKeys(*args):
        """takeKeys(self)"""
        return apply(_AriaPy.ArActionKeydrive_takeKeys, args)

    def giveUpKeys(*args):
        """giveUpKeys(self)"""
        return apply(_AriaPy.ArActionKeydrive_giveUpKeys, args)

    def up(*args):
        """up(self)"""
        return apply(_AriaPy.ArActionKeydrive_up, args)

    def down(*args):
        """down(self)"""
        return apply(_AriaPy.ArActionKeydrive_down, args)

    def left(*args):
        """left(self)"""
        return apply(_AriaPy.ArActionKeydrive_left, args)

    def right(*args):
        """right(self)"""
        return apply(_AriaPy.ArActionKeydrive_right, args)

    def space(*args):
        """space(self)"""
        return apply(_AriaPy.ArActionKeydrive_space, args)

ArActionKeydrive_swigregister = _AriaPy.ArActionKeydrive_swigregister
ArActionKeydrive_swigregister(ArActionKeydrive)

class ArActionLimiterBackwards(ArAction):
    """Proxy of C++ ArActionLimiterBackwards class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionLimiterBackwards, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionLimiterBackwards, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="speed limiter", double stopDistance=-250, 
            double slowDistance=-600, double maxBackwardsSpeed=-250, 
            double widthRatio=1.5) -> ArActionLimiterBackwards
        __init__(self, char name="speed limiter", double stopDistance=-250, 
            double slowDistance=-600, double maxBackwardsSpeed=-250) -> ArActionLimiterBackwards
        __init__(self, char name="speed limiter", double stopDistance=-250, 
            double slowDistance=-600) -> ArActionLimiterBackwards
        __init__(self, char name="speed limiter", double stopDistance=-250) -> ArActionLimiterBackwards
        __init__(self, char name="speed limiter") -> ArActionLimiterBackwards
        __init__(self) -> ArActionLimiterBackwards
        """
        this = apply(_AriaPy.new_ArActionLimiterBackwards, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionLimiterBackwards
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionLimiterBackwards_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionLimiterBackwards_getDesired, args)

ArActionLimiterBackwards_swigregister = _AriaPy.ArActionLimiterBackwards_swigregister
ArActionLimiterBackwards_swigregister(ArActionLimiterBackwards)

class ArActionLimiterForwards(ArAction):
    """Proxy of C++ ArActionLimiterForwards class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionLimiterForwards, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionLimiterForwards, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="speed limiter", double stopDistance=250, 
            double slowDistance=1000, double slowSpeed=200, 
            double widthRatio=1) -> ArActionLimiterForwards
        __init__(self, char name="speed limiter", double stopDistance=250, 
            double slowDistance=1000, double slowSpeed=200) -> ArActionLimiterForwards
        __init__(self, char name="speed limiter", double stopDistance=250, 
            double slowDistance=1000) -> ArActionLimiterForwards
        __init__(self, char name="speed limiter", double stopDistance=250) -> ArActionLimiterForwards
        __init__(self, char name="speed limiter") -> ArActionLimiterForwards
        __init__(self) -> ArActionLimiterForwards
        """
        this = apply(_AriaPy.new_ArActionLimiterForwards, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionLimiterForwards
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionLimiterForwards_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionLimiterForwards_getDesired, args)

    def setParameters(*args):
        """
        setParameters(self, double stopDistance=250, double slowDistance=1000, 
            double slowSpeed=200, double widthRatio=1)
        setParameters(self, double stopDistance=250, double slowDistance=1000, 
            double slowSpeed=200)
        setParameters(self, double stopDistance=250, double slowDistance=1000)
        setParameters(self, double stopDistance=250)
        setParameters(self)
        """
        return apply(_AriaPy.ArActionLimiterForwards_setParameters, args)

ArActionLimiterForwards_swigregister = _AriaPy.ArActionLimiterForwards_swigregister
ArActionLimiterForwards_swigregister(ArActionLimiterForwards)

class ArActionLimiterTableSensor(ArAction):
    """Proxy of C++ ArActionLimiterTableSensor class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionLimiterTableSensor, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionLimiterTableSensor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="TableSensorLimiter") -> ArActionLimiterTableSensor
        __init__(self) -> ArActionLimiterTableSensor
        """
        this = apply(_AriaPy.new_ArActionLimiterTableSensor, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionLimiterTableSensor
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionLimiterTableSensor_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionLimiterTableSensor_getDesired, args)

ArActionLimiterTableSensor_swigregister = _AriaPy.ArActionLimiterTableSensor_swigregister
ArActionLimiterTableSensor_swigregister(ArActionLimiterTableSensor)

class ArActionMovementParameters(ArAction):
    """Proxy of C++ ArActionMovementParameters class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionMovementParameters, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionMovementParameters, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="MovementParameters", bool overrideFaster=True, 
            bool addLatVelIfAvailable=True) -> ArActionMovementParameters
        __init__(self, char name="MovementParameters", bool overrideFaster=True) -> ArActionMovementParameters
        __init__(self, char name="MovementParameters") -> ArActionMovementParameters
        __init__(self) -> ArActionMovementParameters
        """
        this = apply(_AriaPy.new_ArActionMovementParameters, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionMovementParameters
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionMovementParameters_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionMovementParameters_getDesired, args)

    def enable(*args):
        """enable(self)"""
        return apply(_AriaPy.ArActionMovementParameters_enable, args)

    def enableOnceFromSector(*args):
        """enableOnceFromSector(self, ArMapObject mapObject)"""
        return apply(_AriaPy.ArActionMovementParameters_enableOnceFromSector, args)

    def disable(*args):
        """disable(self)"""
        return apply(_AriaPy.ArActionMovementParameters_disable, args)

    def setParameters(*args):
        """
        setParameters(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(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(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(self, double maxVel=0, double maxNegVel=0, double transAccel=0, 
            double transDecel=0, double rotVelMax=0, 
            double rotAccel=0, double rotDecel=0)
        setParameters(self, double maxVel=0, double maxNegVel=0, double transAccel=0, 
            double transDecel=0, double rotVelMax=0, 
            double rotAccel=0)
        setParameters(self, double maxVel=0, double maxNegVel=0, double transAccel=0, 
            double transDecel=0, double rotVelMax=0)
        setParameters(self, double maxVel=0, double maxNegVel=0, double transAccel=0, 
            double transDecel=0)
        setParameters(self, double maxVel=0, double maxNegVel=0, double transAccel=0)
        setParameters(self, double maxVel=0, double maxNegVel=0)
        setParameters(self, double maxVel=0)
        setParameters(self)
        """
        return apply(_AriaPy.ArActionMovementParameters_setParameters, args)

    def addToConfig(*args):
        """
        addToConfig(self, ArConfig config, char section, char prefix=None)
        addToConfig(self, ArConfig config, char section)
        """
        return apply(_AriaPy.ArActionMovementParameters_addToConfig, args)

ArActionMovementParameters_swigregister = _AriaPy.ArActionMovementParameters_swigregister
ArActionMovementParameters_swigregister(ArActionMovementParameters)

class ArActionRatioInput(ArAction):
    """Proxy of C++ ArActionRatioInput class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionRatioInput, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionRatioInput, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="RatioInput") -> ArActionRatioInput
        __init__(self) -> ArActionRatioInput
        """
        this = apply(_AriaPy.new_ArActionRatioInput, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionRatioInput
    __del__ = lambda self : None;
    def setRatios(*args):
        """
        setRatios(self, double transRatio, double rotRatio, double throttleRatio, 
            double latRatio=0)
        setRatios(self, double transRatio, double rotRatio, double throttleRatio)
        """
        return apply(_AriaPy.ArActionRatioInput_setRatios, args)

    def setTransRatio(*args):
        """setTransRatio(self, double transRatio)"""
        return apply(_AriaPy.ArActionRatioInput_setTransRatio, args)

    def setRotRatio(*args):
        """setRotRatio(self, double rotRatio)"""
        return apply(_AriaPy.ArActionRatioInput_setRotRatio, args)

    def setLatRatio(*args):
        """setLatRatio(self, double latRatio)"""
        return apply(_AriaPy.ArActionRatioInput_setLatRatio, args)

    def setThrottleRatio(*args):
        """setThrottleRatio(self, double throttleRatio)"""
        return apply(_AriaPy.ArActionRatioInput_setThrottleRatio, args)

    def getTransRatio(*args):
        """getTransRatio(self) -> double"""
        return apply(_AriaPy.ArActionRatioInput_getTransRatio, args)

    def getRotRatio(*args):
        """getRotRatio(self) -> double"""
        return apply(_AriaPy.ArActionRatioInput_getRotRatio, args)

    def getThrottleRatio(*args):
        """getThrottleRatio(self) -> double"""
        return apply(_AriaPy.ArActionRatioInput_getThrottleRatio, args)

    def addFireCallback(*args):
        """addFireCallback(self, int priority, ArFunctor functor)"""
        return apply(_AriaPy.ArActionRatioInput_addFireCallback, args)

    def remFireCallback(*args):
        """remFireCallback(self, ArFunctor functor)"""
        return apply(_AriaPy.ArActionRatioInput_remFireCallback, args)

    def addActivateCallback(*args):
        """
        addActivateCallback(self, ArFunctor functor, Pos position=LAST)
        addActivateCallback(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArActionRatioInput_addActivateCallback, args)

    def remActivateCallback(*args):
        """remActivateCallback(self, ArFunctor functor)"""
        return apply(_AriaPy.ArActionRatioInput_remActivateCallback, args)

    def addDeactivateCallback(*args):
        """
        addDeactivateCallback(self, ArFunctor functor, Pos position=LAST)
        addDeactivateCallback(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArActionRatioInput_addDeactivateCallback, args)

    def remDeactivateCallback(*args):
        """remDeactivateCallback(self, ArFunctor functor)"""
        return apply(_AriaPy.ArActionRatioInput_remDeactivateCallback, args)

    def setParameters(*args):
        """
        setParameters(self, double fullThrottleForwards, double fullThrottleBackwards, 
            double rotAtFullForwards, double rotAtFullBackwards, 
            double rotAtStopped, double latAtFullForwards=0, 
            double latAtFullBackwards=0, 
            double latAtStopped=0)
        setParameters(self, double fullThrottleForwards, double fullThrottleBackwards, 
            double rotAtFullForwards, double rotAtFullBackwards, 
            double rotAtStopped, double latAtFullForwards=0, 
            double latAtFullBackwards=0)
        setParameters(self, double fullThrottleForwards, double fullThrottleBackwards, 
            double rotAtFullForwards, double rotAtFullBackwards, 
            double rotAtStopped, double latAtFullForwards=0)
        setParameters(self, double fullThrottleForwards, double fullThrottleBackwards, 
            double rotAtFullForwards, double rotAtFullBackwards, 
            double rotAtStopped)
        """
        return apply(_AriaPy.ArActionRatioInput_setParameters, args)

    def addToConfig(*args):
        """addToConfig(self, ArConfig config, char section)"""
        return apply(_AriaPy.ArActionRatioInput_addToConfig, args)

    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionRatioInput_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionRatioInput_getDesired, args)

    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArActionRatioInput_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArActionRatioInput_deactivate, args)

ArActionRatioInput_swigregister = _AriaPy.ArActionRatioInput_swigregister
ArActionRatioInput_swigregister(ArActionRatioInput)

class ArActionRobotJoydrive(ArAction):
    """Proxy of C++ ArActionRobotJoydrive class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionRobotJoydrive, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionRobotJoydrive, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="robotJoyDrive", bool requireDeadmanPushed=True) -> ArActionRobotJoydrive
        __init__(self, char name="robotJoyDrive") -> ArActionRobotJoydrive
        __init__(self) -> ArActionRobotJoydrive
        """
        this = apply(_AriaPy.new_ArActionRobotJoydrive, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionRobotJoydrive
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionRobotJoydrive_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionRobotJoydrive_getDesired, args)

    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArActionRobotJoydrive_setRobot, args)

ArActionRobotJoydrive_swigregister = _AriaPy.ArActionRobotJoydrive_swigregister
ArActionRobotJoydrive_swigregister(ArActionRobotJoydrive)

class ArActionStallRecover(ArAction):
    """Proxy of C++ ArActionStallRecover class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionStallRecover, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionStallRecover, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="stall recover", double obstacleDistance=225, 
            int cyclesToMove=50, double speed=150, double degreesToTurn=45) -> ArActionStallRecover
        __init__(self, char name="stall recover", double obstacleDistance=225, 
            int cyclesToMove=50, double speed=150) -> ArActionStallRecover
        __init__(self, char name="stall recover", double obstacleDistance=225, 
            int cyclesToMove=50) -> ArActionStallRecover
        __init__(self, char name="stall recover", double obstacleDistance=225) -> ArActionStallRecover
        __init__(self, char name="stall recover") -> ArActionStallRecover
        __init__(self) -> ArActionStallRecover
        """
        this = apply(_AriaPy.new_ArActionStallRecover, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionStallRecover
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionStallRecover_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionStallRecover_getDesired, args)

    def addToConfig(*args):
        """
        addToConfig(self, ArConfig config, char sectionName, int priority=NORMAL)
        addToConfig(self, ArConfig config, char sectionName)
        """
        return apply(_AriaPy.ArActionStallRecover_addToConfig, args)

ArActionStallRecover_swigregister = _AriaPy.ArActionStallRecover_swigregister
ArActionStallRecover_swigregister(ArActionStallRecover)

class ArActionStop(ArAction):
    """Proxy of C++ ArActionStop class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionStop, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionStop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="stop") -> ArActionStop
        __init__(self) -> ArActionStop
        """
        this = apply(_AriaPy.new_ArActionStop, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionStop
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionStop_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionStop_getDesired, args)

ArActionStop_swigregister = _AriaPy.ArActionStop_swigregister
ArActionStop_swigregister(ArActionStop)

class ArActionTriangleDriveTo(ArAction):
    """Proxy of C++ ArActionTriangleDriveTo class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionTriangleDriveTo, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionTriangleDriveTo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="triangleDriveTo", double finalDistFromVertex=400, 
            double approachDistFromVertex=1000, 
            double speed=200, double closeDist=100, double acquireTurnSpeed=30) -> ArActionTriangleDriveTo
        __init__(self, char name="triangleDriveTo", double finalDistFromVertex=400, 
            double approachDistFromVertex=1000, 
            double speed=200, double closeDist=100) -> ArActionTriangleDriveTo
        __init__(self, char name="triangleDriveTo", double finalDistFromVertex=400, 
            double approachDistFromVertex=1000, 
            double speed=200) -> ArActionTriangleDriveTo
        __init__(self, char name="triangleDriveTo", double finalDistFromVertex=400, 
            double approachDistFromVertex=1000) -> ArActionTriangleDriveTo
        __init__(self, char name="triangleDriveTo", double finalDistFromVertex=400) -> ArActionTriangleDriveTo
        __init__(self, char name="triangleDriveTo") -> ArActionTriangleDriveTo
        __init__(self) -> ArActionTriangleDriveTo
        """
        this = apply(_AriaPy.new_ArActionTriangleDriveTo, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionTriangleDriveTo
    __del__ = lambda self : None;
    def setAcquire(*args):
        """
        setAcquire(self, bool acquire=False)
        setAcquire(self)
        """
        return apply(_AriaPy.ArActionTriangleDriveTo_setAcquire, args)

    def getAcquire(*args):
        """getAcquire(self) -> bool"""
        return apply(_AriaPy.ArActionTriangleDriveTo_getAcquire, args)

    def setFinalDistFromVertex(*args):
        """setFinalDistFromVertex(self, double dist)"""
        return apply(_AriaPy.ArActionTriangleDriveTo_setFinalDistFromVertex, args)

    def getFinalDistFromVertex(*args):
        """getFinalDistFromVertex(self) -> double"""
        return apply(_AriaPy.ArActionTriangleDriveTo_getFinalDistFromVertex, args)

    def setTriangleParams(*args):
        """
        setTriangleParams(self, double line1Length=254, double angleBetween=135, double line2Length=254)
        setTriangleParams(self, double line1Length=254, double angleBetween=135)
        setTriangleParams(self, double line1Length=254)
        setTriangleParams(self)
        """
        return apply(_AriaPy.ArActionTriangleDriveTo_setTriangleParams, args)

    def setParameters(*args):
        """
        setParameters(self, double finalDistFromVertex=400, double approachDistFromVertex=1000, 
            double speed=200, double closeDist=100, 
            double acquireTurnSpeed=30)
        setParameters(self, double finalDistFromVertex=400, double approachDistFromVertex=1000, 
            double speed=200, double closeDist=100)
        setParameters(self, double finalDistFromVertex=400, double approachDistFromVertex=1000, 
            double speed=200)
        setParameters(self, double finalDistFromVertex=400, double approachDistFromVertex=1000)
        setParameters(self, double finalDistFromVertex=400)
        setParameters(self)
        """
        return apply(_AriaPy.ArActionTriangleDriveTo_setParameters, args)

    def getAdjustVertex(*args):
        """getAdjustVertex(self) -> bool"""
        return apply(_AriaPy.ArActionTriangleDriveTo_getAdjustVertex, args)

    def setAdjustVertex(*args):
        """setAdjustVertex(self, bool adjustVertex)"""
        return apply(_AriaPy.ArActionTriangleDriveTo_setAdjustVertex, args)

    def setVertexOffset(*args):
        """setVertexOffset(self, int localXOffset, int localYOffset, double thOffset)"""
        return apply(_AriaPy.ArActionTriangleDriveTo_setVertexOffset, args)

    def getGotoVertex(*args):
        """getGotoVertex(self) -> bool"""
        return apply(_AriaPy.ArActionTriangleDriveTo_getGotoVertex, args)

    def setGotoVertex(*args):
        """setGotoVertex(self, bool gotoVertex)"""
        return apply(_AriaPy.ArActionTriangleDriveTo_setGotoVertex, args)

    def setIgnoreTriangleDist(*args):
        """
        setIgnoreTriangleDist(self, double dist=250, bool useIgnoreInGotoVertexMode=False)
        setIgnoreTriangleDist(self, double dist=250)
        setIgnoreTriangleDist(self)
        """
        return apply(_AriaPy.ArActionTriangleDriveTo_setIgnoreTriangleDist, args)

    def getIgnoreTriangleDist(*args):
        """getIgnoreTriangleDist(self) -> double"""
        return apply(_AriaPy.ArActionTriangleDriveTo_getIgnoreTriangleDist, args)

    def getUseIgnoreInGOtoVertexMode(*args):
        """getUseIgnoreInGOtoVertexMode(self) -> bool"""
        return apply(_AriaPy.ArActionTriangleDriveTo_getUseIgnoreInGOtoVertexMode, args)

    def setVertexUnseenStopMSecs(*args):
        """
        setVertexUnseenStopMSecs(self, int vertexUnseenStopMSecs=4000)
        setVertexUnseenStopMSecs(self)
        """
        return apply(_AriaPy.ArActionTriangleDriveTo_setVertexUnseenStopMSecs, args)

    def getVertexUnseenStopMSecs(*args):
        """getVertexUnseenStopMSecs(self) -> int"""
        return apply(_AriaPy.ArActionTriangleDriveTo_getVertexUnseenStopMSecs, args)

    def setMaxDistBetweenLinePoints(*args):
        """
        setMaxDistBetweenLinePoints(self, int maxDistBetweenLinePoints=0)
        setMaxDistBetweenLinePoints(self)
        """
        return apply(_AriaPy.ArActionTriangleDriveTo_setMaxDistBetweenLinePoints, args)

    def setMaxLateralDist(*args):
        """
        setMaxLateralDist(self, int maxLateralDist=0)
        setMaxLateralDist(self)
        """
        return apply(_AriaPy.ArActionTriangleDriveTo_setMaxLateralDist, args)

    def setMaxAngleMisalignment(*args):
        """
        setMaxAngleMisalignment(self, int maxAngleMisalignment=0)
        setMaxAngleMisalignment(self)
        """
        return apply(_AriaPy.ArActionTriangleDriveTo_setMaxAngleMisalignment, args)

    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(*args):
        """getState(self) -> int"""
        return apply(_AriaPy.ArActionTriangleDriveTo_getState, args)

    def setLineFinder(*args):
        """setLineFinder(self, ArLineFinder lineFinder)"""
        return apply(_AriaPy.ArActionTriangleDriveTo_setLineFinder, args)

    def getLineFinder(*args):
        """getLineFinder(self) -> ArLineFinder"""
        return apply(_AriaPy.ArActionTriangleDriveTo_getLineFinder, args)

    def setLogging(*args):
        """
        setLogging(self, bool logging)
        setLogging(self) -> bool
        """
        return apply(_AriaPy.ArActionTriangleDriveTo_setLogging, args)

    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArActionTriangleDriveTo_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArActionTriangleDriveTo_deactivate, args)

    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArActionTriangleDriveTo_setRobot, args)

    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionTriangleDriveTo_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionTriangleDriveTo_getDesired, args)

ArActionTriangleDriveTo_swigregister = _AriaPy.ArActionTriangleDriveTo_swigregister
ArActionTriangleDriveTo_swigregister(ArActionTriangleDriveTo)

class ArActionTurn(ArAction):
    """Proxy of C++ ArActionTurn class"""
    __swig_setmethods__ = {}
    for _s in [ArAction]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArActionTurn, name, value)
    __swig_getmethods__ = {}
    for _s in [ArAction]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArActionTurn, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="turn", double speedStartTurn=200, double speedFullTurn=100, 
            double turnAmount=15) -> ArActionTurn
        __init__(self, char name="turn", double speedStartTurn=200, double speedFullTurn=100) -> ArActionTurn
        __init__(self, char name="turn", double speedStartTurn=200) -> ArActionTurn
        __init__(self, char name="turn") -> ArActionTurn
        __init__(self) -> ArActionTurn
        """
        this = apply(_AriaPy.new_ArActionTurn, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArActionTurn
    __del__ = lambda self : None;
    def fire(*args):
        """fire(self, ArActionDesired currentDesired) -> ArActionDesired"""
        return apply(_AriaPy.ArActionTurn_fire, args)

    def getDesired(*args):
        """getDesired(self) -> ArActionDesired"""
        return apply(_AriaPy.ArActionTurn_getDesired, args)

ArActionTurn_swigregister = _AriaPy.ArActionTurn_swigregister
ArActionTurn_swigregister(ArActionTurn)

class ArAnalogGyro:
    """Proxy of C++ ArAnalogGyro class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArAnalogGyro, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArAnalogGyro, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot) -> ArAnalogGyro"""
        this = apply(_AriaPy.new_ArAnalogGyro, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArAnalogGyro
    __del__ = lambda self : None;
    def isActive(*args):
        """isActive(self) -> bool"""
        return apply(_AriaPy.ArAnalogGyro_isActive, args)

    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArAnalogGyro_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArAnalogGyro_deactivate, args)

    def hasGyroOnlyMode(*args):
        """hasGyroOnlyMode(self) -> bool"""
        return apply(_AriaPy.ArAnalogGyro_hasGyroOnlyMode, args)

    def isGyroOnlyActive(*args):
        """isGyroOnlyActive(self) -> bool"""
        return apply(_AriaPy.ArAnalogGyro_isGyroOnlyActive, args)

    def activateGyroOnly(*args):
        """activateGyroOnly(self)"""
        return apply(_AriaPy.ArAnalogGyro_activateGyroOnly, args)

    def hasNoInternalData(*args):
        """hasNoInternalData(self) -> bool"""
        return apply(_AriaPy.ArAnalogGyro_hasNoInternalData, args)

    def haveGottenData(*args):
        """haveGottenData(self) -> bool"""
        return apply(_AriaPy.ArAnalogGyro_haveGottenData, args)

    def getHeading(*args):
        """getHeading(self) -> double"""
        return apply(_AriaPy.ArAnalogGyro_getHeading, args)

    def getTemperature(*args):
        """getTemperature(self) -> int"""
        return apply(_AriaPy.ArAnalogGyro_getTemperature, args)

    def setFilterModel(*args):
        """
        setFilterModel(self, double gyroSigma, double inertialVar, double rotVar, 
            double transVar)
        """
        return apply(_AriaPy.ArAnalogGyro_setFilterModel, args)

    def getPacCount(*args):
        """getPacCount(self) -> int"""
        return apply(_AriaPy.ArAnalogGyro_getPacCount, args)

    def getAverage(*args):
        """getAverage(self) -> double"""
        return apply(_AriaPy.ArAnalogGyro_getAverage, args)

    def getAverageTaken(*args):
        """getAverageTaken(self) -> ArTime"""
        return apply(_AriaPy.ArAnalogGyro_getAverageTaken, args)

    def getScalingFactor(*args):
        """getScalingFactor(self) -> double"""
        return apply(_AriaPy.ArAnalogGyro_getScalingFactor, args)

    def setScalingFactor(*args):
        """setScalingFactor(self, double factor)"""
        return apply(_AriaPy.ArAnalogGyro_setScalingFactor, args)

    def handleGyroPacket(*args):
        """handleGyroPacket(self, ArRobotPacket packet) -> bool"""
        return apply(_AriaPy.ArAnalogGyro_handleGyroPacket, args)

    def encoderCorrect(*args):
        """encoderCorrect(self, ArPoseWithTime deltaPose) -> double"""
        return apply(_AriaPy.ArAnalogGyro_encoderCorrect, args)

    def stabilizingCallback(*args):
        """stabilizingCallback(self)"""
        return apply(_AriaPy.ArAnalogGyro_stabilizingCallback, args)

    def userTaskCallback(*args):
        """userTaskCallback(self)"""
        return apply(_AriaPy.ArAnalogGyro_userTaskCallback, args)

    def setLogAnomalies(*args):
        """setLogAnomalies(self, bool logAnomalies)"""
        return apply(_AriaPy.ArAnalogGyro_setLogAnomalies, args)

ArAnalogGyro_swigregister = _AriaPy.ArAnalogGyro_swigregister
ArAnalogGyro_swigregister(ArAnalogGyro)

class ArArg:
    """Proxy of C++ ArArg class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArArg, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArArg, name)
    __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__(self) -> ArArg
        __init__(self, char name, int pointer, char description="", int minInt=INT_MIN, 
            int maxInt=INT_MAX) -> ArArg
        __init__(self, char name, int pointer, char description="", int minInt=INT_MIN) -> ArArg
        __init__(self, char name, int pointer, char description="") -> ArArg
        __init__(self, char name, int pointer) -> ArArg
        __init__(self, char name, double pointer, char description="", double minDouble=-HUGE_VAL, 
            double maxDouble=HUGE_VAL) -> ArArg
        __init__(self, char name, double pointer, char description="", double minDouble=-HUGE_VAL) -> ArArg
        __init__(self, char name, double pointer, char description="") -> ArArg
        __init__(self, char name, double pointer) -> ArArg
        __init__(self, char name, bool pointer, char description="") -> ArArg
        __init__(self, char name, bool pointer) -> ArArg
        __init__(self, char name, ArPose pointer, char description="") -> ArArg
        __init__(self, char name, ArPose pointer) -> ArArg
        __init__(self, char name, char pointer, char description, size_t maxStrLen) -> ArArg
        __init__(self, char name, ArRetFunctor1_Bool_ArgumentBuilderP setFunctor, 
            ArRetFunctor<(p.q(const).std::list<(p.ArArgumentBuilder,std::allocator<(p.ArArgumentBuilder)>)>)> getFunctor, 
            char description) -> ArArg
        __init__(self, char description) -> ArArg
        __init__(self, ArArg arg) -> ArArg
        """
        this = apply(_AriaPy.new_ArArg, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArArg
    __del__ = lambda self : None;
    def getType(*args):
        """getType(self) -> int"""
        return apply(_AriaPy.ArArg_getType, args)

    def getName(*args):
        """getName(self) -> char"""
        return apply(_AriaPy.ArArg_getName, args)

    def getDescription(*args):
        """getDescription(self) -> char"""
        return apply(_AriaPy.ArArg_getDescription, args)

    def setInt(*args):
        """setInt(self, int val) -> bool"""
        return apply(_AriaPy.ArArg_setInt, args)

    def setDouble(*args):
        """setDouble(self, double val) -> bool"""
        return apply(_AriaPy.ArArg_setDouble, args)

    def setBool(*args):
        """setBool(self, bool val) -> bool"""
        return apply(_AriaPy.ArArg_setBool, args)

    def setPose(*args):
        """setPose(self, ArPose pose) -> bool"""
        return apply(_AriaPy.ArArg_setPose, args)

    def setString(*args):
        """setString(self, char str) -> bool"""
        return apply(_AriaPy.ArArg_setString, args)

    def setArgWithFunctor(*args):
        """setArgWithFunctor(self, ArArgumentBuilder argument) -> bool"""
        return apply(_AriaPy.ArArg_setArgWithFunctor, args)

    def getInt(*args):
        """getInt(self) -> int"""
        return apply(_AriaPy.ArArg_getInt, args)

    def getDouble(*args):
        """getDouble(self) -> double"""
        return apply(_AriaPy.ArArg_getDouble, args)

    def getBool(*args):
        """getBool(self) -> bool"""
        return apply(_AriaPy.ArArg_getBool, args)

    def getPose(*args):
        """getPose(self) -> ArPose"""
        return apply(_AriaPy.ArArg_getPose, args)

    def getString(*args):
        """getString(self) -> char"""
        return apply(_AriaPy.ArArg_getString, args)

    def getArgsWithFunctor(*args):
        """getArgsWithFunctor(self) -> ArArgumentBuilderPtrList"""
        return apply(_AriaPy.ArArg_getArgsWithFunctor, args)

    def log(*args):
        """log(self)"""
        return apply(_AriaPy.ArArg_log, args)

    def getMinInt(*args):
        """getMinInt(self) -> int"""
        return apply(_AriaPy.ArArg_getMinInt, args)

    def getMaxInt(*args):
        """getMaxInt(self) -> int"""
        return apply(_AriaPy.ArArg_getMaxInt, args)

    def getMinDouble(*args):
        """getMinDouble(self) -> double"""
        return apply(_AriaPy.ArArg_getMinDouble, args)

    def getMaxDouble(*args):
        """getMaxDouble(self) -> double"""
        return apply(_AriaPy.ArArg_getMaxDouble, args)

    def getConfigPrioritySet(*args):
        """getConfigPrioritySet(self) -> bool"""
        return apply(_AriaPy.ArArg_getConfigPrioritySet, args)

    def getConfigPriority(*args):
        """getConfigPriority(self) -> int"""
        return apply(_AriaPy.ArArg_getConfigPriority, args)

    def setConfigPriority(*args):
        """setConfigPriority(self, Priority priority)"""
        return apply(_AriaPy.ArArg_setConfigPriority, args)

ArArg_swigregister = _AriaPy.ArArg_swigregister
ArArg_swigregister(ArArg)

class ArArgumentBuilder:
    """Proxy of C++ ArArgumentBuilder class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArArgumentBuilder, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArArgumentBuilder, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, size_t argvLen=512, char extraSpaceChar='\0') -> ArArgumentBuilder
        __init__(self, size_t argvLen=512) -> ArArgumentBuilder
        __init__(self) -> ArArgumentBuilder
        __init__(self, ArArgumentBuilder builder) -> ArArgumentBuilder
        """
        this = apply(_AriaPy.new_ArArgumentBuilder, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArArgumentBuilder
    __del__ = lambda self : None;
    def addPlain(*args):
        """
        addPlain(self, char str, int position=-1)
        addPlain(self, char str)
        """
        return apply(_AriaPy.ArArgumentBuilder_addPlain, args)

    def addPlainAsIs(*args):
        """
        addPlainAsIs(self, char str, int position=-1)
        addPlainAsIs(self, char str)
        """
        return apply(_AriaPy.ArArgumentBuilder_addPlainAsIs, args)

    def addStrings(*args):
        """
        addStrings(self, char argv, int argc, int position=-1)
        addStrings(self, char argv, int argc)
        addStrings(self, int argc, char argv, int position=-1)
        addStrings(self, int argc, char argv)
        """
        return apply(_AriaPy.ArArgumentBuilder_addStrings, args)

    def addStringsAsIs(*args):
        """
        addStringsAsIs(self, int argc, char argv, int position=-1)
        addStringsAsIs(self, int argc, char argv)
        """
        return apply(_AriaPy.ArArgumentBuilder_addStringsAsIs, args)

    def getFullString(*args):
        """getFullString(self) -> char"""
        return apply(_AriaPy.ArArgumentBuilder_getFullString, args)

    def setFullString(*args):
        """setFullString(self, char str)"""
        return apply(_AriaPy.ArArgumentBuilder_setFullString, args)

    def getExtraString(*args):
        """getExtraString(self) -> char"""
        return apply(_AriaPy.ArArgumentBuilder_getExtraString, args)

    def setExtraString(*args):
        """setExtraString(self, char str)"""
        return apply(_AriaPy.ArArgumentBuilder_setExtraString, args)

    def log(*args):
        """log(self)"""
        return apply(_AriaPy.ArArgumentBuilder_log, args)

    def getArgc(*args):
        """getArgc(self) -> size_t"""
        return apply(_AriaPy.ArArgumentBuilder_getArgc, args)

    def getArgv(*args):
        """getArgv(self) -> char"""
        return apply(_AriaPy.ArArgumentBuilder_getArgv, args)

    def getArg(*args):
        """getArg(self, size_t whichArg) -> char"""
        return apply(_AriaPy.ArArgumentBuilder_getArg, args)

    def isArgBool(*args):
        """isArgBool(self, size_t whichArg) -> bool"""
        return apply(_AriaPy.ArArgumentBuilder_isArgBool, args)

    def getArgBool(*args):
        """
        getArgBool(self, size_t whichArg, bool ok=None) -> bool
        getArgBool(self, size_t whichArg) -> bool
        """
        return apply(_AriaPy.ArArgumentBuilder_getArgBool, args)

    def isArgInt(*args):
        """isArgInt(self, size_t whichArg) -> bool"""
        return apply(_AriaPy.ArArgumentBuilder_isArgInt, args)

    def getArgInt(*args):
        """
        getArgInt(self, size_t whichArg, bool ok=None) -> int
        getArgInt(self, size_t whichArg) -> int
        """
        return apply(_AriaPy.ArArgumentBuilder_getArgInt, args)

    def isArgDouble(*args):
        """isArgDouble(self, size_t whichArg) -> bool"""
        return apply(_AriaPy.ArArgumentBuilder_isArgDouble, args)

    def getArgDouble(*args):
        """
        getArgDouble(self, size_t whichArg, bool ok=None) -> double
        getArgDouble(self, size_t whichArg) -> double
        """
        return apply(_AriaPy.ArArgumentBuilder_getArgDouble, args)

    def removeArg(*args):
        """
        removeArg(self, size_t which, bool isRebuildFullString=False)
        removeArg(self, size_t which)
        """
        return apply(_AriaPy.ArArgumentBuilder_removeArg, args)

    def compressQuoted(*args):
        """
        compressQuoted(self, bool stripQuotationMarks=False)
        compressQuoted(self)
        """
        return apply(_AriaPy.ArArgumentBuilder_compressQuoted, args)

    def setQuiet(*args):
        """setQuiet(self, bool isQuiet)"""
        return apply(_AriaPy.ArArgumentBuilder_setQuiet, args)

ArArgumentBuilder_swigregister = _AriaPy.ArArgumentBuilder_swigregister
ArArgumentBuilder_swigregister(ArArgumentBuilder)

class ArArgumentParser:
    """Proxy of C++ ArArgumentParser class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArArgumentParser, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArArgumentParser, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, int argc) -> ArArgumentParser
        __init__(self, ArArgumentBuilder builder) -> ArArgumentParser
        """
        this = apply(_AriaPy.new_ArArgumentParser, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArArgumentParser
    __del__ = lambda self : None;
    def setWasReallySetOnlyTrue(*args):
        """setWasReallySetOnlyTrue(self, bool wasReallySetOnlyTrue)"""
        return apply(_AriaPy.ArArgumentParser_setWasReallySetOnlyTrue, args)

    def getWasReallySetOnlyTrue(*args):
        """getWasReallySetOnlyTrue(self) -> bool"""
        return apply(_AriaPy.ArArgumentParser_getWasReallySetOnlyTrue, args)

    def checkArgument(*args):
        """checkArgument(self, char argument) -> bool"""
        return apply(_AriaPy.ArArgumentParser_checkArgument, args)

    def checkParameterArgument(*args):
        """
        checkParameterArgument(self, char argument, bool returnFirst=False) -> char
        checkParameterArgument(self, char argument) -> char
        """
        return apply(_AriaPy.ArArgumentParser_checkParameterArgument, args)

    def checkParameterArgumentString(*args):
        """
        checkParameterArgumentString(self, char argument, char dest, bool wasReallySet=None, bool returnFirst=False) -> bool
        checkParameterArgumentString(self, char argument, char dest, bool wasReallySet=None) -> bool
        checkParameterArgumentString(self, char argument, char dest) -> bool
        """
        return apply(_AriaPy.ArArgumentParser_checkParameterArgumentString, args)

    def checkParameterArgumentInteger(*args):
        """
        checkParameterArgumentInteger(self, char argument, int dest, bool wasReallySet=None, bool returnFirst=False) -> bool
        checkParameterArgumentInteger(self, char argument, int dest, bool wasReallySet=None) -> bool
        checkParameterArgumentInteger(self, char argument, int dest) -> bool
        """
        return apply(_AriaPy.ArArgumentParser_checkParameterArgumentInteger, args)

    def checkParameterArgumentBool(*args):
        """
        checkParameterArgumentBool(self, char argument, bool dest, bool wasReallySet=None, bool returnFirst=False) -> bool
        checkParameterArgumentBool(self, char argument, bool dest, bool wasReallySet=None) -> bool
        checkParameterArgumentBool(self, char argument, bool dest) -> bool
        """
        return apply(_AriaPy.ArArgumentParser_checkParameterArgumentBool, args)

    def checkParameterArgumentFloat(*args):
        """
        checkParameterArgumentFloat(self, char argument, float dest, bool wasReallySet=None, 
            bool returnFirst=False) -> bool
        checkParameterArgumentFloat(self, char argument, float dest, bool wasReallySet=None) -> bool
        checkParameterArgumentFloat(self, char argument, float dest) -> bool
        """
        return apply(_AriaPy.ArArgumentParser_checkParameterArgumentFloat, args)

    def checkParameterArgumentDouble(*args):
        """
        checkParameterArgumentDouble(self, char argument, double dest, bool wasReallySet=None, 
            bool returnFirst=False) -> bool
        checkParameterArgumentDouble(self, char argument, double dest, bool wasReallySet=None) -> bool
        checkParameterArgumentDouble(self, char argument, double dest) -> bool
        """
        return apply(_AriaPy.ArArgumentParser_checkParameterArgumentDouble, args)

    def addDefaultArgument(*args):
        """
        addDefaultArgument(self, char argument, int position=-1)
        addDefaultArgument(self, char argument)
        """
        return apply(_AriaPy.ArArgumentParser_addDefaultArgument, args)

    def loadDefaultArguments(*args):
        """
        loadDefaultArguments(self, int positon=1)
        loadDefaultArguments(self)
        """
        return apply(_AriaPy.ArArgumentParser_loadDefaultArguments, args)

    def checkHelpAndWarnUnparsed(*args):
        """
        checkHelpAndWarnUnparsed(self, unsigned int numArgsOkay=0) -> bool
        checkHelpAndWarnUnparsed(self) -> bool
        """
        return apply(_AriaPy.ArArgumentParser_checkHelpAndWarnUnparsed, args)

    def getArgc(*args):
        """getArgc(self) -> size_t"""
        return apply(_AriaPy.ArArgumentParser_getArgc, args)

    def getArgv(*args):
        """getArgv(self) -> char"""
        return apply(_AriaPy.ArArgumentParser_getArgv, args)

    def getArg(*args):
        """getArg(self, size_t whichArg) -> char"""
        return apply(_AriaPy.ArArgumentParser_getArg, args)

    def log(*args):
        """log(self)"""
        return apply(_AriaPy.ArArgumentParser_log, args)

    def getStartingArguments(*args):
        """getStartingArguments(self) -> char"""
        return apply(_AriaPy.ArArgumentParser_getStartingArguments, args)

    def removeArg(*args):
        """removeArg(self, size_t which)"""
        return apply(_AriaPy.ArArgumentParser_removeArg, args)

    __swig_getmethods__["addDefaultArgumentFile"] = lambda x: _AriaPy.ArArgumentParser_addDefaultArgumentFile
    __swig_getmethods__["addDefaultArgumentEnv"] = lambda x: _AriaPy.ArArgumentParser_addDefaultArgumentEnv
    __swig_getmethods__["logDefaultArgumentLocations"] = lambda x: _AriaPy.ArArgumentParser_logDefaultArgumentLocations
ArArgumentParser_swigregister = _AriaPy.ArArgumentParser_swigregister
ArArgumentParser_swigregister(ArArgumentParser)

def ArArgumentParser_addDefaultArgumentFile(*args):
  """ArArgumentParser_addDefaultArgumentFile(char file)"""
  return apply(_AriaPy.ArArgumentParser_addDefaultArgumentFile, args)

def ArArgumentParser_addDefaultArgumentEnv(*args):
  """ArArgumentParser_addDefaultArgumentEnv(char env)"""
  return apply(_AriaPy.ArArgumentParser_addDefaultArgumentEnv, args)

def ArArgumentParser_logDefaultArgumentLocations(*args):
  """ArArgumentParser_logDefaultArgumentLocations()"""
  return apply(_AriaPy.ArArgumentParser_logDefaultArgumentLocations, args)

class ArBumpers(ArRangeDevice):
    """Proxy of C++ ArBumpers class"""
    __swig_setmethods__ = {}
    for _s in [ArRangeDevice]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArBumpers, name, value)
    __swig_getmethods__ = {}
    for _s in [ArRangeDevice]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArBumpers, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, size_t currentBufferSize=30, size_t cumulativeBufferSize=30, 
            char name="bumpers", int maxSecondsToKeepCurrent=15, 
            double angleRange=135) -> ArBumpers
        __init__(self, size_t currentBufferSize=30, size_t cumulativeBufferSize=30, 
            char name="bumpers", int maxSecondsToKeepCurrent=15) -> ArBumpers
        __init__(self, size_t currentBufferSize=30, size_t cumulativeBufferSize=30, 
            char name="bumpers") -> ArBumpers
        __init__(self, size_t currentBufferSize=30, size_t cumulativeBufferSize=30) -> ArBumpers
        __init__(self, size_t currentBufferSize=30) -> ArBumpers
        __init__(self) -> ArBumpers
        """
        this = apply(_AriaPy.new_ArBumpers, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArBumpers
    __del__ = lambda self : None;
    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArBumpers_setRobot, args)

    def processReadings(*args):
        """processReadings(self)"""
        return apply(_AriaPy.ArBumpers_processReadings, args)

    def addBumpToBuffer(*args):
        """addBumpToBuffer(self, int bumpValue, int whichBumper)"""
        return apply(_AriaPy.ArBumpers_addBumpToBuffer, args)

ArBumpers_swigregister = _AriaPy.ArBumpers_swigregister
ArBumpers_swigregister(ArBumpers)

class ArCameraCollection:
    """Proxy of C++ ArCameraCollection class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArCameraCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArCameraCollection, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArCameraCollection"""
        this = apply(_AriaPy.new_ArCameraCollection, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArCameraCollection
    __del__ = lambda self : None;
    def addCamera(*args):
        """
        addCamera(self, char cameraName, char cameraType, char displayName, 
            char displayType) -> bool
        """
        return apply(_AriaPy.ArCameraCollection_addCamera, args)

    def removeCamera(*args):
        """removeCamera(self, char cameraName) -> bool"""
        return apply(_AriaPy.ArCameraCollection_removeCamera, args)

    def addCameraCommand(*args):
        """
        addCameraCommand(self, char cameraName, char command, char cameraCommandName, 
            int requestInterval=-1) -> bool
        addCameraCommand(self, char cameraName, char command, char cameraCommandName) -> bool
        """
        return apply(_AriaPy.ArCameraCollection_addCameraCommand, args)

    def removeCameraCommand(*args):
        """removeCameraCommand(self, char cameraName, char command) -> bool"""
        return apply(_AriaPy.ArCameraCollection_removeCameraCommand, args)

    def addParameter(*args):
        """addParameter(self, char cameraName, ArCameraParameterSource source, ArConfigArg param) -> bool"""
        return apply(_AriaPy.ArCameraCollection_addParameter, args)

    def removeParameter(*args):
        """removeParameter(self, char cameraName, char paramName) -> bool"""
        return apply(_AriaPy.ArCameraCollection_removeParameter, args)

    def getCameraNames(*args):
        """getCameraNames(self, std::list<(std::string,std::allocator<(std::string)>)> outList)"""
        return apply(_AriaPy.ArCameraCollection_getCameraNames, args)

    def getCameraType(*args):
        """getCameraType(self, char cameraName) -> char"""
        return apply(_AriaPy.ArCameraCollection_getCameraType, args)

    def getDisplayName(*args):
        """getDisplayName(self, char cameraName) -> char"""
        return apply(_AriaPy.ArCameraCollection_getDisplayName, args)

    def getDisplayType(*args):
        """getDisplayType(self, char cameraName) -> char"""
        return apply(_AriaPy.ArCameraCollection_getDisplayType, args)

    def getCameraCommands(*args):
        """getCameraCommands(self, char cameraName, std::list<(std::string,std::allocator<(std::string)>)> outList)"""
        return apply(_AriaPy.ArCameraCollection_getCameraCommands, args)

    def getCommandName(*args):
        """getCommandName(self, char cameraName, char command) -> char"""
        return apply(_AriaPy.ArCameraCollection_getCommandName, args)

    def getRequestInterval(*args):
        """getRequestInterval(self, char cameraName, char command) -> int"""
        return apply(_AriaPy.ArCameraCollection_getRequestInterval, args)

    def getParameterNames(*args):
        """getParameterNames(self, char cameraName, std::list<(std::string,std::allocator<(std::string)>)> outList)"""
        return apply(_AriaPy.ArCameraCollection_getParameterNames, args)

    def getParameter(*args):
        """getParameter(self, char cameraName, char parameterName, ArConfigArg paramOut) -> bool"""
        return apply(_AriaPy.ArCameraCollection_getParameter, args)

    def setParameter(*args):
        """setParameter(self, char cameraName, ArConfigArg param) -> bool"""
        return apply(_AriaPy.ArCameraCollection_setParameter, args)

    def exists(*args):
        """
        exists(self, char cameraName) -> bool
        exists(self, char cameraName, char command) -> bool
        """
        return apply(_AriaPy.ArCameraCollection_exists, args)

    def parameterExists(*args):
        """parameterExists(self, char cameraName, char paramName) -> bool"""
        return apply(_AriaPy.ArCameraCollection_parameterExists, args)

    def addModifiedCB(*args):
        """
        addModifiedCB(self, ArFunctor functor, Pos position=LAST) -> bool
        addModifiedCB(self, ArFunctor functor) -> bool
        """
        return apply(_AriaPy.ArCameraCollection_addModifiedCB, args)

    def removeModifiedCB(*args):
        """removeModifiedCB(self, ArFunctor functor) -> bool"""
        return apply(_AriaPy.ArCameraCollection_removeModifiedCB, args)

    def startUpdate(*args):
        """startUpdate(self)"""
        return apply(_AriaPy.ArCameraCollection_startUpdate, args)

    def endUpdate(*args):
        """endUpdate(self)"""
        return apply(_AriaPy.ArCameraCollection_endUpdate, args)

    def lock(*args):
        """lock(self) -> int"""
        return apply(_AriaPy.ArCameraCollection_lock, args)

    def tryLock(*args):
        """tryLock(self) -> int"""
        return apply(_AriaPy.ArCameraCollection_tryLock, args)

    def unlock(*args):
        """unlock(self) -> int"""
        return apply(_AriaPy.ArCameraCollection_unlock, args)

ArCameraCollection_swigregister = _AriaPy.ArCameraCollection_swigregister
ArCameraCollection_swigregister(ArCameraCollection)

class ArCameraCollectionItem:
    """Proxy of C++ ArCameraCollectionItem class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArCameraCollectionItem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArCameraCollectionItem, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArCameraCollectionItem
    __del__ = lambda self : None;
    def getCameraName(*args):
        """getCameraName(self) -> char"""
        return apply(_AriaPy.ArCameraCollectionItem_getCameraName, args)

    def addToCameraCollection(*args):
        """addToCameraCollection(self, ArCameraCollection collection)"""
        return apply(_AriaPy.ArCameraCollectionItem_addToCameraCollection, args)

ArCameraCollectionItem_swigregister = _AriaPy.ArCameraCollectionItem_swigregister
ArCameraCollectionItem_swigregister(ArCameraCollectionItem)

class ArCameraParameterSource(ArCameraCollectionItem):
    """Proxy of C++ ArCameraParameterSource class"""
    __swig_setmethods__ = {}
    for _s in [ArCameraCollectionItem]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArCameraParameterSource, name, value)
    __swig_getmethods__ = {}
    for _s in [ArCameraCollectionItem]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArCameraParameterSource, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArCameraParameterSource
    __del__ = lambda self : None;
    def getParameter(*args):
        """getParameter(self, char paramName, ArConfigArg paramOut) -> bool"""
        return apply(_AriaPy.ArCameraParameterSource_getParameter, args)

    def setParameter(*args):
        """setParameter(self, ArConfigArg param) -> bool"""
        return apply(_AriaPy.ArCameraParameterSource_setParameter, args)

ArCameraParameterSource_swigregister = _AriaPy.ArCameraParameterSource_swigregister
ArCameraParameterSource_swigregister(ArCameraParameterSource)

class ArCameraCommands:
    """Proxy of C++ ArCameraCommands class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArCameraCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArCameraCommands, name)
    __repr__ = _swig_repr
    __swig_setmethods__["GET_CAMERA_DATA"] = _AriaPy.ArCameraCommands_GET_CAMERA_DATA_set
    __swig_getmethods__["GET_CAMERA_DATA"] = _AriaPy.ArCameraCommands_GET_CAMERA_DATA_get
    __swig_setmethods__["GET_CAMERA_INFO"] = _AriaPy.ArCameraCommands_GET_CAMERA_INFO_set
    __swig_getmethods__["GET_CAMERA_INFO"] = _AriaPy.ArCameraCommands_GET_CAMERA_INFO_get
    __swig_setmethods__["GET_PICTURE"] = _AriaPy.ArCameraCommands_GET_PICTURE_set
    __swig_getmethods__["GET_PICTURE"] = _AriaPy.ArCameraCommands_GET_PICTURE_get
    __swig_setmethods__["GET_PICTURE_OPTIM"] = _AriaPy.ArCameraCommands_GET_PICTURE_OPTIM_set
    __swig_getmethods__["GET_PICTURE_OPTIM"] = _AriaPy.ArCameraCommands_GET_PICTURE_OPTIM_get
    __swig_setmethods__["GET_SNAPSHOT"] = _AriaPy.ArCameraCommands_GET_SNAPSHOT_set
    __swig_getmethods__["GET_SNAPSHOT"] = _AriaPy.ArCameraCommands_GET_SNAPSHOT_get
    __swig_setmethods__["GET_DISPLAY"] = _AriaPy.ArCameraCommands_GET_DISPLAY_set
    __swig_getmethods__["GET_DISPLAY"] = _AriaPy.ArCameraCommands_GET_DISPLAY_get
    __swig_setmethods__["SET_CAMERA_ABS"] = _AriaPy.ArCameraCommands_SET_CAMERA_ABS_set
    __swig_getmethods__["SET_CAMERA_ABS"] = _AriaPy.ArCameraCommands_SET_CAMERA_ABS_get
    __swig_setmethods__["SET_CAMERA_PCT"] = _AriaPy.ArCameraCommands_SET_CAMERA_PCT_set
    __swig_getmethods__["SET_CAMERA_PCT"] = _AriaPy.ArCameraCommands_SET_CAMERA_PCT_get
    __swig_setmethods__["SET_CAMERA_REL"] = _AriaPy.ArCameraCommands_SET_CAMERA_REL_set
    __swig_getmethods__["SET_CAMERA_REL"] = _AriaPy.ArCameraCommands_SET_CAMERA_REL_get
    __swig_setmethods__["GET_CAMERA_MODE_LIST"] = _AriaPy.ArCameraCommands_GET_CAMERA_MODE_LIST_set
    __swig_getmethods__["GET_CAMERA_MODE_LIST"] = _AriaPy.ArCameraCommands_GET_CAMERA_MODE_LIST_get
    __swig_setmethods__["CAMERA_MODE_UPDATED"] = _AriaPy.ArCameraCommands_CAMERA_MODE_UPDATED_set
    __swig_getmethods__["CAMERA_MODE_UPDATED"] = _AriaPy.ArCameraCommands_CAMERA_MODE_UPDATED_get
    __swig_setmethods__["SET_CAMERA_MODE"] = _AriaPy.ArCameraCommands_SET_CAMERA_MODE_set
    __swig_getmethods__["SET_CAMERA_MODE"] = _AriaPy.ArCameraCommands_SET_CAMERA_MODE_get
    __swig_setmethods__["RESET_CAMERA"] = _AriaPy.ArCameraCommands_RESET_CAMERA_set
    __swig_getmethods__["RESET_CAMERA"] = _AriaPy.ArCameraCommands_RESET_CAMERA_get
    __swig_setmethods__["GET_CAMERA_DATA_INT"] = _AriaPy.ArCameraCommands_GET_CAMERA_DATA_INT_set
    __swig_getmethods__["GET_CAMERA_DATA_INT"] = _AriaPy.ArCameraCommands_GET_CAMERA_DATA_INT_get
    __swig_setmethods__["GET_CAMERA_INFO_INT"] = _AriaPy.ArCameraCommands_GET_CAMERA_INFO_INT_set
    __swig_getmethods__["GET_CAMERA_INFO_INT"] = _AriaPy.ArCameraCommands_GET_CAMERA_INFO_INT_get
    __swig_setmethods__["SET_CAMERA_ABS_INT"] = _AriaPy.ArCameraCommands_SET_CAMERA_ABS_INT_set
    __swig_getmethods__["SET_CAMERA_ABS_INT"] = _AriaPy.ArCameraCommands_SET_CAMERA_ABS_INT_get
    __swig_setmethods__["SET_CAMERA_REL_INT"] = _AriaPy.ArCameraCommands_SET_CAMERA_REL_INT_set
    __swig_getmethods__["SET_CAMERA_REL_INT"] = _AriaPy.ArCameraCommands_SET_CAMERA_REL_INT_get
    __swig_setmethods__["SET_CAMERA_PCT_INT"] = _AriaPy.ArCameraCommands_SET_CAMERA_PCT_INT_set
    __swig_getmethods__["SET_CAMERA_PCT_INT"] = _AriaPy.ArCameraCommands_SET_CAMERA_PCT_INT_get
    __swig_setmethods__["GET_VIDEO"] = _AriaPy.ArCameraCommands_GET_VIDEO_set
    __swig_getmethods__["GET_VIDEO"] = _AriaPy.ArCameraCommands_GET_VIDEO_get
    __swig_setmethods__["GET_SNAPSHOT_PLAIN"] = _AriaPy.ArCameraCommands_GET_SNAPSHOT_PLAIN_set
    __swig_getmethods__["GET_SNAPSHOT_PLAIN"] = _AriaPy.ArCameraCommands_GET_SNAPSHOT_PLAIN_get
    def __init__(self, *args): 
        """__init__(self) -> ArCameraCommands"""
        this = apply(_AriaPy.new_ArCameraCommands, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArCameraCommands
    __del__ = lambda self : None;
ArCameraCommands_swigregister = _AriaPy.ArCameraCommands_swigregister
ArCameraCommands_swigregister(ArCameraCommands)

class ArCommands:
    """Proxy of C++ ArCommands class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArCommands, name)
    __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
    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
    TTY3 = _AriaPy.ArCommands_TTY3
    GETAUX2 = _AriaPy.ArCommands_GETAUX2
    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
    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, *args): 
        """__init__(self) -> ArCommands"""
        this = apply(_AriaPy.new_ArCommands, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArCommands
    __del__ = lambda self : None;
ArCommands_swigregister = _AriaPy.ArCommands_swigregister
ArCommands_swigregister(ArCommands)

class ArCondition:
    """Proxy of C++ ArCondition class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArCondition, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArCondition, name)
    __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, *args): 
        """__init__(self) -> ArCondition"""
        this = apply(_AriaPy.new_ArCondition, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArCondition
    __del__ = lambda self : None;
    def signal(*args):
        """signal(self) -> int"""
        return apply(_AriaPy.ArCondition_signal, args)

    def broadcast(*args):
        """broadcast(self) -> int"""
        return apply(_AriaPy.ArCondition_broadcast, args)

    def wait(*args):
        """wait(self) -> int"""
        return apply(_AriaPy.ArCondition_wait, args)

    def timedWait(*args):
        """timedWait(self, unsigned int msecs) -> int"""
        return apply(_AriaPy.ArCondition_timedWait, args)

    def getError(*args):
        """getError(self, int messageNumber) -> char"""
        return apply(_AriaPy.ArCondition_getError, args)

ArCondition_swigregister = _AriaPy.ArCondition_swigregister
ArCondition_swigregister(ArCondition)

class ArConfig:
    """Proxy of C++ ArConfig class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArConfig, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char baseDirectory=None, bool noBlanksBetweenParams=False, 
            bool ignoreBounds=False, bool failOnBadSection=False, 
            bool saveUnknown=True) -> ArConfig
        __init__(self, char baseDirectory=None, bool noBlanksBetweenParams=False, 
            bool ignoreBounds=False, bool failOnBadSection=False) -> ArConfig
        __init__(self, char baseDirectory=None, bool noBlanksBetweenParams=False, 
            bool ignoreBounds=False) -> ArConfig
        __init__(self, char baseDirectory=None, bool noBlanksBetweenParams=False) -> ArConfig
        __init__(self, char baseDirectory=None) -> ArConfig
        __init__(self) -> ArConfig
        __init__(self, ArConfig config) -> ArConfig
        """
        this = apply(_AriaPy.new_ArConfig, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArConfig
    __del__ = lambda self : None;
    def setConfigName(*args):
        """
        setConfigName(self, char configName, char robotName=None)
        setConfigName(self, char configName)
        """
        return apply(_AriaPy.ArConfig_setConfigName, args)

    def setQuiet(*args):
        """setQuiet(self, bool isQuiet)"""
        return apply(_AriaPy.ArConfig_setQuiet, args)

    def parseFile(*args):
        """
        parseFile(self, char 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(self, char fileName, bool continueOnError=False, bool noFileNotFoundMessage=False, 
            char errorBuffer=None, 
            size_t errorBufferLen=0) -> bool
        parseFile(self, char fileName, bool continueOnError=False, bool noFileNotFoundMessage=False, 
            char errorBuffer=None) -> bool
        parseFile(self, char fileName, bool continueOnError=False, bool noFileNotFoundMessage=False) -> bool
        parseFile(self, char fileName, bool continueOnError=False) -> bool
        parseFile(self, char fileName) -> bool
        """
        return apply(_AriaPy.ArConfig_parseFile, args)

    def writeFile(*args):
        """
        writeFile(self, char fileName, bool append=False, std::set<(std::string,std::less<(std::string)>,std::allocator<(std::string)>)> alreadyWritten=None, 
            bool writePriorities=False, 
            std::list<(std::string,std::allocator<(std::string)>)> sectionsToWrite=None) -> bool
        writeFile(self, char fileName, bool append=False, std::set<(std::string,std::less<(std::string)>,std::allocator<(std::string)>)> alreadyWritten=None, 
            bool writePriorities=False) -> bool
        writeFile(self, char fileName, bool append=False, std::set<(std::string,std::less<(std::string)>,std::allocator<(std::string)>)> alreadyWritten=None) -> bool
        writeFile(self, char fileName, bool append=False) -> bool
        writeFile(self, char fileName) -> bool
        """
        return apply(_AriaPy.ArConfig_writeFile, args)

    def addParam(*args):
        """
        addParam(self, ArConfigArg arg, char sectionName="", Priority priority=NORMAL, 
            char displayHint=None) -> bool
        addParam(self, ArConfigArg arg, char sectionName="", Priority priority=NORMAL) -> bool
        addParam(self, ArConfigArg arg, char sectionName="") -> bool
        addParam(self, ArConfigArg arg) -> bool
        """
        return apply(_AriaPy.ArConfig_addParam, args)

    def addComment(*args):
        """
        addComment(self, char comment, char sectionName="", Priority priority=NORMAL) -> bool
        addComment(self, char comment, char sectionName="") -> bool
        addComment(self, char comment) -> bool
        """
        return apply(_AriaPy.ArConfig_addComment, args)

    def setSectionComment(*args):
        """setSectionComment(self, char sectionName, char comment)"""
        return apply(_AriaPy.ArConfig_setSectionComment, args)

    def useArgumentParser(*args):
        """useArgumentParser(self, ArArgumentParser parser)"""
        return apply(_AriaPy.ArConfig_useArgumentParser, args)

    def processFile(*args):
        """processFile(self) -> bool"""
        return apply(_AriaPy.ArConfig_processFile, args)

    def addProcessFileCB(*args):
        """
        addProcessFileCB(self, ArRetFunctor_Bool functor, int priority=0)
        addProcessFileCB(self, ArRetFunctor_Bool functor)
        addProcessFileCB(self, ArRetFunctor2<(bool,p.char,size_t)> functor, int priority=0)
        addProcessFileCB(self, ArRetFunctor2<(bool,p.char,size_t)> functor)
        """
        return apply(_AriaPy.ArConfig_addProcessFileCB, args)

    def addProcessFileWithErrorCB(*args):
        """
        addProcessFileWithErrorCB(self, ArRetFunctor2<(bool,p.char,size_t)> functor, int priority=0)
        addProcessFileWithErrorCB(self, ArRetFunctor2<(bool,p.char,size_t)> functor)
        """
        return apply(_AriaPy.ArConfig_addProcessFileWithErrorCB, args)

    def remProcessFileCB(*args):
        """
        remProcessFileCB(self, ArRetFunctor_Bool functor)
        remProcessFileCB(self, ArRetFunctor2<(bool,p.char,size_t)> functor)
        """
        return apply(_AriaPy.ArConfig_remProcessFileCB, args)

    def callProcessFileCallBacks(*args):
        """
        callProcessFileCallBacks(self, bool continueOnError, char errorBuffer=None, size_t errorBufferLen=0) -> bool
        callProcessFileCallBacks(self, bool continueOnError, char errorBuffer=None) -> bool
        callProcessFileCallBacks(self, bool continueOnError) -> bool
        """
        return apply(_AriaPy.ArConfig_callProcessFileCallBacks, args)

    def parseArgument(*args):
        """
        parseArgument(self, ArArgumentBuilder arg, char errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseArgument(self, ArArgumentBuilder arg, char errorBuffer=None) -> bool
        parseArgument(self, ArArgumentBuilder arg) -> bool
        """
        return apply(_AriaPy.ArConfig_parseArgument, args)

    def parseSection(*args):
        """
        parseSection(self, ArArgumentBuilder arg, char errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseSection(self, ArArgumentBuilder arg, char errorBuffer=None) -> bool
        parseSection(self, ArArgumentBuilder arg) -> bool
        """
        return apply(_AriaPy.ArConfig_parseSection, args)

    def parseUnknown(*args):
        """
        parseUnknown(self, ArArgumentBuilder arg, char errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseUnknown(self, ArArgumentBuilder arg, char errorBuffer=None) -> bool
        parseUnknown(self, ArArgumentBuilder arg) -> bool
        """
        return apply(_AriaPy.ArConfig_parseUnknown, args)

    def getBaseDirectory(*args):
        """getBaseDirectory(self) -> char"""
        return apply(_AriaPy.ArConfig_getBaseDirectory, args)

    def setBaseDirectory(*args):
        """setBaseDirectory(self, char baseDirectory)"""
        return apply(_AriaPy.ArConfig_setBaseDirectory, args)

    def getFileName(*args):
        """getFileName(self) -> char"""
        return apply(_AriaPy.ArConfig_getFileName, args)

    def setNoBlanksBetweenParams(*args):
        """setNoBlanksBetweenParams(self, bool noBlanksBetweenParams)"""
        return apply(_AriaPy.ArConfig_setNoBlanksBetweenParams, args)

    def getNoBlanksBetweenParams(*args):
        """getNoBlanksBetweenParams(self) -> bool"""
        return apply(_AriaPy.ArConfig_getNoBlanksBetweenParams, args)

    def parseArgumentParser(*args):
        """
        parseArgumentParser(self, ArArgumentParser parser, bool continueOnError=False, 
            char errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseArgumentParser(self, ArArgumentParser parser, bool continueOnError=False, 
            char errorBuffer=None) -> bool
        parseArgumentParser(self, ArArgumentParser parser, bool continueOnError=False) -> bool
        parseArgumentParser(self, ArArgumentParser parser) -> bool
        """
        return apply(_AriaPy.ArConfig_parseArgumentParser, args)

    def getSections(*args):
        """getSections(self) -> std::list<(p.ArConfigSection,std::allocator<(p.ArConfigSection)>)>"""
        return apply(_AriaPy.ArConfig_getSections, args)

    def findSection(*args):
        """findSection(self, char sectionName) -> ArConfigSection"""
        return apply(_AriaPy.ArConfig_findSection, args)

    def setProcessFileCallbacksLogLevel(*args):
        """setProcessFileCallbacksLogLevel(self, LogLevel level)"""
        return apply(_AriaPy.ArConfig_setProcessFileCallbacksLogLevel, args)

    def getProcessFileCallbacksLogLevel(*args):
        """getProcessFileCallbacksLogLevel(self) -> int"""
        return apply(_AriaPy.ArConfig_getProcessFileCallbacksLogLevel, args)

    def setSaveUnknown(*args):
        """setSaveUnknown(self, bool saveUnknown)"""
        return apply(_AriaPy.ArConfig_setSaveUnknown, args)

    def getSaveUnknown(*args):
        """getSaveUnknown(self) -> bool"""
        return apply(_AriaPy.ArConfig_getSaveUnknown, args)

    def clearSections(*args):
        """clearSections(self)"""
        return apply(_AriaPy.ArConfig_clearSections, args)

    def clearAll(*args):
        """clearAll(self)"""
        return apply(_AriaPy.ArConfig_clearAll, args)

    def addSectionFlags(*args):
        """addSectionFlags(self, char sectionName, char flags) -> bool"""
        return apply(_AriaPy.ArConfig_addSectionFlags, args)

    def remSectionFlag(*args):
        """remSectionFlag(self, char sectionName, char flag) -> bool"""
        return apply(_AriaPy.ArConfig_remSectionFlag, args)

    def clearAllValueSet(*args):
        """clearAllValueSet(self)"""
        return apply(_AriaPy.ArConfig_clearAllValueSet, args)

    def removeAllUnsetValues(*args):
        """removeAllUnsetValues(self)"""
        return apply(_AriaPy.ArConfig_removeAllUnsetValues, args)

    def log(*args):
        """
        log(self, bool isSummary=True)
        log(self)
        """
        return apply(_AriaPy.ArConfig_log, args)

ArConfig_swigregister = _AriaPy.ArConfig_swigregister
ArConfig_swigregister(ArConfig)

class ArConfigSection:
    """Proxy of C++ ArConfigSection class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArConfigSection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArConfigSection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArConfigSection
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(self, char name=None, char comment=None) -> ArConfigSection
        __init__(self, char name=None) -> ArConfigSection
        __init__(self) -> ArConfigSection
        __init__(self, ArConfigSection section) -> ArConfigSection
        """
        this = apply(_AriaPy.new_ArConfigSection, args)
        try: self.this.append(this)
        except: self.this = this
    def getName(*args):
        """getName(self) -> char"""
        return apply(_AriaPy.ArConfigSection_getName, args)

    def getComment(*args):
        """getComment(self) -> char"""
        return apply(_AriaPy.ArConfigSection_getComment, args)

    def getFlags(*args):
        """getFlags(self) -> char"""
        return apply(_AriaPy.ArConfigSection_getFlags, args)

    def hasFlag(*args):
        """hasFlag(self, char flag) -> bool"""
        return apply(_AriaPy.ArConfigSection_hasFlag, args)

    def getParams(*args):
        """getParams(self) -> std::list<(ArConfigArg,std::allocator<(ArConfigArg)>)>"""
        return apply(_AriaPy.ArConfigSection_getParams, args)

    def setName(*args):
        """setName(self, char name)"""
        return apply(_AriaPy.ArConfigSection_setName, args)

    def setComment(*args):
        """setComment(self, char comment)"""
        return apply(_AriaPy.ArConfigSection_setComment, args)

    def addFlags(*args):
        """
        addFlags(self, char flags, bool isQuiet=False) -> bool
        addFlags(self, char flags) -> bool
        """
        return apply(_AriaPy.ArConfigSection_addFlags, args)

    def remFlag(*args):
        """remFlag(self, char dataFlag) -> bool"""
        return apply(_AriaPy.ArConfigSection_remFlag, args)

    def findParam(*args):
        """findParam(self, char paramName) -> ArConfigArg"""
        return apply(_AriaPy.ArConfigSection_findParam, args)

    def remStringHolder(*args):
        """remStringHolder(self, char paramName) -> bool"""
        return apply(_AriaPy.ArConfigSection_remStringHolder, args)

ArConfigSection_swigregister = _AriaPy.ArConfigSection_swigregister
ArConfigSection_swigregister(ArConfigSection)

class ArConfigArg:
    """Proxy of C++ ArConfigArg class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArConfigArg, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArConfigArg, name)
    __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
    LAST_TYPE = _AriaPy.ArConfigArg_LAST_TYPE
    TYPE_COUNT = _AriaPy.ArConfigArg_TYPE_COUNT
    def __init__(self, *args): 
        """
        __init__(self) -> ArConfigArg
        __init__(self, char name, int pointer, char description="", int minInt=INT_MIN) -> ArConfigArg
        __init__(self, char name, int pointer, char description="") -> ArConfigArg
        __init__(self, char name, int pointer) -> ArConfigArg
        __init__(self, char name, short pointer, char description="", int minInt=SHRT_MIN) -> ArConfigArg
        __init__(self, char name, short pointer, char description="") -> ArConfigArg
        __init__(self, char name, short pointer) -> ArConfigArg
        __init__(self, char name, unsigned short pointer, char description="", 
            int minInt=0) -> ArConfigArg
        __init__(self, char name, unsigned short pointer, char description="") -> ArConfigArg
        __init__(self, char name, unsigned short pointer) -> ArConfigArg
        __init__(self, char name, unsigned char pointer, char description="", 
            int minInt=0) -> ArConfigArg
        __init__(self, char name, unsigned char pointer, char description="") -> ArConfigArg
        __init__(self, char name, unsigned char pointer) -> ArConfigArg
        __init__(self, char name, double pointer, char description="", double minDouble=-HUGE_VAL) -> ArConfigArg
        __init__(self, char name, double pointer, char description="") -> ArConfigArg
        __init__(self, char name, double pointer) -> ArConfigArg
        __init__(self, char name, bool pointer) -> ArConfigArg
        __init__(self, char name, char str, char description, size_t maxStrLen) -> ArConfigArg
        __init__(self, char name, int val, char description="", int minInt=INT_MIN, 
            int maxInt=INT_MAX) -> ArConfigArg
        __init__(self, char name, int val, char description="", int minInt=INT_MIN) -> ArConfigArg
        __init__(self, char name, int val, char description="") -> ArConfigArg
        __init__(self, char name, int val) -> ArConfigArg
        __init__(self, char name, double val, char description="", double minDouble=-HUGE_VAL, 
            double maxDouble=HUGE_VAL) -> ArConfigArg
        __init__(self, char name, double val, char description="", double minDouble=-HUGE_VAL) -> ArConfigArg
        __init__(self, char name, double val, char description="") -> ArConfigArg
        __init__(self, char name, double val) -> ArConfigArg
        __init__(self, char name, bool val, char description="") -> ArConfigArg
        __init__(self, char name, bool val) -> ArConfigArg
        __init__(self, char name, ArRetFunctor1_Bool_ArgumentBuilderP setFunctor, 
            ArRetFunctor<(p.q(const).std::list<(p.ArArgumentBuilder,std::allocator<(p.ArArgumentBuilder)>)>)> getFunctor, 
            char description) -> ArConfigArg
        __init__(self, char str, Type type=DESCRIPTION_HOLDER) -> ArConfigArg
        __init__(self, char str) -> ArConfigArg
        __init__(self, char name, char str) -> ArConfigArg
        __init__(self, Type type) -> ArConfigArg
        __init__(self, ArConfigArg arg) -> ArConfigArg
        """
        this = apply(_AriaPy.new_ArConfigArg, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArConfigArg
    __del__ = lambda self : None;
    def getType(*args):
        """getType(self) -> int"""
        return apply(_AriaPy.ArConfigArg_getType, args)

    def getName(*args):
        """getName(self) -> char"""
        return apply(_AriaPy.ArConfigArg_getName, args)

    def getDescription(*args):
        """getDescription(self) -> char"""
        return apply(_AriaPy.ArConfigArg_getDescription, args)

    def setInt(*args):
        """
        setInt(self, int val, char errorBuffer=None, size_t errorBufferLen=0, 
            bool doNotSet=False) -> bool
        setInt(self, int val, char errorBuffer=None, size_t errorBufferLen=0) -> bool
        setInt(self, int val, char errorBuffer=None) -> bool
        setInt(self, int val) -> bool
        """
        return apply(_AriaPy.ArConfigArg_setInt, args)

    def setDouble(*args):
        """
        setDouble(self, double val, char errorBuffer=None, size_t errorBufferLen=0, 
            bool doNotSet=False) -> bool
        setDouble(self, double val, char errorBuffer=None, size_t errorBufferLen=0) -> bool
        setDouble(self, double val, char errorBuffer=None) -> bool
        setDouble(self, double val) -> bool
        """
        return apply(_AriaPy.ArConfigArg_setDouble, args)

    def setBool(*args):
        """
        setBool(self, bool val, char errorBuffer=None, size_t errorBufferLen=0, 
            bool doNotSet=False) -> bool
        setBool(self, bool val, char errorBuffer=None, size_t errorBufferLen=0) -> bool
        setBool(self, bool val, char errorBuffer=None) -> bool
        setBool(self, bool val) -> bool
        """
        return apply(_AriaPy.ArConfigArg_setBool, args)

    def setString(*args):
        """
        setString(self, char str, char errorBuffer=None, size_t errorBufferLen=0, 
            bool doNotSet=False) -> bool
        setString(self, char str, char errorBuffer=None, size_t errorBufferLen=0) -> bool
        setString(self, char str, char errorBuffer=None) -> bool
        setString(self, char str) -> bool
        """
        return apply(_AriaPy.ArConfigArg_setString, args)

    def setArgWithFunctor(*args):
        """
        setArgWithFunctor(self, ArArgumentBuilder argument, char errorBuffer=None, 
            size_t errorBufferLen=0, bool doNotSet=False) -> bool
        setArgWithFunctor(self, ArArgumentBuilder argument, char errorBuffer=None, 
            size_t errorBufferLen=0) -> bool
        setArgWithFunctor(self, ArArgumentBuilder argument, char errorBuffer=None) -> bool
        setArgWithFunctor(self, ArArgumentBuilder argument) -> bool
        """
        return apply(_AriaPy.ArConfigArg_setArgWithFunctor, args)

    def getInt(*args):
        """getInt(self) -> int"""
        return apply(_AriaPy.ArConfigArg_getInt, args)

    def getDouble(*args):
        """getDouble(self) -> double"""
        return apply(_AriaPy.ArConfigArg_getDouble, args)

    def getBool(*args):
        """getBool(self) -> bool"""
        return apply(_AriaPy.ArConfigArg_getBool, args)

    def getString(*args):
        """getString(self) -> char"""
        return apply(_AriaPy.ArConfigArg_getString, args)

    def getArgsWithFunctor(*args):
        """getArgsWithFunctor(self) -> ArArgumentBuilderPtrList"""
        return apply(_AriaPy.ArConfigArg_getArgsWithFunctor, args)

    def log(*args):
        """
        log(self, bool verbose=False)
        log(self)
        """
        return apply(_AriaPy.ArConfigArg_log, args)

    def getMinInt(*args):
        """getMinInt(self) -> int"""
        return apply(_AriaPy.ArConfigArg_getMinInt, args)

    def getMaxInt(*args):
        """getMaxInt(self) -> int"""
        return apply(_AriaPy.ArConfigArg_getMaxInt, args)

    def getMinDouble(*args):
        """getMinDouble(self) -> double"""
        return apply(_AriaPy.ArConfigArg_getMinDouble, args)

    def getMaxDouble(*args):
        """getMaxDouble(self) -> double"""
        return apply(_AriaPy.ArConfigArg_getMaxDouble, args)

    def getConfigPriority(*args):
        """getConfigPriority(self) -> int"""
        return apply(_AriaPy.ArConfigArg_getConfigPriority, args)

    def setConfigPriority(*args):
        """setConfigPriority(self, Priority priority)"""
        return apply(_AriaPy.ArConfigArg_setConfigPriority, args)

    def getDisplayHint(*args):
        """getDisplayHint(self) -> char"""
        return apply(_AriaPy.ArConfigArg_getDisplayHint, args)

    def setDisplayHint(*args):
        """setDisplayHint(self, char hintText)"""
        return apply(_AriaPy.ArConfigArg_setDisplayHint, args)

    def setIgnoreBounds(*args):
        """
        setIgnoreBounds(self, bool ignoreBounds=False)
        setIgnoreBounds(self)
        """
        return apply(_AriaPy.ArConfigArg_setIgnoreBounds, args)

    def isValueEqual(*args):
        """isValueEqual(self, ArConfigArg other) -> bool"""
        return apply(_AriaPy.ArConfigArg_isValueEqual, args)

    def setValue(*args):
        """setValue(self, ArConfigArg source) -> bool"""
        return apply(_AriaPy.ArConfigArg_setValue, args)

    def isValueSet(*args):
        """isValueSet(self) -> bool"""
        return apply(_AriaPy.ArConfigArg_isValueSet, args)

    def clearValueSet(*args):
        """clearValueSet(self)"""
        return apply(_AriaPy.ArConfigArg_clearValueSet, args)

ArConfigArg_swigregister = _AriaPy.ArConfigArg_swigregister
ArConfigArg_swigregister(ArConfigArg)

class ArConfigGroup:
    """Proxy of C++ ArConfigGroup class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArConfigGroup, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArConfigGroup, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char baseDirectory=None) -> ArConfigGroup
        __init__(self) -> ArConfigGroup
        """
        this = apply(_AriaPy.new_ArConfigGroup, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArConfigGroup
    __del__ = lambda self : None;
    def addConfig(*args):
        """addConfig(self, ArConfig config)"""
        return apply(_AriaPy.ArConfigGroup_addConfig, args)

    def remConfig(*args):
        """remConfig(self, ArConfig config)"""
        return apply(_AriaPy.ArConfigGroup_remConfig, args)

    def parseFile(*args):
        """
        parseFile(self, char fileName, bool continueOnError=False) -> bool
        parseFile(self, char fileName) -> bool
        """
        return apply(_AriaPy.ArConfigGroup_parseFile, args)

    def reloadFile(*args):
        """
        reloadFile(self, bool continueOnError=True) -> bool
        reloadFile(self) -> bool
        """
        return apply(_AriaPy.ArConfigGroup_reloadFile, args)

    def writeFile(*args):
        """writeFile(self, char fileName) -> bool"""
        return apply(_AriaPy.ArConfigGroup_writeFile, args)

    def setBaseDirectory(*args):
        """setBaseDirectory(self, char baseDirectory)"""
        return apply(_AriaPy.ArConfigGroup_setBaseDirectory, args)

    def getBaseDirectory(*args):
        """getBaseDirectory(self) -> char"""
        return apply(_AriaPy.ArConfigGroup_getBaseDirectory, args)

ArConfigGroup_swigregister = _AriaPy.ArConfigGroup_swigregister
ArConfigGroup_swigregister(ArConfigGroup)

class ArDataLogger:
    """Proxy of C++ ArDataLogger class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArDataLogger, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArDataLogger, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, char fileName=None) -> ArDataLogger
        __init__(self, ArRobot robot) -> ArDataLogger
        """
        this = apply(_AriaPy.new_ArDataLogger, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArDataLogger
    __del__ = lambda self : None;
    def addToConfig(*args):
        """addToConfig(self, ArConfig config)"""
        return apply(_AriaPy.ArDataLogger_addToConfig, args)

    def addString(*args):
        """addString(self, char name, UByte2 maxLen, ArFunctor2<(p.char,ArTypes::UByte2)> functor)"""
        return apply(_AriaPy.ArDataLogger_addString, args)

    def getAddStringFunctor(*args):
        """getAddStringFunctor(self) -> ArFunctor3<(p.q(const).char,ArTypes::UByte2,p.ArFunctor2<(p.char,ArTypes::UByte2)>)>"""
        return apply(_AriaPy.ArDataLogger_getAddStringFunctor, args)

ArDataLogger_swigregister = _AriaPy.ArDataLogger_swigregister
ArDataLogger_swigregister(ArDataLogger)

class ArDPPTUCommands:
    """Proxy of C++ ArDPPTUCommands class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArDPPTUCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArDPPTUCommands, name)
    __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, *args): 
        """__init__(self) -> ArDPPTUCommands"""
        this = apply(_AriaPy.new_ArDPPTUCommands, args)
        try: self.this.append(this)
        except: 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"""
    __swig_setmethods__ = {}
    for _s in [ArBasePacket]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArDPPTUPacket, name, value)
    __swig_getmethods__ = {}
    for _s in [ArBasePacket]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArDPPTUPacket, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, UByte2 bufferSize=30) -> ArDPPTUPacket
        __init__(self) -> ArDPPTUPacket
        """
        this = apply(_AriaPy.new_ArDPPTUPacket, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArDPPTUPacket
    __del__ = lambda self : None;
    def byte2ToBuf(*args):
        """byte2ToBuf(self, int val)"""
        return apply(_AriaPy.ArDPPTUPacket_byte2ToBuf, args)

    def finalizePacket(*args):
        """finalizePacket(self)"""
        return apply(_AriaPy.ArDPPTUPacket_finalizePacket, args)

ArDPPTUPacket_swigregister = _AriaPy.ArDPPTUPacket_swigregister
ArDPPTUPacket_swigregister(ArDPPTUPacket)

class ArDPPTU(ArPTZ):
    """Proxy of C++ ArDPPTU class"""
    __swig_setmethods__ = {}
    for _s in [ArPTZ]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArDPPTU, name, value)
    __swig_getmethods__ = {}
    for _s in [ArPTZ]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArDPPTU, name)
    __repr__ = _swig_repr
    PANTILT_DEFAULT = _AriaPy.ArDPPTU_PANTILT_DEFAULT
    PANTILT_PTUD47 = _AriaPy.ArDPPTU_PANTILT_PTUD47
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, DeviceType deviceType=PANTILT_DEFAULT) -> ArDPPTU
        __init__(self, ArRobot robot) -> ArDPPTU
        """
        this = apply(_AriaPy.new_ArDPPTU, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArDPPTU
    __del__ = lambda self : None;
    def init(*args):
        """init(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_init, args)

    def canZoom(*args):
        """canZoom(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_canZoom, args)

    def blank(*args):
        """blank(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_blank, args)

    def resetCalib(*args):
        """resetCalib(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_resetCalib, args)

    def disableReset(*args):
        """disableReset(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_disableReset, args)

    def resetTilt(*args):
        """resetTilt(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_resetTilt, args)

    def resetPan(*args):
        """resetPan(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_resetPan, args)

    def resetAll(*args):
        """resetAll(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_resetAll, args)

    def saveSet(*args):
        """saveSet(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_saveSet, args)

    def restoreSet(*args):
        """restoreSet(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_restoreSet, args)

    def factorySet(*args):
        """factorySet(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_factorySet, args)

    def panTilt(*args):
        """panTilt(self, double pdeg, double tdeg) -> bool"""
        return apply(_AriaPy.ArDPPTU_panTilt, args)

    def pan(*args):
        """pan(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_pan, args)

    def panRel(*args):
        """panRel(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_panRel, args)

    def tilt(*args):
        """tilt(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_tilt, args)

    def tiltRel(*args):
        """tiltRel(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_tiltRel, args)

    def panTiltRel(*args):
        """panTiltRel(self, double pdeg, double tdeg) -> bool"""
        return apply(_AriaPy.ArDPPTU_panTiltRel, args)

    def limitEnforce(*args):
        """limitEnforce(self, bool val) -> bool"""
        return apply(_AriaPy.ArDPPTU_limitEnforce, args)

    def immedExec(*args):
        """immedExec(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_immedExec, args)

    def slaveExec(*args):
        """slaveExec(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_slaveExec, args)

    def awaitExec(*args):
        """awaitExec(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_awaitExec, args)

    def haltAll(*args):
        """haltAll(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_haltAll, args)

    def haltPan(*args):
        """haltPan(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_haltPan, args)

    def haltTilt(*args):
        """haltTilt(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_haltTilt, args)

    def getMaxPosPan(*args):
        """getMaxPosPan(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getMaxPosPan, args)

    def getMaxNegPan(*args):
        """getMaxNegPan(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getMaxNegPan, args)

    def getMaxPosTilt(*args):
        """getMaxPosTilt(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getMaxPosTilt, args)

    def getMaxNegTilt(*args):
        """getMaxNegTilt(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getMaxNegTilt, args)

    def getMaxPanSlew(*args):
        """getMaxPanSlew(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getMaxPanSlew, args)

    def getMinPanSlew(*args):
        """getMinPanSlew(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getMinPanSlew, args)

    def getMaxTiltSlew(*args):
        """getMaxTiltSlew(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getMaxTiltSlew, args)

    def getMinTiltSlew(*args):
        """getMinTiltSlew(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getMinTiltSlew, args)

    def getMaxPanAccel(*args):
        """getMaxPanAccel(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getMaxPanAccel, args)

    def getMinPanAccel(*args):
        """getMinPanAccel(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getMinPanAccel, args)

    def getMaxTiltAccel(*args):
        """getMaxTiltAccel(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getMaxTiltAccel, args)

    def getMinTiltAccel(*args):
        """getMinTiltAccel(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getMinTiltAccel, args)

    def initMon(*args):
        """initMon(self, double deg1, double deg2, double deg3, double deg4) -> bool"""
        return apply(_AriaPy.ArDPPTU_initMon, args)

    def enMon(*args):
        """enMon(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_enMon, args)

    def disMon(*args):
        """disMon(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_disMon, args)

    def offStatPower(*args):
        """offStatPower(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_offStatPower, args)

    def regStatPower(*args):
        """regStatPower(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_regStatPower, args)

    def lowStatPower(*args):
        """lowStatPower(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_lowStatPower, args)

    def highMotPower(*args):
        """highMotPower(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_highMotPower, args)

    def regMotPower(*args):
        """regMotPower(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_regMotPower, args)

    def lowMotPower(*args):
        """lowMotPower(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_lowMotPower, args)

    def panAccel(*args):
        """panAccel(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_panAccel, args)

    def tiltAccel(*args):
        """tiltAccel(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_tiltAccel, args)

    def basePanSlew(*args):
        """basePanSlew(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_basePanSlew, args)

    def baseTiltSlew(*args):
        """baseTiltSlew(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_baseTiltSlew, args)

    def upperPanSlew(*args):
        """upperPanSlew(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_upperPanSlew, args)

    def lowerPanSlew(*args):
        """lowerPanSlew(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_lowerPanSlew, args)

    def upperTiltSlew(*args):
        """upperTiltSlew(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_upperTiltSlew, args)

    def lowerTiltSlew(*args):
        """lowerTiltSlew(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_lowerTiltSlew, args)

    def indepMove(*args):
        """indepMove(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_indepMove, args)

    def velMove(*args):
        """velMove(self) -> bool"""
        return apply(_AriaPy.ArDPPTU_velMove, args)

    def panSlew(*args):
        """panSlew(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_panSlew, args)

    def tiltSlew(*args):
        """tiltSlew(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_tiltSlew, args)

    def panSlewRel(*args):
        """panSlewRel(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_panSlewRel, args)

    def tiltSlewRel(*args):
        """tiltSlewRel(self, double deg) -> bool"""
        return apply(_AriaPy.ArDPPTU_tiltSlewRel, args)

    def getPan(*args):
        """getPan(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getPan, args)

    def getTilt(*args):
        """getTilt(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getTilt, args)

    def getPanSlew(*args):
        """getPanSlew(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getPanSlew, args)

    def getTiltSlew(*args):
        """getTiltSlew(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getTiltSlew, args)

    def getBasePanSlew(*args):
        """getBasePanSlew(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getBasePanSlew, args)

    def getBaseTiltSlew(*args):
        """getBaseTiltSlew(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getBaseTiltSlew, args)

    def getPanAccel(*args):
        """getPanAccel(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getPanAccel, args)

    def getTiltAccel(*args):
        """getTiltAccel(self) -> double"""
        return apply(_AriaPy.ArDPPTU_getTiltAccel, args)

ArDPPTU_swigregister = _AriaPy.ArDPPTU_swigregister
ArDPPTU_swigregister(ArDPPTU)

class ArDeviceConnection:
    """Proxy of C++ ArDeviceConnection class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArDeviceConnection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArDeviceConnection, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArDeviceConnection
    __del__ = lambda self : None;
    def read(*args):
        """
        read(self, char data, unsigned int size, unsigned int msWait=0) -> int
        read(self, char data, unsigned int size) -> int
        """
        return apply(_AriaPy.ArDeviceConnection_read, args)

    def writePacket(*args):
        """writePacket(self, ArBasePacket packet) -> int"""
        return apply(_AriaPy.ArDeviceConnection_writePacket, args)

    def write(*args):
        """write(self, char data, unsigned int size) -> int"""
        return apply(_AriaPy.ArDeviceConnection_write, args)

    def getStatus(*args):
        """getStatus(self) -> int"""
        return apply(_AriaPy.ArDeviceConnection_getStatus, args)

    def getStatusMessage(*args):
        """getStatusMessage(self, int messageNumber) -> char"""
        return apply(_AriaPy.ArDeviceConnection_getStatusMessage, args)

    def openSimple(*args):
        """openSimple(self) -> bool"""
        return apply(_AriaPy.ArDeviceConnection_openSimple, args)

    def close(*args):
        """close(self) -> bool"""
        return apply(_AriaPy.ArDeviceConnection_close, args)

    def getOpenMessage(*args):
        """getOpenMessage(self, int messageNumber) -> char"""
        return apply(_AriaPy.ArDeviceConnection_getOpenMessage, args)

    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(*args):
        """getTimeRead(self, int index) -> ArTime"""
        return apply(_AriaPy.ArDeviceConnection_getTimeRead, args)

    def isTimeStamping(*args):
        """isTimeStamping(self) -> bool"""
        return apply(_AriaPy.ArDeviceConnection_isTimeStamping, args)

ArDeviceConnection_swigregister = _AriaPy.ArDeviceConnection_swigregister
ArDeviceConnection_swigregister(ArDeviceConnection)

class ArColor:
    """Proxy of C++ ArColor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArColor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArColor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, unsigned char red, unsigned char green, unsigned char blue) -> ArColor
        __init__(self) -> ArColor
        __init__(self, Byte4 rgbValue) -> ArColor
        """
        this = apply(_AriaPy.new_ArColor, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArColor
    __del__ = lambda self : None;
    def getRed(*args):
        """getRed(self) -> unsigned char"""
        return apply(_AriaPy.ArColor_getRed, args)

    def getGreen(*args):
        """getGreen(self) -> unsigned char"""
        return apply(_AriaPy.ArColor_getGreen, args)

    def getBlue(*args):
        """getBlue(self) -> unsigned char"""
        return apply(_AriaPy.ArColor_getBlue, args)

    def colorToByte4(*args):
        """colorToByte4(self) -> Byte4"""
        return apply(_AriaPy.ArColor_colorToByte4, args)

ArColor_swigregister = _AriaPy.ArColor_swigregister
ArColor_swigregister(ArColor)

class ArDrawingData:
    """Proxy of C++ ArDrawingData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArDrawingData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArDrawingData, name)
    __repr__ = _swig_repr
    DEFAULT_REFRESH_TIME = _AriaPy.ArDrawingData_DEFAULT_REFRESH_TIME
    def __init__(self, *args): 
        """
        __init__(self, char shape, ArColor primaryColor, int size, int layer, 
            unsigned int defaultRefreshTime=DEFAULT_REFRESH_TIME, 
            char visibility="DefaultOn") -> ArDrawingData
        __init__(self, char shape, ArColor primaryColor, int size, int layer, 
            unsigned int defaultRefreshTime=DEFAULT_REFRESH_TIME) -> ArDrawingData
        __init__(self, char shape, ArColor primaryColor, int size, int layer) -> ArDrawingData
        __init__(self, char shape, ArColor primaryColor, int size, int layer, 
            unsigned int defaultRefreshTime, ArColor secondaryColor, 
            char visibility="DefaultOn") -> ArDrawingData
        __init__(self, char shape, ArColor primaryColor, int size, int layer, 
            unsigned int defaultRefreshTime, ArColor secondaryColor) -> ArDrawingData
        """
        this = apply(_AriaPy.new_ArDrawingData, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArDrawingData
    __del__ = lambda self : None;
    def getShape(*args):
        """getShape(self) -> char"""
        return apply(_AriaPy.ArDrawingData_getShape, args)

    def getPrimaryColor(*args):
        """getPrimaryColor(self) -> ArColor"""
        return apply(_AriaPy.ArDrawingData_getPrimaryColor, args)

    def getSize(*args):
        """getSize(self) -> int"""
        return apply(_AriaPy.ArDrawingData_getSize, args)

    def getLayer(*args):
        """getLayer(self) -> int"""
        return apply(_AriaPy.ArDrawingData_getLayer, args)

    def getDefaultRefreshTime(*args):
        """getDefaultRefreshTime(self) -> unsigned int"""
        return apply(_AriaPy.ArDrawingData_getDefaultRefreshTime, args)

    def getSecondaryColor(*args):
        """getSecondaryColor(self) -> ArColor"""
        return apply(_AriaPy.ArDrawingData_getSecondaryColor, args)

    def getVisibility(*args):
        """getVisibility(self) -> char"""
        return apply(_AriaPy.ArDrawingData_getVisibility, args)

    def setShape(*args):
        """setShape(self, char shape)"""
        return apply(_AriaPy.ArDrawingData_setShape, args)

    def setPrimaryColor(*args):
        """setPrimaryColor(self, ArColor color)"""
        return apply(_AriaPy.ArDrawingData_setPrimaryColor, args)

    def setSize(*args):
        """setSize(self, int size)"""
        return apply(_AriaPy.ArDrawingData_setSize, args)

    def setLayer(*args):
        """setLayer(self, int layer)"""
        return apply(_AriaPy.ArDrawingData_setLayer, args)

    def setDefaultRefreshTime(*args):
        """setDefaultRefreshTime(self, unsigned int refreshTime)"""
        return apply(_AriaPy.ArDrawingData_setDefaultRefreshTime, args)

    def setSecondaryColor(*args):
        """setSecondaryColor(self, ArColor color)"""
        return apply(_AriaPy.ArDrawingData_setSecondaryColor, args)

    def setVisibility(*args):
        """setVisibility(self, char visibility)"""
        return apply(_AriaPy.ArDrawingData_setVisibility, args)

ArDrawingData_swigregister = _AriaPy.ArDrawingData_swigregister
ArDrawingData_swigregister(ArDrawingData)

class ArFileParser:
    """Proxy of C++ ArFileParser class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArFileParser, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArFileParser, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char baseDirectory="./") -> ArFileParser
        __init__(self) -> ArFileParser
        """
        this = apply(_AriaPy.new_ArFileParser, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArFileParser
    __del__ = lambda self : None;
    def addHandler(*args):
        """addHandler(self, char keyword, ArRetFunctor1_Bool_ArgumentBuilderP functor) -> bool"""
        return apply(_AriaPy.ArFileParser_addHandler, args)

    def addHandlerWithError(*args):
        """addHandlerWithError(self, char keyword, ArRetFunctor3<(bool,p.ArArgumentBuilder,p.char,size_t)> functor) -> bool"""
        return apply(_AriaPy.ArFileParser_addHandlerWithError, args)

    def remHandler(*args):
        """
        remHandler(self, char keyword, bool logIfCannotFind=True) -> bool
        remHandler(self, char keyword) -> bool
        remHandler(self, ArRetFunctor1_Bool_ArgumentBuilderP functor) -> bool
        remHandler(self, ArRetFunctor3<(bool,p.ArArgumentBuilder,p.char,size_t)> functor) -> bool
        """
        return apply(_AriaPy.ArFileParser_remHandler, args)

    def setPreParseFunctor(*args):
        """setPreParseFunctor(self, ArFunctor1_CString functor)"""
        return apply(_AriaPy.ArFileParser_setPreParseFunctor, args)

    def parseFile(*args):
        """
        parseFile(self, char fileName, bool continueOnErrors=True, bool noFileNotFoundMessage=False, 
            char errorBuffer=None, 
            size_t errorBufferLen=0) -> bool
        parseFile(self, char fileName, bool continueOnErrors=True, bool noFileNotFoundMessage=False, 
            char errorBuffer=None) -> bool
        parseFile(self, char fileName, bool continueOnErrors=True, bool noFileNotFoundMessage=False) -> bool
        parseFile(self, char fileName, bool continueOnErrors=True) -> bool
        parseFile(self, char fileName) -> bool
        parseFile(self, FILE file, char buffer, int bufferLength, bool continueOnErrors=True, 
            char errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseFile(self, FILE file, char buffer, int bufferLength, bool continueOnErrors=True, 
            char errorBuffer=None) -> bool
        parseFile(self, FILE file, char buffer, int bufferLength, bool continueOnErrors=True) -> bool
        parseFile(self, FILE file, char buffer, int bufferLength) -> bool
        """
        return apply(_AriaPy.ArFileParser_parseFile, args)

    def getBaseDirectory(*args):
        """getBaseDirectory(self) -> char"""
        return apply(_AriaPy.ArFileParser_getBaseDirectory, args)

    def setBaseDirectory(*args):
        """setBaseDirectory(self, char baseDirectory)"""
        return apply(_AriaPy.ArFileParser_setBaseDirectory, args)

    def setCommentDelimiters(*args):
        """setCommentDelimiters(self, std::list<(std::string,std::allocator<(std::string)>)> delimiters)"""
        return apply(_AriaPy.ArFileParser_setCommentDelimiters, args)

    def clearCommentDelimiters(*args):
        """clearCommentDelimiters(self)"""
        return apply(_AriaPy.ArFileParser_clearCommentDelimiters, args)

    def parseLine(*args):
        """
        parseLine(self, char line, char errorBuffer=None, size_t errorBufferLen=0) -> bool
        parseLine(self, char line, char errorBuffer=None) -> bool
        parseLine(self, char line) -> bool
        """
        return apply(_AriaPy.ArFileParser_parseLine, args)

    def resetCounters(*args):
        """resetCounters(self)"""
        return apply(_AriaPy.ArFileParser_resetCounters, args)

    def setMaxNumArguments(*args):
        """
        setMaxNumArguments(self, size_t maxNumArguments=512)
        setMaxNumArguments(self)
        """
        return apply(_AriaPy.ArFileParser_setMaxNumArguments, args)

    def setQuiet(*args):
        """setQuiet(self, bool isQuiet)"""
        return apply(_AriaPy.ArFileParser_setQuiet, args)

ArFileParser_swigregister = _AriaPy.ArFileParser_swigregister
ArFileParser_swigregister(ArFileParser)

class ArForbiddenRangeDevice(ArRangeDevice):
    """Proxy of C++ ArForbiddenRangeDevice class"""
    __swig_setmethods__ = {}
    for _s in [ArRangeDevice]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArForbiddenRangeDevice, name, value)
    __swig_getmethods__ = {}
    for _s in [ArRangeDevice]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArForbiddenRangeDevice, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArMapInterface armap, double distanceIncrement=100, 
            unsigned int maxRange=4000, char name="forbidden") -> ArForbiddenRangeDevice
        __init__(self, ArMapInterface armap, double distanceIncrement=100, 
            unsigned int maxRange=4000) -> ArForbiddenRangeDevice
        __init__(self, ArMapInterface armap, double distanceIncrement=100) -> ArForbiddenRangeDevice
        __init__(self, ArMapInterface armap) -> ArForbiddenRangeDevice
        """
        this = apply(_AriaPy.new_ArForbiddenRangeDevice, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArForbiddenRangeDevice
    __del__ = lambda self : None;
    def processMap(*args):
        """processMap(self)"""
        return apply(_AriaPy.ArForbiddenRangeDevice_processMap, args)

    def processReadings(*args):
        """processReadings(self)"""
        return apply(_AriaPy.ArForbiddenRangeDevice_processReadings, args)

    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArForbiddenRangeDevice_setRobot, args)

    def enable(*args):
        """enable(self)"""
        return apply(_AriaPy.ArForbiddenRangeDevice_enable, args)

    def disable(*args):
        """disable(self)"""
        return apply(_AriaPy.ArForbiddenRangeDevice_disable, args)

    def isEnabled(*args):
        """isEnabled(self) -> bool"""
        return apply(_AriaPy.ArForbiddenRangeDevice_isEnabled, args)

    def getEnableCB(*args):
        """getEnableCB(self) -> ArFunctor"""
        return apply(_AriaPy.ArForbiddenRangeDevice_getEnableCB, args)

    def getDisableCB(*args):
        """getDisableCB(self) -> ArFunctor"""
        return apply(_AriaPy.ArForbiddenRangeDevice_getDisableCB, args)

ArForbiddenRangeDevice_swigregister = _AriaPy.ArForbiddenRangeDevice_swigregister
ArForbiddenRangeDevice_swigregister(ArForbiddenRangeDevice)

class ArFunctorASyncTask(ArASyncTask):
    """Proxy of C++ ArFunctorASyncTask class"""
    __swig_setmethods__ = {}
    for _s in [ArASyncTask]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArFunctorASyncTask, name, value)
    __swig_getmethods__ = {}
    for _s in [ArASyncTask]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArFunctorASyncTask, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRetFunctor1_VoidP_VoidP functor) -> ArFunctorASyncTask"""
        this = apply(_AriaPy.new_ArFunctorASyncTask, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArFunctorASyncTask
    __del__ = lambda self : None;
    def runThread(*args):
        """runThread(self, void arg) -> void"""
        return apply(_AriaPy.ArFunctorASyncTask_runThread, args)

ArFunctorASyncTask_swigregister = _AriaPy.ArFunctorASyncTask_swigregister
ArFunctorASyncTask_swigregister(ArFunctorASyncTask)

class ArGPS:
    """Proxy of C++ ArGPS class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArGPS, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArGPS, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArGPS"""
        this = apply(_AriaPy.new_ArGPS, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArGPS
    __del__ = lambda self : None;
    def setDeviceConnection(*args):
        """setDeviceConnection(self, ArDeviceConnection deviceConn)"""
        return apply(_AriaPy.ArGPS_setDeviceConnection, args)

    def getDeviceConnection(*args):
        """getDeviceConnection(self) -> ArDeviceConnection"""
        return apply(_AriaPy.ArGPS_getDeviceConnection, args)

    def connect(*args):
        """
        connect(self, unsigned long connectTimeout=10000) -> bool
        connect(self) -> bool
        """
        return apply(_AriaPy.ArGPS_connect, args)

    def blockingConnect(*args):
        """
        blockingConnect(self, unsigned long connectTimeout=10000) -> bool
        blockingConnect(self) -> bool
        """
        return apply(_AriaPy.ArGPS_blockingConnect, args)

    ReadFinished = _AriaPy.ArGPS_ReadFinished
    ReadError = _AriaPy.ArGPS_ReadError
    ReadData = _AriaPy.ArGPS_ReadData
    ReadUpdated = _AriaPy.ArGPS_ReadUpdated
    __swig_setmethods__["ReadFlags"] = _AriaPy.ArGPS_ReadFlags_set
    __swig_getmethods__["ReadFlags"] = _AriaPy.ArGPS_ReadFlags_get
    def read(*args):
        """
        read(self, unsigned long maxTime=0) -> int
        read(self) -> int
        """
        return apply(_AriaPy.ArGPS_read, args)

    def readWithLock(*args):
        """readWithLock(self, unsigned int maxTime) -> int"""
        return apply(_AriaPy.ArGPS_readWithLock, args)

    def lock(*args):
        """lock(self)"""
        return apply(_AriaPy.ArGPS_lock, args)

    def unlock(*args):
        """unlock(self)"""
        return apply(_AriaPy.ArGPS_unlock, args)

    def setIgnoreChecksum(*args):
        """setIgnoreChecksum(self, bool ignore)"""
        return apply(_AriaPy.ArGPS_setIgnoreChecksum, args)

    def logData(*args):
        """logData(self)"""
        return apply(_AriaPy.ArGPS_logData, args)

    def printData(*args):
        """
        printData(self, bool labels=True)
        printData(self)
        """
        return apply(_AriaPy.ArGPS_printData, args)

    def printDataLabelsHeader(*args):
        """printDataLabelsHeader(self)"""
        return apply(_AriaPy.ArGPS_printDataLabelsHeader, args)

    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(*args):
        """getCurrentDataRef(self) -> ArGPS::Data"""
        return apply(_AriaPy.ArGPS_getCurrentDataRef, args)

    def getFixType(*args):
        """getFixType(self) -> int"""
        return apply(_AriaPy.ArGPS_getFixType, args)

    __swig_getmethods__["getFixTypeName"] = lambda x: _AriaPy.ArGPS_getFixTypeName
    def havePosition(*args):
        """havePosition(self) -> bool"""
        return apply(_AriaPy.ArGPS_havePosition, args)

    def haveLatitude(*args):
        """haveLatitude(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveLatitude, args)

    def haveLongitude(*args):
        """haveLongitude(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveLongitude, args)

    def getLatitude(*args):
        """getLatitude(self) -> double"""
        return apply(_AriaPy.ArGPS_getLatitude, args)

    def getLongitude(*args):
        """getLongitude(self) -> double"""
        return apply(_AriaPy.ArGPS_getLongitude, args)

    def getTimeReceivedPosition(*args):
        """getTimeReceivedPosition(self) -> ArTime"""
        return apply(_AriaPy.ArGPS_getTimeReceivedPosition, args)

    def haveSpeed(*args):
        """haveSpeed(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveSpeed, args)

    def getSpeed(*args):
        """getSpeed(self) -> double"""
        return apply(_AriaPy.ArGPS_getSpeed, args)

    def getGPSPositionTimestamp(*args):
        """getGPSPositionTimestamp(self) -> ArTime"""
        return apply(_AriaPy.ArGPS_getGPSPositionTimestamp, args)

    def getNumSatellitesTracked(*args):
        """getNumSatellitesTracked(self) -> int"""
        return apply(_AriaPy.ArGPS_getNumSatellitesTracked, args)

    def haveDGPSStation(*args):
        """haveDGPSStation(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveDGPSStation, args)

    def getDGPSStationID(*args):
        """getDGPSStationID(self) -> unsigned short"""
        return apply(_AriaPy.ArGPS_getDGPSStationID, args)

    def haveGarminPositionError(*args):
        """haveGarminPositionError(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveGarminPositionError, args)

    def getGarminPositionError(*args):
        """getGarminPositionError(self) -> double"""
        return apply(_AriaPy.ArGPS_getGarminPositionError, args)

    def haveGarminVerticalPositionError(*args):
        """haveGarminVerticalPositionError(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveGarminVerticalPositionError, args)

    def getGarminVerticalPositionError(*args):
        """getGarminVerticalPositionError(self) -> double"""
        return apply(_AriaPy.ArGPS_getGarminVerticalPositionError, args)

    def haveCompassHeadingMag(*args):
        """haveCompassHeadingMag(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveCompassHeadingMag, args)

    def haveCompassHeadingTrue(*args):
        """haveCompassHeadingTrue(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveCompassHeadingTrue, args)

    def getCompassHeadingMag(*args):
        """getCompassHeadingMag(self) -> double"""
        return apply(_AriaPy.ArGPS_getCompassHeadingMag, args)

    def getCompassHeadingTrue(*args):
        """getCompassHeadingTrue(self) -> double"""
        return apply(_AriaPy.ArGPS_getCompassHeadingTrue, args)

    def setCompassHeadingMag(*args):
        """setCompassHeadingMag(self, double val)"""
        return apply(_AriaPy.ArGPS_setCompassHeadingMag, args)

    def setCompassHeadingTrue(*args):
        """setCompassHeadingTrue(self, double val)"""
        return apply(_AriaPy.ArGPS_setCompassHeadingTrue, args)

    def setCompassHeadingMagWithLock(*args):
        """setCompassHeadingMagWithLock(self, double val)"""
        return apply(_AriaPy.ArGPS_setCompassHeadingMagWithLock, args)

    def setCompassHeadingTrueWithLock(*args):
        """setCompassHeadingTrueWithLock(self, double val)"""
        return apply(_AriaPy.ArGPS_setCompassHeadingTrueWithLock, args)

    def haveAltitude(*args):
        """haveAltitude(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveAltitude, args)

    def getAltitude(*args):
        """getAltitude(self) -> double"""
        return apply(_AriaPy.ArGPS_getAltitude, args)

    def haveAltimeter(*args):
        """haveAltimeter(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveAltimeter, args)

    def getAltimeter(*args):
        """getAltimeter(self) -> double"""
        return apply(_AriaPy.ArGPS_getAltimeter, args)

    def haveHDOP(*args):
        """haveHDOP(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveHDOP, args)

    def getHDOP(*args):
        """getHDOP(self) -> double"""
        return apply(_AriaPy.ArGPS_getHDOP, args)

    def haveVDOP(*args):
        """haveVDOP(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveVDOP, args)

    def getVDOP(*args):
        """getVDOP(self) -> double"""
        return apply(_AriaPy.ArGPS_getVDOP, args)

    def havePDOP(*args):
        """havePDOP(self) -> bool"""
        return apply(_AriaPy.ArGPS_havePDOP, args)

    def getPDOP(*args):
        """getPDOP(self) -> double"""
        return apply(_AriaPy.ArGPS_getPDOP, args)

    def haveSNR(*args):
        """haveSNR(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveSNR, args)

    def getMeanSNR(*args):
        """getMeanSNR(self) -> double"""
        return apply(_AriaPy.ArGPS_getMeanSNR, args)

    def haveBeaconInfo(*args):
        """haveBeaconInfo(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveBeaconInfo, args)

    def getBeaconSignalStrength(*args):
        """getBeaconSignalStrength(self) -> double"""
        return apply(_AriaPy.ArGPS_getBeaconSignalStrength, args)

    def getBeaconSNR(*args):
        """getBeaconSNR(self) -> double"""
        return apply(_AriaPy.ArGPS_getBeaconSNR, args)

    def getBeaconFreq(*args):
        """getBeaconFreq(self) -> double"""
        return apply(_AriaPy.ArGPS_getBeaconFreq, args)

    def getBecaonBPS(*args):
        """getBecaonBPS(self) -> unsigned short"""
        return apply(_AriaPy.ArGPS_getBecaonBPS, args)

    def getBeaconChannel(*args):
        """getBeaconChannel(self) -> unsigned short"""
        return apply(_AriaPy.ArGPS_getBeaconChannel, args)

    def haveErrorEllipse(*args):
        """haveErrorEllipse(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveErrorEllipse, args)

    def getErrorEllipse(*args):
        """getErrorEllipse(self) -> ArPose"""
        return apply(_AriaPy.ArGPS_getErrorEllipse, args)

    def haveLatLonError(*args):
        """haveLatLonError(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveLatLonError, args)

    def getLatLonError(*args):
        """getLatLonError(self) -> ArPose"""
        return apply(_AriaPy.ArGPS_getLatLonError, args)

    def getLatitudeError(*args):
        """getLatitudeError(self) -> double"""
        return apply(_AriaPy.ArGPS_getLatitudeError, args)

    def getLongitudeError(*args):
        """getLongitudeError(self) -> double"""
        return apply(_AriaPy.ArGPS_getLongitudeError, args)

    def haveAltitudeError(*args):
        """haveAltitudeError(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveAltitudeError, args)

    def getAltitudeError(*args):
        """getAltitudeError(self) -> double"""
        return apply(_AriaPy.ArGPS_getAltitudeError, args)

    def haveInputsRMS(*args):
        """haveInputsRMS(self) -> bool"""
        return apply(_AriaPy.ArGPS_haveInputsRMS, args)

    def getInputsRMS(*args):
        """getInputsRMS(self) -> double"""
        return apply(_AriaPy.ArGPS_getInputsRMS, args)

    def addNMEAHandler(*args):
        """addNMEAHandler(self, char message, Handler handler)"""
        return apply(_AriaPy.ArGPS_addNMEAHandler, args)

    def removeNMEAHandler(*args):
        """removeNMEAHandler(self, char message)"""
        return apply(_AriaPy.ArGPS_removeNMEAHandler, args)

ArGPS_swigregister = _AriaPy.ArGPS_swigregister
ArGPS_swigregister(ArGPS)

def ArGPS_getFixTypeName(*args):
  """
    getFixTypeName() -> char
    ArGPS_getFixTypeName(FixType type) -> char
    """
  return apply(_AriaPy.ArGPS_getFixTypeName, args)

class ArGPSConnector:
    """Proxy of C++ ArGPSConnector class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArGPSConnector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArGPSConnector, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArArgumentParser argParser) -> ArGPSConnector"""
        this = apply(_AriaPy.new_ArGPSConnector, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArGPSConnector
    __del__ = lambda self : None;
    def parseArgs(*args):
        """parseArgs(self) -> bool"""
        return apply(_AriaPy.ArGPSConnector_parseArgs, args)

    def createGPS(*args):
        """
        createGPS(self, ArRobot robot=None) -> ArGPS
        createGPS(self) -> ArGPS
        """
        return apply(_AriaPy.ArGPSConnector_createGPS, args)

    def create(*args):
        """
        create(self, ArRobot robot=None) -> ArGPS
        create(self) -> ArGPS
        """
        return apply(_AriaPy.ArGPSConnector_create, args)

    Standard = _AriaPy.ArGPSConnector_Standard
    Novatel = _AriaPy.ArGPSConnector_Novatel
    Trimble = _AriaPy.ArGPSConnector_Trimble
    Invalid = _AriaPy.ArGPSConnector_Invalid
    def getGPSType(*args):
        """getGPSType(self) -> int"""
        return apply(_AriaPy.ArGPSConnector_getGPSType, args)

ArGPSConnector_swigregister = _AriaPy.ArGPSConnector_swigregister
ArGPSConnector_swigregister(ArGPSConnector)

class Ar3DPoint:
    """Proxy of C++ Ar3DPoint class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Ar3DPoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Ar3DPoint, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> Ar3DPoint
        __init__(self, double x, double y, double z) -> Ar3DPoint
        """
        this = apply(_AriaPy.new_Ar3DPoint, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_Ar3DPoint
    __del__ = lambda self : None;
    def __add__(*args):
        """__add__(self, Ar3DPoint c) -> Ar3DPoint"""
        return apply(_AriaPy.Ar3DPoint___add__, args)

    def __sub__(*args):
        """__sub__(self, Ar3DPoint c) -> Ar3DPoint"""
        return apply(_AriaPy.Ar3DPoint___sub__, args)

    def __mul__(*args):
        """__mul__(self, double c) -> Ar3DPoint"""
        return apply(_AriaPy.Ar3DPoint___mul__, args)

    def dot(*args):
        """dot(self, Ar3DPoint c) -> double"""
        return apply(_AriaPy.Ar3DPoint_dot, args)

    def cross(*args):
        """cross(self, Ar3DPoint c) -> Ar3DPoint"""
        return apply(_AriaPy.Ar3DPoint_cross, args)

    def printPoint(*args):
        """
        printPoint(self, char head=None)
        printPoint(self)
        """
        return apply(_AriaPy.Ar3DPoint_printPoint, args)

    def getX(*args):
        """getX(self) -> double"""
        return apply(_AriaPy.Ar3DPoint_getX, args)

    def getY(*args):
        """getY(self) -> double"""
        return apply(_AriaPy.Ar3DPoint_getY, args)

    def getZ(*args):
        """getZ(self) -> double"""
        return apply(_AriaPy.Ar3DPoint_getZ, args)

Ar3DPoint_swigregister = _AriaPy.Ar3DPoint_swigregister
Ar3DPoint_swigregister(Ar3DPoint)

class ArWGS84:
    """Proxy of C++ ArWGS84 class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArWGS84, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArWGS84, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArWGS84"""
        this = apply(_AriaPy.new_ArWGS84, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["getE"] = lambda x: _AriaPy.ArWGS84_getE
    __swig_getmethods__["getA"] = lambda x: _AriaPy.ArWGS84_getA
    __swig_getmethods__["getB"] = lambda x: _AriaPy.ArWGS84_getB
    __swig_getmethods__["getEP"] = lambda x: _AriaPy.ArWGS84_getEP
    __swig_getmethods__["get1byf"] = lambda x: _AriaPy.ArWGS84_get1byf
    __swig_getmethods__["getOmega"] = lambda x: _AriaPy.ArWGS84_getOmega
    __swig_getmethods__["getGM"] = lambda x: _AriaPy.ArWGS84_getGM
    __swig_destroy__ = _AriaPy.delete_ArWGS84
    __del__ = lambda self : None;
ArWGS84_swigregister = _AriaPy.ArWGS84_swigregister
ArWGS84_swigregister(ArWGS84)

def ArWGS84_getE(*args):
  """ArWGS84_getE() -> double"""
  return apply(_AriaPy.ArWGS84_getE, args)

def ArWGS84_getA(*args):
  """ArWGS84_getA() -> double"""
  return apply(_AriaPy.ArWGS84_getA, args)

def ArWGS84_getB(*args):
  """ArWGS84_getB() -> double"""
  return apply(_AriaPy.ArWGS84_getB, args)

def ArWGS84_getEP(*args):
  """ArWGS84_getEP() -> double"""
  return apply(_AriaPy.ArWGS84_getEP, args)

def ArWGS84_get1byf(*args):
  """ArWGS84_get1byf() -> double"""
  return apply(_AriaPy.ArWGS84_get1byf, args)

def ArWGS84_getOmega(*args):
  """ArWGS84_getOmega() -> double"""
  return apply(_AriaPy.ArWGS84_getOmega, args)

def ArWGS84_getGM(*args):
  """ArWGS84_getGM() -> double"""
  return apply(_AriaPy.ArWGS84_getGM, args)

class ArECEFCoords(Ar3DPoint):
    """Proxy of C++ ArECEFCoords class"""
    __swig_setmethods__ = {}
    for _s in [Ar3DPoint]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArECEFCoords, name, value)
    __swig_getmethods__ = {}
    for _s in [Ar3DPoint]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArECEFCoords, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, double x, double y, double z) -> ArECEFCoords"""
        this = apply(_AriaPy.new_ArECEFCoords, args)
        try: self.this.append(this)
        except: self.this = this
    def ECEF2LLA(*args):
        """ECEF2LLA(self) -> ArLLACoords"""
        return apply(_AriaPy.ArECEFCoords_ECEF2LLA, args)

    def ECEF2ENU(*args):
        """ECEF2ENU(self, ArECEFCoords ref) -> ArENUCoords"""
        return apply(_AriaPy.ArECEFCoords_ECEF2ENU, args)

    __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"""
    __swig_setmethods__ = {}
    for _s in [Ar3DPoint]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLLACoords, name, value)
    __swig_getmethods__ = {}
    for _s in [Ar3DPoint]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArLLACoords, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> ArLLACoords
        __init__(self, double x, double y, double z) -> ArLLACoords
        """
        this = apply(_AriaPy.new_ArLLACoords, args)
        try: self.this.append(this)
        except: self.this = this
    def LLA2ECEF(*args):
        """LLA2ECEF(self) -> ArECEFCoords"""
        return apply(_AriaPy.ArLLACoords_LLA2ECEF, args)

    def getLatitude(*args):
        """getLatitude(self) -> double"""
        return apply(_AriaPy.ArLLACoords_getLatitude, args)

    def getLongitude(*args):
        """getLongitude(self) -> double"""
        return apply(_AriaPy.ArLLACoords_getLongitude, args)

    def getAltitude(*args):
        """getAltitude(self) -> double"""
        return apply(_AriaPy.ArLLACoords_getAltitude, args)

    __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"""
    __swig_setmethods__ = {}
    for _s in [Ar3DPoint]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArENUCoords, name, value)
    __swig_getmethods__ = {}
    for _s in [Ar3DPoint]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArENUCoords, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, double x, double y, double z) -> ArENUCoords"""
        this = apply(_AriaPy.new_ArENUCoords, args)
        try: self.this.append(this)
        except: self.this = this
    def ENU2ECEF(*args):
        """ENU2ECEF(self, ArLLACoords ref) -> ArECEFCoords"""
        return apply(_AriaPy.ArENUCoords_ENU2ECEF, args)

    def getEast(*args):
        """getEast(self) -> double"""
        return apply(_AriaPy.ArENUCoords_getEast, args)

    def getNorth(*args):
        """getNorth(self) -> double"""
        return apply(_AriaPy.ArENUCoords_getNorth, args)

    def getUp(*args):
        """getUp(self) -> double"""
        return apply(_AriaPy.ArENUCoords_getUp, args)

    __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"""
    __swig_setmethods__ = {}
    for _s in [ArENUCoords]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMapGPSCoords, name, value)
    __swig_getmethods__ = {}
    for _s in [ArENUCoords]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArMapGPSCoords, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArLLACoords org) -> ArMapGPSCoords"""
        this = apply(_AriaPy.new_ArMapGPSCoords, args)
        try: self.this.append(this)
        except: self.this = this
    def convertMap2LLACoords(*args):
        """
        convertMap2LLACoords(self, double ea, double no, double up, double lat, double lon, 
            double alt) -> bool
        """
        return apply(_AriaPy.ArMapGPSCoords_convertMap2LLACoords, args)

    def convertLLA2MapCoords(*args):
        """
        convertLLA2MapCoords(self, double lat, double lon, double alt, double ea, double no, 
            double up) -> bool
        convertLLA2MapCoords(self, ArLLACoords lla, double ea, double no, double up) -> bool
        """
        return apply(_AriaPy.ArMapGPSCoords_convertLLA2MapCoords, args)

    __swig_setmethods__["myOriginECEF"] = _AriaPy.ArMapGPSCoords_myOriginECEF_set
    __swig_getmethods__["myOriginECEF"] = _AriaPy.ArMapGPSCoords_myOriginECEF_get
    __swig_setmethods__["myOriginLLA"] = _AriaPy.ArMapGPSCoords_myOriginLLA_set
    __swig_getmethods__["myOriginLLA"] = _AriaPy.ArMapGPSCoords_myOriginLLA_get
    __swig_setmethods__["myOriginSet"] = _AriaPy.ArMapGPSCoords_myOriginSet_set
    __swig_getmethods__["myOriginSet"] = _AriaPy.ArMapGPSCoords_myOriginSet_get
    __swig_destroy__ = _AriaPy.delete_ArMapGPSCoords
    __del__ = lambda self : None;
ArMapGPSCoords_swigregister = _AriaPy.ArMapGPSCoords_swigregister
ArMapGPSCoords_swigregister(ArMapGPSCoords)

class ArGripperCommands:
    """Proxy of C++ ArGripperCommands class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArGripperCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArGripperCommands, name)
    __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, *args): 
        """__init__(self) -> ArGripperCommands"""
        this = apply(_AriaPy.new_ArGripperCommands, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArGripperCommands
    __del__ = lambda self : None;
ArGripperCommands_swigregister = _AriaPy.ArGripperCommands_swigregister
ArGripperCommands_swigregister(ArGripperCommands)

class ArGripper:
    """Proxy of C++ ArGripper class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArGripper, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArGripper, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, int gripperType=QUERYTYPE) -> ArGripper
        __init__(self, ArRobot robot) -> ArGripper
        """
        this = apply(_AriaPy.new_ArGripper, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArGripper
    __del__ = lambda self : None;
    def gripOpen(*args):
        """gripOpen(self) -> bool"""
        return apply(_AriaPy.ArGripper_gripOpen, args)

    def gripClose(*args):
        """gripClose(self) -> bool"""
        return apply(_AriaPy.ArGripper_gripClose, args)

    def gripStop(*args):
        """gripStop(self) -> bool"""
        return apply(_AriaPy.ArGripper_gripStop, args)

    def liftUp(*args):
        """liftUp(self) -> bool"""
        return apply(_AriaPy.ArGripper_liftUp, args)

    def liftDown(*args):
        """liftDown(self) -> bool"""
        return apply(_AriaPy.ArGripper_liftDown, args)

    def liftStop(*args):
        """liftStop(self) -> bool"""
        return apply(_AriaPy.ArGripper_liftStop, args)

    def gripperStore(*args):
        """gripperStore(self) -> bool"""
        return apply(_AriaPy.ArGripper_gripperStore, args)

    def gripperDeploy(*args):
        """gripperDeploy(self) -> bool"""
        return apply(_AriaPy.ArGripper_gripperDeploy, args)

    def gripperHalt(*args):
        """gripperHalt(self) -> bool"""
        return apply(_AriaPy.ArGripper_gripperHalt, args)

    def gripPressure(*args):
        """gripPressure(self, int mSecIntervals) -> bool"""
        return apply(_AriaPy.ArGripper_gripPressure, args)

    def liftCarry(*args):
        """liftCarry(self, int mSecIntervals) -> bool"""
        return apply(_AriaPy.ArGripper_liftCarry, args)

    def isGripMoving(*args):
        """isGripMoving(self) -> bool"""
        return apply(_AriaPy.ArGripper_isGripMoving, args)

    def isLiftMoving(*args):
        """isLiftMoving(self) -> bool"""
        return apply(_AriaPy.ArGripper_isLiftMoving, args)

    def getGripState(*args):
        """getGripState(self) -> int"""
        return apply(_AriaPy.ArGripper_getGripState, args)

    def getPaddleState(*args):
        """getPaddleState(self) -> int"""
        return apply(_AriaPy.ArGripper_getPaddleState, args)

    def getBreakBeamState(*args):
        """getBreakBeamState(self) -> int"""
        return apply(_AriaPy.ArGripper_getBreakBeamState, args)

    def isLiftMaxed(*args):
        """isLiftMaxed(self) -> bool"""
        return apply(_AriaPy.ArGripper_isLiftMaxed, args)

    def getType(*args):
        """getType(self) -> int"""
        return apply(_AriaPy.ArGripper_getType, args)

    def setType(*args):
        """setType(self, int type)"""
        return apply(_AriaPy.ArGripper_setType, args)

    def getMSecSinceLastPacket(*args):
        """getMSecSinceLastPacket(self) -> long"""
        return apply(_AriaPy.ArGripper_getMSecSinceLastPacket, args)

    def getGraspTime(*args):
        """getGraspTime(self) -> int"""
        return apply(_AriaPy.ArGripper_getGraspTime, args)

    def logState(*args):
        """logState(self)"""
        return apply(_AriaPy.ArGripper_logState, args)

    def packetHandler(*args):
        """packetHandler(self, ArRobotPacket packet) -> bool"""
        return apply(_AriaPy.ArGripper_packetHandler, args)

    def connectHandler(*args):
        """connectHandler(self)"""
        return apply(_AriaPy.ArGripper_connectHandler, args)

    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"""
    __swig_setmethods__ = {}
    for _s in [ArRangeDevice]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArIRs, name, value)
    __swig_getmethods__ = {}
    for _s in [ArRangeDevice]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArIRs, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, size_t currentBufferSize=10, size_t cumulativeBufferSize=10, 
            char name="irs", int maxSecondsToKeepCurrent=15) -> ArIRs
        __init__(self, size_t currentBufferSize=10, size_t cumulativeBufferSize=10, 
            char name="irs") -> ArIRs
        __init__(self, size_t currentBufferSize=10, size_t cumulativeBufferSize=10) -> ArIRs
        __init__(self, size_t currentBufferSize=10) -> ArIRs
        __init__(self) -> ArIRs
        """
        this = apply(_AriaPy.new_ArIRs, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArIRs
    __del__ = lambda self : None;
    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArIRs_setRobot, args)

    def processReadings(*args):
        """processReadings(self)"""
        return apply(_AriaPy.ArIRs_processReadings, args)

ArIRs_swigregister = _AriaPy.ArIRs_swigregister
ArIRs_swigregister(ArIRs)

class ArInterpolation:
    """Proxy of C++ ArInterpolation class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArInterpolation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArInterpolation, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, size_t numberOfReadings=100) -> ArInterpolation
        __init__(self) -> ArInterpolation
        """
        this = apply(_AriaPy.new_ArInterpolation, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArInterpolation
    __del__ = lambda self : None;
    def addReading(*args):
        """addReading(self, ArTime timeOfReading, ArPose position) -> bool"""
        return apply(_AriaPy.ArInterpolation_addReading, args)

    def getPose(*args):
        """getPose(self, ArTime timeStamp, ArPose position) -> int"""
        return apply(_AriaPy.ArInterpolation_getPose, args)

    def setNumberOfReadings(*args):
        """setNumberOfReadings(self, size_t numberOfReadings)"""
        return apply(_AriaPy.ArInterpolation_setNumberOfReadings, args)

    def getNumberOfReadings(*args):
        """getNumberOfReadings(self) -> size_t"""
        return apply(_AriaPy.ArInterpolation_getNumberOfReadings, args)

    def reset(*args):
        """reset(self)"""
        return apply(_AriaPy.ArInterpolation_reset, args)

ArInterpolation_swigregister = _AriaPy.ArInterpolation_swigregister
ArInterpolation_swigregister(ArInterpolation)

class ArIrrfDevice(ArRangeDevice):
    """Proxy of C++ ArIrrfDevice class"""
    __swig_setmethods__ = {}
    for _s in [ArRangeDevice]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArIrrfDevice, name, value)
    __swig_getmethods__ = {}
    for _s in [ArRangeDevice]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArIrrfDevice, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, size_t currentBufferSize=91, size_t cumulativeBufferSize=273, 
            char name="irrf") -> ArIrrfDevice
        __init__(self, size_t currentBufferSize=91, size_t cumulativeBufferSize=273) -> ArIrrfDevice
        __init__(self, size_t currentBufferSize=91) -> ArIrrfDevice
        __init__(self) -> ArIrrfDevice
        """
        this = apply(_AriaPy.new_ArIrrfDevice, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArIrrfDevice
    __del__ = lambda self : None;
    def packetHandler(*args):
        """packetHandler(self, ArRobotPacket packet) -> bool"""
        return apply(_AriaPy.ArIrrfDevice_packetHandler, args)

    def setCumulativeMaxRange(*args):
        """setCumulativeMaxRange(self, double r)"""
        return apply(_AriaPy.ArIrrfDevice_setCumulativeMaxRange, args)

    def setRobot(*args):
        """setRobot(self, ArRobot ?)"""
        return apply(_AriaPy.ArIrrfDevice_setRobot, args)

ArIrrfDevice_swigregister = _AriaPy.ArIrrfDevice_swigregister
ArIrrfDevice_swigregister(ArIrrfDevice)

class ArJoyHandler:
    """Proxy of C++ ArJoyHandler class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArJoyHandler, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArJoyHandler, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, bool useOSCal=True, bool useOldJoystick=False) -> ArJoyHandler
        __init__(self, bool useOSCal=True) -> ArJoyHandler
        __init__(self) -> ArJoyHandler
        """
        this = apply(_AriaPy.new_ArJoyHandler, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArJoyHandler
    __del__ = lambda self : None;
    def init(*args):
        """init(self) -> bool"""
        return apply(_AriaPy.ArJoyHandler_init, args)

    def haveJoystick(*args):
        """haveJoystick(self) -> bool"""
        return apply(_AriaPy.ArJoyHandler_haveJoystick, args)

    def getDoubles(*args):
        """
        getDoubles(self, double x, double y, double z=None)
        getDoubles(self, double x, double y)
        """
        return apply(_AriaPy.ArJoyHandler_getDoubles, args)

    def getButton(*args):
        """getButton(self, unsigned int button) -> bool"""
        return apply(_AriaPy.ArJoyHandler_getButton, args)

    def haveZAxis(*args):
        """haveZAxis(self) -> bool"""
        return apply(_AriaPy.ArJoyHandler_haveZAxis, args)

    def setSpeeds(*args):
        """
        setSpeeds(self, int x, int y, int z=0)
        setSpeeds(self, int x, int y)
        """
        return apply(_AriaPy.ArJoyHandler_setSpeeds, args)

    def getAdjusted(*args):
        """
        getAdjusted(self, int x, int y, int z=None)
        getAdjusted(self, int x, int y)
        """
        return apply(_AriaPy.ArJoyHandler_getAdjusted, args)

    def getNumAxes(*args):
        """getNumAxes(self) -> unsigned int"""
        return apply(_AriaPy.ArJoyHandler_getNumAxes, args)

    def getAxis(*args):
        """getAxis(self, unsigned int axis) -> double"""
        return apply(_AriaPy.ArJoyHandler_getAxis, args)

    def getNumButtons(*args):
        """getNumButtons(self) -> unsigned int"""
        return apply(_AriaPy.ArJoyHandler_getNumButtons, args)

    def setUseOSCal(*args):
        """setUseOSCal(self, bool useOSCal)"""
        return apply(_AriaPy.ArJoyHandler_setUseOSCal, args)

    def getUseOSCal(*args):
        """getUseOSCal(self) -> bool"""
        return apply(_AriaPy.ArJoyHandler_getUseOSCal, args)

    def startCal(*args):
        """startCal(self)"""
        return apply(_AriaPy.ArJoyHandler_startCal, args)

    def endCal(*args):
        """endCal(self)"""
        return apply(_AriaPy.ArJoyHandler_endCal, args)

    def getUnfiltered(*args):
        """
        getUnfiltered(self, int x, int y, int z=None)
        getUnfiltered(self, int x, int y)
        """
        return apply(_AriaPy.ArJoyHandler_getUnfiltered, args)

    def getStats(*args):
        """getStats(self, int maxX, int minX, int maxY, int minY, int cenX, int cenY)"""
        return apply(_AriaPy.ArJoyHandler_getStats, args)

    def setStats(*args):
        """setStats(self, int maxX, int minX, int maxY, int minY, int cenX, int cenY)"""
        return apply(_AriaPy.ArJoyHandler_setStats, args)

    def getSpeeds(*args):
        """getSpeeds(self, int x, int y, int z)"""
        return apply(_AriaPy.ArJoyHandler_getSpeeds, args)

ArJoyHandler_swigregister = _AriaPy.ArJoyHandler_swigregister
ArJoyHandler_swigregister(ArJoyHandler)

class ArKeyHandler:
    """Proxy of C++ ArKeyHandler class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArKeyHandler, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArKeyHandler, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, bool blocking=False, bool addAriaExitCB=True, FILE stream=None, 
            bool takeKeysInConstructor=True) -> ArKeyHandler
        __init__(self, bool blocking=False, bool addAriaExitCB=True, FILE stream=None) -> ArKeyHandler
        __init__(self, bool blocking=False, bool addAriaExitCB=True) -> ArKeyHandler
        __init__(self, bool blocking=False) -> ArKeyHandler
        __init__(self) -> ArKeyHandler
        """
        this = apply(_AriaPy.new_ArKeyHandler, args)
        try: self.this.append(this)
        except: 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(*args):
        """addKeyHandler(self, int keyToHandle, ArFunctor functor) -> bool"""
        return apply(_AriaPy.ArKeyHandler_addKeyHandler, args)

    def remKeyHandler(*args):
        """
        remKeyHandler(self, int keyToHandler) -> bool
        remKeyHandler(self, ArFunctor functor) -> bool
        """
        return apply(_AriaPy.ArKeyHandler_remKeyHandler, args)

    def takeKeys(*args):
        """
        takeKeys(self, bool blocking=False)
        takeKeys(self)
        """
        return apply(_AriaPy.ArKeyHandler_takeKeys, args)

    def restore(*args):
        """restore(self)"""
        return apply(_AriaPy.ArKeyHandler_restore, args)

    def checkKeys(*args):
        """checkKeys(self)"""
        return apply(_AriaPy.ArKeyHandler_checkKeys, args)

    def getKey(*args):
        """getKey(self) -> int"""
        return apply(_AriaPy.ArKeyHandler_getKey, args)

ArKeyHandler_swigregister = _AriaPy.ArKeyHandler_swigregister
ArKeyHandler_swigregister(ArKeyHandler)

class ArLMS2xx(ArLaser):
    """Proxy of C++ ArLMS2xx class"""
    __swig_setmethods__ = {}
    for _s in [ArLaser]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLMS2xx, name, value)
    __swig_getmethods__ = {}
    for _s in [ArLaser]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArLMS2xx, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, int laserNumber, char name="lms2xx", bool appendLaserNumberToName=True) -> ArLMS2xx
        __init__(self, int laserNumber, char name="lms2xx") -> ArLMS2xx
        __init__(self, int laserNumber) -> ArLMS2xx
        """
        this = apply(_AriaPy.new_ArLMS2xx, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLMS2xx
    __del__ = lambda self : None;
    def blockingConnect(*args):
        """blockingConnect(self) -> bool"""
        return apply(_AriaPy.ArLMS2xx_blockingConnect, args)

    def asyncConnect(*args):
        """asyncConnect(self) -> bool"""
        return apply(_AriaPy.ArLMS2xx_asyncConnect, args)

    def disconnect(*args):
        """disconnect(self) -> bool"""
        return apply(_AriaPy.ArLMS2xx_disconnect, args)

    def isConnected(*args):
        """isConnected(self) -> bool"""
        return apply(_AriaPy.ArLMS2xx_isConnected, args)

    def isTryingToConnect(*args):
        """isTryingToConnect(self) -> bool"""
        return apply(_AriaPy.ArLMS2xx_isTryingToConnect, args)

    def setDeviceConnection(*args):
        """setDeviceConnection(self, ArDeviceConnection conn)"""
        return apply(_AriaPy.ArLMS2xx_setDeviceConnection, args)

    def runThread(*args):
        """runThread(self, void arg) -> void"""
        return apply(_AriaPy.ArLMS2xx_runThread, args)

    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArLMS2xx_setRobot, args)

ArLMS2xx_swigregister = _AriaPy.ArLMS2xx_swigregister
ArLMS2xx_swigregister(ArLMS2xx)

class ArLMS2xxPacket(ArBasePacket):
    """Proxy of C++ ArLMS2xxPacket class"""
    __swig_setmethods__ = {}
    for _s in [ArBasePacket]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLMS2xxPacket, name, value)
    __swig_getmethods__ = {}
    for _s in [ArBasePacket]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArLMS2xxPacket, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, unsigned char sendingAddress=0) -> ArLMS2xxPacket
        __init__(self) -> ArLMS2xxPacket
        """
        this = apply(_AriaPy.new_ArLMS2xxPacket, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLMS2xxPacket
    __del__ = lambda self : None;
    def setSendingAddress(*args):
        """setSendingAddress(self, unsigned char address)"""
        return apply(_AriaPy.ArLMS2xxPacket_setSendingAddress, args)

    def getSendingAddress(*args):
        """getSendingAddress(self) -> unsigned char"""
        return apply(_AriaPy.ArLMS2xxPacket_getSendingAddress, args)

    def getReceivedAddress(*args):
        """getReceivedAddress(self) -> unsigned char"""
        return apply(_AriaPy.ArLMS2xxPacket_getReceivedAddress, args)

    def verifyCRC(*args):
        """verifyCRC(self) -> bool"""
        return apply(_AriaPy.ArLMS2xxPacket_verifyCRC, args)

    def getID(*args):
        """getID(self) -> UByte"""
        return apply(_AriaPy.ArLMS2xxPacket_getID, args)

    def calcCRC(*args):
        """calcCRC(self) -> Byte2"""
        return apply(_AriaPy.ArLMS2xxPacket_calcCRC, args)

    def finalizePacket(*args):
        """finalizePacket(self)"""
        return apply(_AriaPy.ArLMS2xxPacket_finalizePacket, args)

    def resetRead(*args):
        """resetRead(self)"""
        return apply(_AriaPy.ArLMS2xxPacket_resetRead, args)

    def getTimeReceived(*args):
        """getTimeReceived(self) -> ArTime"""
        return apply(_AriaPy.ArLMS2xxPacket_getTimeReceived, args)

    def setTimeReceived(*args):
        """setTimeReceived(self, ArTime timeReceived)"""
        return apply(_AriaPy.ArLMS2xxPacket_setTimeReceived, args)

    def duplicatePacket(*args):
        """duplicatePacket(self, ArLMS2xxPacket packet)"""
        return apply(_AriaPy.ArLMS2xxPacket_duplicatePacket, args)

ArLMS2xxPacket_swigregister = _AriaPy.ArLMS2xxPacket_swigregister
ArLMS2xxPacket_swigregister(ArLMS2xxPacket)

class ArLMS2xxPacketReceiver:
    """Proxy of C++ ArLMS2xxPacketReceiver class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLMS2xxPacketReceiver, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArLMS2xxPacketReceiver, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, unsigned char receivingAddress=0, bool allocatePackets=False, 
            bool useBase0Address=False) -> ArLMS2xxPacketReceiver
        __init__(self, unsigned char receivingAddress=0, bool allocatePackets=False) -> ArLMS2xxPacketReceiver
        __init__(self, unsigned char receivingAddress=0) -> ArLMS2xxPacketReceiver
        __init__(self) -> ArLMS2xxPacketReceiver
        __init__(self, ArDeviceConnection deviceConnection, unsigned char receivingAddress=0, 
            bool allocatePackets=False, 
            bool useBase0Address=False) -> ArLMS2xxPacketReceiver
        __init__(self, ArDeviceConnection deviceConnection, unsigned char receivingAddress=0, 
            bool allocatePackets=False) -> ArLMS2xxPacketReceiver
        __init__(self, ArDeviceConnection deviceConnection, unsigned char receivingAddress=0) -> ArLMS2xxPacketReceiver
        __init__(self, ArDeviceConnection deviceConnection) -> ArLMS2xxPacketReceiver
        """
        this = apply(_AriaPy.new_ArLMS2xxPacketReceiver, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLMS2xxPacketReceiver
    __del__ = lambda self : None;
    def receivePacket(*args):
        """
        receivePacket(self, unsigned int msWait=0) -> ArLMS2xxPacket
        receivePacket(self) -> ArLMS2xxPacket
        """
        return apply(_AriaPy.ArLMS2xxPacketReceiver_receivePacket, args)

    def setDeviceConnection(*args):
        """setDeviceConnection(self, ArDeviceConnection deviceConnection)"""
        return apply(_AriaPy.ArLMS2xxPacketReceiver_setDeviceConnection, args)

    def getDeviceConnection(*args):
        """getDeviceConnection(self) -> ArDeviceConnection"""
        return apply(_AriaPy.ArLMS2xxPacketReceiver_getDeviceConnection, args)

    def isAllocatingPackets(*args):
        """isAllocatingPackets(self) -> bool"""
        return apply(_AriaPy.ArLMS2xxPacketReceiver_isAllocatingPackets, args)

ArLMS2xxPacketReceiver_swigregister = _AriaPy.ArLMS2xxPacketReceiver_swigregister
ArLMS2xxPacketReceiver_swigregister(ArLMS2xxPacketReceiver)

class ArLaserConnector:
    """Proxy of C++ ArLaserConnector class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLaserConnector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArLaserConnector, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArArgumentParser parser, ArRobot robot, ArRobotConnector robotConnector, 
            bool autoParseArgs=True, 
            LogLevel infoLogLevel=Verbose) -> ArLaserConnector
        __init__(self, ArArgumentParser parser, ArRobot robot, ArRobotConnector robotConnector, 
            bool autoParseArgs=True) -> ArLaserConnector
        __init__(self, ArArgumentParser parser, ArRobot robot, ArRobotConnector robotConnector) -> ArLaserConnector
        """
        this = apply(_AriaPy.new_ArLaserConnector, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLaserConnector
    __del__ = lambda self : None;
    def connectLasers(*args):
        """
        connectLasers(self, bool continueOnFailedConnect=False, bool addConnectedLasersToRobot=True, 
            bool addAllLasersToRobot=False, 
            bool turnOnLasers=True, bool powerCycleLaserOnFailedConnect=True) -> bool
        connectLasers(self, bool continueOnFailedConnect=False, bool addConnectedLasersToRobot=True, 
            bool addAllLasersToRobot=False, 
            bool turnOnLasers=True) -> bool
        connectLasers(self, bool continueOnFailedConnect=False, bool addConnectedLasersToRobot=True, 
            bool addAllLasersToRobot=False) -> bool
        connectLasers(self, bool continueOnFailedConnect=False, bool addConnectedLasersToRobot=True) -> bool
        connectLasers(self, bool continueOnFailedConnect=False) -> bool
        connectLasers(self) -> bool
        """
        return apply(_AriaPy.ArLaserConnector_connectLasers, args)

    def setupLaser(*args):
        """
        setupLaser(self, ArLaser laser, int laserNumber=1) -> bool
        setupLaser(self, ArLaser laser) -> bool
        """
        return apply(_AriaPy.ArLaserConnector_setupLaser, args)

    def connectLaser(*args):
        """
        connectLaser(self, ArLaser laser, int laserNumber=1, bool forceConnection=True) -> bool
        connectLaser(self, ArLaser laser, int laserNumber=1) -> bool
        connectLaser(self, ArLaser laser) -> bool
        """
        return apply(_AriaPy.ArLaserConnector_connectLaser, args)

    def addLaser(*args):
        """
        addLaser(self, ArLaser laser, int laserNumber=1) -> bool
        addLaser(self, ArLaser laser) -> bool
        """
        return apply(_AriaPy.ArLaserConnector_addLaser, args)

    def addPlaceholderLaser(*args):
        """
        addPlaceholderLaser(self, ArLaser placeholderLaser, int laserNumber=1, bool takeOwnershipOfPlaceholder=False) -> bool
        addPlaceholderLaser(self, ArLaser placeholderLaser, int laserNumber=1) -> bool
        addPlaceholderLaser(self, ArLaser placeholderLaser) -> bool
        """
        return apply(_AriaPy.ArLaserConnector_addPlaceholderLaser, args)

    def parseArgs(*args):
        """
        parseArgs(self) -> bool
        parseArgs(self, ArArgumentParser parser) -> bool
        """
        return apply(_AriaPy.ArLaserConnector_parseArgs, args)

    def logOptions(*args):
        """logOptions(self)"""
        return apply(_AriaPy.ArLaserConnector_logOptions, args)

ArLaserConnector_swigregister = _AriaPy.ArLaserConnector_swigregister
ArLaserConnector_swigregister(ArLaserConnector)

class ArLaserFilter(ArLaser):
    """Proxy of C++ ArLaserFilter class"""
    __swig_setmethods__ = {}
    for _s in [ArLaser]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLaserFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [ArLaser]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArLaserFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArLaser laser, char name=None) -> ArLaserFilter
        __init__(self, ArLaser laser) -> ArLaserFilter
        """
        this = apply(_AriaPy.new_ArLaserFilter, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLaserFilter
    __del__ = lambda self : None;
    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArLaserFilter_setRobot, args)

    def addToConfig(*args):
        """
        addToConfig(self, ArConfig config, char sectionName, char prefix="")
        addToConfig(self, ArConfig config, char sectionName)
        """
        return apply(_AriaPy.ArLaserFilter_addToConfig, args)

    def blockingConnect(*args):
        """blockingConnect(self) -> bool"""
        return apply(_AriaPy.ArLaserFilter_blockingConnect, args)

    def asyncConnect(*args):
        """asyncConnect(self) -> bool"""
        return apply(_AriaPy.ArLaserFilter_asyncConnect, args)

    def disconnect(*args):
        """disconnect(self) -> bool"""
        return apply(_AriaPy.ArLaserFilter_disconnect, args)

    def isConnected(*args):
        """isConnected(self) -> bool"""
        return apply(_AriaPy.ArLaserFilter_isConnected, args)

    def isTryingToConnect(*args):
        """isTryingToConnect(self) -> bool"""
        return apply(_AriaPy.ArLaserFilter_isTryingToConnect, args)

    def runThread(*args):
        """runThread(self, void arg) -> void"""
        return apply(_AriaPy.ArLaserFilter_runThread, args)

    def laserCheckParams(*args):
        """laserCheckParams(self) -> bool"""
        return apply(_AriaPy.ArLaserFilter_laserCheckParams, args)

    def getBaseLaser(*args):
        """getBaseLaser(self) -> ArLaser"""
        return apply(_AriaPy.ArLaserFilter_getBaseLaser, args)

ArLaserFilter_swigregister = _AriaPy.ArLaserFilter_swigregister
ArLaserFilter_swigregister(ArLaserFilter)

class ArLaserLogger:
    """Proxy of C++ ArLaserLogger class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLaserLogger, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArLaserLogger, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, 
            char fileName, bool addGoals=False, 
            ArJoyHandler joyHandler=None, char baseDirectory=None, 
            bool useReflectorValues=False, ArRobotJoyHandler robotJoyHandler=None, 
            std::map<(std::string,p.ArRetFunctor2<(int,ArTime,p.ArPose)>,ArStrCaseCmpOp,std::allocator<(std::pair<(q(const).std::string,p.ArRetFunctor2<(int,ArTime,p.ArPose)>)>)>)> extraLocationData=None) -> ArLaserLogger
        __init__(self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, 
            char fileName, bool addGoals=False, 
            ArJoyHandler joyHandler=None, char baseDirectory=None, 
            bool useReflectorValues=False, ArRobotJoyHandler robotJoyHandler=None) -> ArLaserLogger
        __init__(self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, 
            char fileName, bool addGoals=False, 
            ArJoyHandler joyHandler=None, char baseDirectory=None, 
            bool useReflectorValues=False) -> ArLaserLogger
        __init__(self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, 
            char fileName, bool addGoals=False, 
            ArJoyHandler joyHandler=None, char baseDirectory=None) -> ArLaserLogger
        __init__(self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, 
            char fileName, bool addGoals=False, 
            ArJoyHandler joyHandler=None) -> ArLaserLogger
        __init__(self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, 
            char fileName, bool addGoals=False) -> ArLaserLogger
        __init__(self, ArRobot robot, ArLaser laser, double distDiff, double degDiff, 
            char fileName) -> ArLaserLogger
        """
        this = apply(_AriaPy.new_ArLaserLogger, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLaserLogger
    __del__ = lambda self : None;
    def addTagToLogPlain(*args):
        """addTagToLogPlain(self, char str)"""
        return apply(_AriaPy.ArLaserLogger_addTagToLogPlain, args)

    def addInfoToLogPlain(*args):
        """addInfoToLogPlain(self, char str)"""
        return apply(_AriaPy.ArLaserLogger_addInfoToLogPlain, args)

    def setDistDiff(*args):
        """setDistDiff(self, double distDiff)"""
        return apply(_AriaPy.ArLaserLogger_setDistDiff, args)

    def getDistDiff(*args):
        """getDistDiff(self) -> double"""
        return apply(_AriaPy.ArLaserLogger_getDistDiff, args)

    def setDegDiff(*args):
        """setDegDiff(self, double degDiff)"""
        return apply(_AriaPy.ArLaserLogger_setDegDiff, args)

    def getDegDiff(*args):
        """getDegDiff(self) -> double"""
        return apply(_AriaPy.ArLaserLogger_getDegDiff, args)

    def takeReading(*args):
        """takeReading(self)"""
        return apply(_AriaPy.ArLaserLogger_takeReading, args)

    def addGoal(*args):
        """addGoal(self)"""
        return apply(_AriaPy.ArLaserLogger_addGoal, args)

    def wasFileOpenedSuccessfully(*args):
        """wasFileOpenedSuccessfully(self) -> bool"""
        return apply(_AriaPy.ArLaserLogger_wasFileOpenedSuccessfully, args)

    def takingOldReadings(*args):
        """takingOldReadings(self) -> bool"""
        return apply(_AriaPy.ArLaserLogger_takingOldReadings, args)

    def takeOldReadings(*args):
        """takeOldReadings(self, bool takeOld)"""
        return apply(_AriaPy.ArLaserLogger_takeOldReadings, args)

    def takingNewReadings(*args):
        """takingNewReadings(self) -> bool"""
        return apply(_AriaPy.ArLaserLogger_takingNewReadings, args)

    def takeNewReadings(*args):
        """takeNewReadings(self, bool takeNew)"""
        return apply(_AriaPy.ArLaserLogger_takeNewReadings, args)

ArLaserLogger_swigregister = _AriaPy.ArLaserLogger_swigregister
ArLaserLogger_swigregister(ArLaserLogger)

class ArLaserReflectorDevice(ArRangeDevice):
    """Proxy of C++ ArLaserReflectorDevice class"""
    __swig_setmethods__ = {}
    for _s in [ArRangeDevice]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLaserReflectorDevice, name, value)
    __swig_getmethods__ = {}
    for _s in [ArRangeDevice]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArLaserReflectorDevice, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRangeDevice laser, ArRobot robot, char name="reflector") -> ArLaserReflectorDevice
        __init__(self, ArRangeDevice laser, ArRobot robot) -> ArLaserReflectorDevice
        """
        this = apply(_AriaPy.new_ArLaserReflectorDevice, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLaserReflectorDevice
    __del__ = lambda self : None;
    def processReadings(*args):
        """processReadings(self)"""
        return apply(_AriaPy.ArLaserReflectorDevice_processReadings, args)

    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArLaserReflectorDevice_setRobot, args)

    def addToConfig(*args):
        """addToConfig(self, ArConfig config, char section)"""
        return apply(_AriaPy.ArLaserReflectorDevice_addToConfig, args)

ArLaserReflectorDevice_swigregister = _AriaPy.ArLaserReflectorDevice_swigregister
ArLaserReflectorDevice_swigregister(ArLaserReflectorDevice)

class ArLineFinder:
    """Proxy of C++ ArLineFinder class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLineFinder, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArLineFinder, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRangeDevice dev) -> ArLineFinder"""
        this = apply(_AriaPy.new_ArLineFinder, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLineFinder
    __del__ = lambda self : None;
    def getLinesAsSet(*args):
        """getLinesAsSet(self) -> std::set<(p.ArLineFinderSegment,std::less<(p.ArLineFinderSegment)>,std::allocator<(p.ArLineFinderSegment)>)>"""
        return apply(_AriaPy.ArLineFinder_getLinesAsSet, args)

    def getNonLinePointsAsSet(*args):
        """getNonLinePointsAsSet(self) -> std::set<(ArPose,std::less<(ArPose)>,std::allocator<(ArPose)>)>"""
        return apply(_AriaPy.ArLineFinder_getNonLinePointsAsSet, args)

    def getLinesTakenPose(*args):
        """getLinesTakenPose(self) -> ArPose"""
        return apply(_AriaPy.ArLineFinder_getLinesTakenPose, args)

    def saveLast(*args):
        """saveLast(self)"""
        return apply(_AriaPy.ArLineFinder_saveLast, args)

    def getLinesAndSaveThem(*args):
        """getLinesAndSaveThem(self)"""
        return apply(_AriaPy.ArLineFinder_getLinesAndSaveThem, args)

    def setVerbose(*args):
        """setVerbose(self, bool verbose)"""
        return apply(_AriaPy.ArLineFinder_setVerbose, args)

    def getVerbose(*args):
        """getVerbose(self) -> bool"""
        return apply(_AriaPy.ArLineFinder_getVerbose, args)

    def setLineCreationParams(*args):
        """
        setLineCreationParams(self, int minLineLen=40, int minLinePoints=2)
        setLineCreationParams(self, int minLineLen=40)
        setLineCreationParams(self)
        """
        return apply(_AriaPy.ArLineFinder_setLineCreationParams, args)

    def setLineCombiningParams(*args):
        """
        setLineCombiningParams(self, int angleTol=30, int linesCloseEnough=75)
        setLineCombiningParams(self, int angleTol=30)
        setLineCombiningParams(self)
        """
        return apply(_AriaPy.ArLineFinder_setLineCombiningParams, args)

    def setLineFilteringParams(*args):
        """
        setLineFilteringParams(self, int minPointsInLine=3, int minLineLength=75)
        setLineFilteringParams(self, int minPointsInLine=3)
        setLineFilteringParams(self)
        """
        return apply(_AriaPy.ArLineFinder_setLineFilteringParams, args)

    def setLineValidParams(*args):
        """
        setLineValidParams(self, int maxDistFromLine=30, int maxAveDistFromLine=20)
        setLineValidParams(self, int maxDistFromLine=30)
        setLineValidParams(self)
        """
        return apply(_AriaPy.ArLineFinder_setLineValidParams, args)

    def setMaxDistBetweenPoints(*args):
        """
        setMaxDistBetweenPoints(self, int maxDistBetweenPoints=0)
        setMaxDistBetweenPoints(self)
        """
        return apply(_AriaPy.ArLineFinder_setMaxDistBetweenPoints, args)

    def addToConfig(*args):
        """addToConfig(self, ArConfig config, char section)"""
        return apply(_AriaPy.ArLineFinder_addToConfig, args)

ArLineFinder_swigregister = _AriaPy.ArLineFinder_swigregister
ArLineFinder_swigregister(ArLineFinder)

class ArLineFinderSegment(ArLineSegment):
    """Proxy of C++ ArLineFinderSegment class"""
    __swig_setmethods__ = {}
    for _s in [ArLineSegment]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLineFinderSegment, name, value)
    __swig_getmethods__ = {}
    for _s in [ArLineSegment]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArLineFinderSegment, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> ArLineFinderSegment
        __init__(self, double x1, double y1, double x2, double y2, int numPoints=0, 
            int startPoint=0, int endPoint=0) -> ArLineFinderSegment
        __init__(self, double x1, double y1, double x2, double y2, int numPoints=0, 
            int startPoint=0) -> ArLineFinderSegment
        __init__(self, double x1, double y1, double x2, double y2, int numPoints=0) -> ArLineFinderSegment
        __init__(self, double x1, double y1, double x2, double y2) -> ArLineFinderSegment
        """
        this = apply(_AriaPy.new_ArLineFinderSegment, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLineFinderSegment
    __del__ = lambda self : None;
    def newEndPoints(*args):
        """
        newEndPoints(self, double x1, double y1, double x2, double y2, int numPoints=0, 
            int startPoint=0, int endPoint=0)
        newEndPoints(self, double x1, double y1, double x2, double y2, int numPoints=0, 
            int startPoint=0)
        newEndPoints(self, double x1, double y1, double x2, double y2, int numPoints=0)
        newEndPoints(self, double x1, double y1, double x2, double y2)
        """
        return apply(_AriaPy.ArLineFinderSegment_newEndPoints, args)

    def getLineAngle(*args):
        """getLineAngle(self) -> double"""
        return apply(_AriaPy.ArLineFinderSegment_getLineAngle, args)

    def getLength(*args):
        """getLength(self) -> double"""
        return apply(_AriaPy.ArLineFinderSegment_getLength, args)

    def getNumPoints(*args):
        """getNumPoints(self) -> int"""
        return apply(_AriaPy.ArLineFinderSegment_getNumPoints, args)

    def getStartPoint(*args):
        """getStartPoint(self) -> int"""
        return apply(_AriaPy.ArLineFinderSegment_getStartPoint, args)

    def getEndPoint(*args):
        """getEndPoint(self) -> int"""
        return apply(_AriaPy.ArLineFinderSegment_getEndPoint, args)

    def setAveDistFromLine(*args):
        """setAveDistFromLine(self, double aveDistFromLine)"""
        return apply(_AriaPy.ArLineFinderSegment_setAveDistFromLine, args)

    def getAveDistFromLine(*args):
        """getAveDistFromLine(self) -> double"""
        return apply(_AriaPy.ArLineFinderSegment_getAveDistFromLine, args)

ArLineFinderSegment_swigregister = _AriaPy.ArLineFinderSegment_swigregister
ArLineFinderSegment_swigregister(ArLineFinderSegment)

class ArLog:
    """Proxy of C++ ArLog class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLog, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArLog, name)
    __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
    __swig_getmethods__["log"] = lambda x: _AriaPy.ArLog_log
    __swig_getmethods__["init"] = lambda x: _AriaPy.ArLog_init
    __swig_getmethods__["close"] = lambda x: _AriaPy.ArLog_close
    __swig_setmethods__["colbertPrint"] = _AriaPy.ArLog_colbertPrint_set
    __swig_getmethods__["colbertPrint"] = _AriaPy.ArLog_colbertPrint_get
    __swig_getmethods__["addToConfig"] = lambda x: _AriaPy.ArLog_addToConfig
    __swig_getmethods__["aramInit"] = lambda x: _AriaPy.ArLog_aramInit
    def __init__(self, *args): 
        """__init__(self) -> ArLog"""
        this = apply(_AriaPy.new_ArLog, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLog
    __del__ = lambda self : None;
ArLog_swigregister = _AriaPy.ArLog_swigregister
ArLog_swigregister(ArLog)

def ArLog_log(*args):
  """ArLog_log(LogLevel level, char str)"""
  return apply(_AriaPy.ArLog_log, args)

def ArLog_init(*args):
  """
    init(LogType type, LogLevel level, char fileName="", bool logTime=False, 
        bool alsoPrint=False, bool printThisCall=True) -> bool
    init(LogType type, LogLevel level, char fileName="", bool logTime=False, 
        bool alsoPrint=False) -> bool
    init(LogType type, LogLevel level, char fileName="", bool logTime=False) -> bool
    init(LogType type, LogLevel level, char fileName="") -> bool
    ArLog_init(LogType type, LogLevel level) -> bool
    """
  return apply(_AriaPy.ArLog_init, args)

def ArLog_close(*args):
  """ArLog_close()"""
  return apply(_AriaPy.ArLog_close, args)

def ArLog_addToConfig(*args):
  """ArLog_addToConfig(ArConfig config)"""
  return apply(_AriaPy.ArLog_addToConfig, args)

def ArLog_aramInit(*args):
  """
    aramInit(char prefix, LogLevel defaultLevel=Normal, double defaultSize=10)
    aramInit(char prefix, LogLevel defaultLevel=Normal)
    ArLog_aramInit(char prefix)
    """
  return apply(_AriaPy.ArLog_aramInit, args)

class ArLogFileConnection(ArDeviceConnection):
    """Proxy of C++ ArLogFileConnection class"""
    __swig_setmethods__ = {}
    for _s in [ArDeviceConnection]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArLogFileConnection, name, value)
    __swig_getmethods__ = {}
    for _s in [ArDeviceConnection]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArLogFileConnection, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArLogFileConnection"""
        this = apply(_AriaPy.new_ArLogFileConnection, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArLogFileConnection
    __del__ = lambda self : None;
    def open(*args):
        """
        open(self, char fname=None) -> int
        open(self) -> int
        """
        return apply(_AriaPy.ArLogFileConnection_open, args)

    def setLogFile(*args):
        """
        setLogFile(self, char fname=None)
        setLogFile(self)
        """
        return apply(_AriaPy.ArLogFileConnection_setLogFile, args)

    def openSimple(*args):
        """openSimple(self) -> bool"""
        return apply(_AriaPy.ArLogFileConnection_openSimple, args)

    def getStatus(*args):
        """getStatus(self) -> int"""
        return apply(_AriaPy.ArLogFileConnection_getStatus, args)

    def close(*args):
        """close(self) -> bool"""
        return apply(_AriaPy.ArLogFileConnection_close, args)

    def read(*args):
        """
        read(self, char data, unsigned int size, unsigned int msWait=0) -> int
        read(self, char data, unsigned int size) -> int
        """
        return apply(_AriaPy.ArLogFileConnection_read, args)

    def write(*args):
        """write(self, char data, unsigned int size) -> int"""
        return apply(_AriaPy.ArLogFileConnection_write, args)

    def getOpenMessage(*args):
        """getOpenMessage(self, int messageNumber) -> char"""
        return apply(_AriaPy.ArLogFileConnection_getOpenMessage, args)

    def getTimeRead(*args):
        """getTimeRead(self, int index) -> ArTime"""
        return apply(_AriaPy.ArLogFileConnection_getTimeRead, args)

    def isTimeStamping(*args):
        """isTimeStamping(self) -> bool"""
        return apply(_AriaPy.ArLogFileConnection_isTimeStamping, args)

    def getLogFile(*args):
        """getLogFile(self) -> char"""
        return apply(_AriaPy.ArLogFileConnection_getLogFile, args)

    def internalOpen(*args):
        """internalOpen(self) -> int"""
        return apply(_AriaPy.ArLogFileConnection_internalOpen, args)

    OPEN_FILE_NOT_FOUND = _AriaPy.ArLogFileConnection_OPEN_FILE_NOT_FOUND
    OPEN_NOT_A_LOG_FILE = _AriaPy.ArLogFileConnection_OPEN_NOT_A_LOG_FILE
    __swig_setmethods__["myPose"] = _AriaPy.ArLogFileConnection_myPose_set
    __swig_getmethods__["myPose"] = _AriaPy.ArLogFileConnection_myPose_get
    __swig_setmethods__["havePose"] = _AriaPy.ArLogFileConnection_havePose_set
    __swig_getmethods__["havePose"] = _AriaPy.ArLogFileConnection_havePose_get
    __swig_setmethods__["myName"] = _AriaPy.ArLogFileConnection_myName_set
    __swig_getmethods__["myName"] = _AriaPy.ArLogFileConnection_myName_get
    __swig_setmethods__["myType"] = _AriaPy.ArLogFileConnection_myType_set
    __swig_getmethods__["myType"] = _AriaPy.ArLogFileConnection_myType_get
    __swig_setmethods__["mySubtype"] = _AriaPy.ArLogFileConnection_mySubtype_set
    __swig_getmethods__["mySubtype"] = _AriaPy.ArLogFileConnection_mySubtype_get
ArLogFileConnection_swigregister = _AriaPy.ArLogFileConnection_swigregister
ArLogFileConnection_swigregister(ArLogFileConnection)

class ArMD5Calculator:
    """Proxy of C++ ArMD5Calculator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMD5Calculator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArMD5Calculator, name)
    __repr__ = _swig_repr
    DIGEST_LENGTH = _AriaPy.ArMD5Calculator_DIGEST_LENGTH
    DISPLAY_LENGTH = _AriaPy.ArMD5Calculator_DISPLAY_LENGTH
    __swig_getmethods__["toDisplay"] = lambda x: _AriaPy.ArMD5Calculator_toDisplay
    __swig_getmethods__["calculateChecksum"] = lambda x: _AriaPy.ArMD5Calculator_calculateChecksum
    def __init__(self, *args): 
        """
        __init__(self, ArFunctor1_CString secondFunctor=None) -> ArMD5Calculator
        __init__(self) -> ArMD5Calculator
        """
        this = apply(_AriaPy.new_ArMD5Calculator, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMD5Calculator
    __del__ = lambda self : None;
    def reset(*args):
        """reset(self)"""
        return apply(_AriaPy.ArMD5Calculator_reset, args)

    def append(*args):
        """append(self, char str)"""
        return apply(_AriaPy.ArMD5Calculator_append, args)

    def getDigest(*args):
        """getDigest(self) -> unsigned char"""
        return apply(_AriaPy.ArMD5Calculator_getDigest, args)

    def getFunctor(*args):
        """getFunctor(self) -> ArFunctor1_CString"""
        return apply(_AriaPy.ArMD5Calculator_getFunctor, args)

    def getSecondFunctor(*args):
        """getSecondFunctor(self) -> ArFunctor1_CString"""
        return apply(_AriaPy.ArMD5Calculator_getSecondFunctor, args)

    def setSecondFunctor(*args):
        """setSecondFunctor(self, ArFunctor1_CString secondFunctor)"""
        return apply(_AriaPy.ArMD5Calculator_setSecondFunctor, args)

ArMD5Calculator_swigregister = _AriaPy.ArMD5Calculator_swigregister
ArMD5Calculator_swigregister(ArMD5Calculator)

def ArMD5Calculator_toDisplay(*args):
  """
    ArMD5Calculator_toDisplay(unsigned char digestBuf, size_t digestLength, char displayBuf, 
        size_t displayLength)
    """
  return apply(_AriaPy.ArMD5Calculator_toDisplay, args)

def ArMD5Calculator_calculateChecksum(*args):
  """ArMD5Calculator_calculateChecksum(char fileName, unsigned char md5DigestBuffer, size_t md5DigestBufferLen) -> bool"""
  return apply(_AriaPy.ArMD5Calculator_calculateChecksum, args)

ARMAP_DEFAULT_SCAN_TYPE = _AriaPy.ARMAP_DEFAULT_SCAN_TYPE
class ArMapScanInterface:
    """Proxy of C++ ArMapScanInterface class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMapScanInterface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArMapScanInterface, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_getmethods__["isDefaultScanType"] = lambda x: _AriaPy.ArMapScanInterface_isDefaultScanType
    __swig_getmethods__["isSummaryScanType"] = lambda x: _AriaPy.ArMapScanInterface_isSummaryScanType
    __swig_destroy__ = _AriaPy.delete_ArMapScanInterface
    __del__ = lambda self : None;
    def getDisplayString(*args):
        """
        getDisplayString(self, char scanType="") -> char
        getDisplayString(self) -> char
        """
        return apply(_AriaPy.ArMapScanInterface_getDisplayString, args)

    def getPoints(*args):
        """
        getPoints(self, char scanType="") -> std::vector<(ArPose,std::allocator<(ArPose)>)>
        getPoints(self) -> std::vector<(ArPose,std::allocator<(ArPose)>)>
        """
        return apply(_AriaPy.ArMapScanInterface_getPoints, args)

    def getMinPose(*args):
        """
        getMinPose(self, char scanType="") -> ArPose
        getMinPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMapScanInterface_getMinPose, args)

    def getMaxPose(*args):
        """
        getMaxPose(self, char scanType="") -> ArPose
        getMaxPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMapScanInterface_getMaxPose, args)

    def getNumPoints(*args):
        """
        getNumPoints(self, char scanType="") -> int
        getNumPoints(self) -> int
        """
        return apply(_AriaPy.ArMapScanInterface_getNumPoints, args)

    def isSortedPoints(*args):
        """
        isSortedPoints(self, char scanType="") -> bool
        isSortedPoints(self) -> bool
        """
        return apply(_AriaPy.ArMapScanInterface_isSortedPoints, args)

    def setPoints(*args):
        """
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points, 
            char scanType="", bool isSortedPoints=False, 
            ArMapChangeDetails changeDetails=None)
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points, 
            char scanType="", bool isSortedPoints=False)
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points, 
            char scanType="")
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points)
        """
        return apply(_AriaPy.ArMapScanInterface_setPoints, args)

    def getLines(*args):
        """
        getLines(self, char scanType="") -> std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>
        getLines(self) -> std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>
        """
        return apply(_AriaPy.ArMapScanInterface_getLines, args)

    def getLineMinPose(*args):
        """
        getLineMinPose(self, char scanType="") -> ArPose
        getLineMinPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMapScanInterface_getLineMinPose, args)

    def getLineMaxPose(*args):
        """
        getLineMaxPose(self, char scanType="") -> ArPose
        getLineMaxPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMapScanInterface_getLineMaxPose, args)

    def getNumLines(*args):
        """
        getNumLines(self, char scanType="") -> int
        getNumLines(self) -> int
        """
        return apply(_AriaPy.ArMapScanInterface_getNumLines, args)

    def isSortedLines(*args):
        """
        isSortedLines(self, char scanType="") -> bool
        isSortedLines(self) -> bool
        """
        return apply(_AriaPy.ArMapScanInterface_isSortedLines, args)

    def setLines(*args):
        """
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines, 
            char scanType="", bool isSortedLines=False, 
            ArMapChangeDetails changeDetails=None)
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines, 
            char scanType="", bool isSortedLines=False)
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines, 
            char scanType="")
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines)
        """
        return apply(_AriaPy.ArMapScanInterface_setLines, args)

    def getResolution(*args):
        """
        getResolution(self, char scanType="") -> int
        getResolution(self) -> int
        """
        return apply(_AriaPy.ArMapScanInterface_getResolution, args)

    def setResolution(*args):
        """
        setResolution(self, int resolution, char scanType="", ArMapChangeDetails changeDetails=None)
        setResolution(self, int resolution, char scanType="")
        setResolution(self, int resolution)
        """
        return apply(_AriaPy.ArMapScanInterface_setResolution, args)

    def writeScanToFunctor(*args):
        """
        writeScanToFunctor(self, ArFunctor1_CString functor, char endOfLineChars, char scanType="")
        writeScanToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)
        """
        return apply(_AriaPy.ArMapScanInterface_writeScanToFunctor, args)

    def writePointsToFunctor(*args):
        """
        writePointsToFunctor(self, ArFunctor2<(int,p.std::vector<(ArPose,std::allocator<(ArPose)>)>)> functor, 
            char scanType="", ArFunctor1_CString keywordFunctor=None)
        writePointsToFunctor(self, ArFunctor2<(int,p.std::vector<(ArPose,std::allocator<(ArPose)>)>)> functor, 
            char scanType="")
        writePointsToFunctor(self, ArFunctor2<(int,p.std::vector<(ArPose,std::allocator<(ArPose)>)>)> functor)
        """
        return apply(_AriaPy.ArMapScanInterface_writePointsToFunctor, args)

    def writeLinesToFunctor(*args):
        """
        writeLinesToFunctor(self, ArFunctor2<(int,p.std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>)> functor, 
            char scanType="", 
            ArFunctor1_CString keywordFunctor=None)
        writeLinesToFunctor(self, ArFunctor2<(int,p.std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>)> functor, 
            char scanType="")
        writeLinesToFunctor(self, ArFunctor2<(int,p.std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>)> functor)
        """
        return apply(_AriaPy.ArMapScanInterface_writeLinesToFunctor, args)

    def addToFileParser(*args):
        """addToFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMapScanInterface_addToFileParser, args)

    def remFromFileParser(*args):
        """remFromFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMapScanInterface_remFromFileParser, args)

    def readDataPoint(*args):
        """readDataPoint(self, char line) -> bool"""
        return apply(_AriaPy.ArMapScanInterface_readDataPoint, args)

    def readLineSegment(*args):
        """readLineSegment(self, char line) -> bool"""
        return apply(_AriaPy.ArMapScanInterface_readLineSegment, args)

    def loadDataPoint(*args):
        """loadDataPoint(self, double x, double y)"""
        return apply(_AriaPy.ArMapScanInterface_loadDataPoint, args)

    def loadLineSegment(*args):
        """loadLineSegment(self, double x1, double y1, double x2, double y2)"""
        return apply(_AriaPy.ArMapScanInterface_loadLineSegment, args)

ArMapScanInterface_swigregister = _AriaPy.ArMapScanInterface_swigregister
ArMapScanInterface_swigregister(ArMapScanInterface)

def ArMapScanInterface_isDefaultScanType(*args):
  """ArMapScanInterface_isDefaultScanType(char scanType) -> bool"""
  return apply(_AriaPy.ArMapScanInterface_isDefaultScanType, args)

def ArMapScanInterface_isSummaryScanType(*args):
  """ArMapScanInterface_isSummaryScanType(char scanType) -> bool"""
  return apply(_AriaPy.ArMapScanInterface_isSummaryScanType, args)

class ArMapObjectsInterface:
    """Proxy of C++ ArMapObjectsInterface class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMapObjectsInterface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArMapObjectsInterface, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArMapObjectsInterface
    __del__ = lambda self : None;
    def findFirstMapObject(*args):
        """
        findFirstMapObject(self, char name, char type, bool isIncludeWithHeading=False) -> ArMapObject
        findFirstMapObject(self, char name, char type) -> ArMapObject
        """
        return apply(_AriaPy.ArMapObjectsInterface_findFirstMapObject, args)

    def findMapObject(*args):
        """
        findMapObject(self, char name, char type=None, bool isIncludeWithHeading=False) -> ArMapObject
        findMapObject(self, char name, char type=None) -> ArMapObject
        findMapObject(self, char name) -> ArMapObject
        """
        return apply(_AriaPy.ArMapObjectsInterface_findMapObject, args)

    def findMapObjectsOfType(*args):
        """
        findMapObjectsOfType(self, char type, bool isIncludeWithHeading=False) -> ArMapObjectPtrList
        findMapObjectsOfType(self, char type) -> ArMapObjectPtrList
        """
        return apply(_AriaPy.ArMapObjectsInterface_findMapObjectsOfType, args)

    def getMapObjects(*args):
        """getMapObjects(self) -> ArMapObjectPtrList"""
        return apply(_AriaPy.ArMapObjectsInterface_getMapObjects, args)

    def setMapObjects(*args):
        """
        setMapObjects(self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False, 
            ArMapChangeDetails changeDetails=None)
        setMapObjects(self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False)
        setMapObjects(self, ArMapObjectPtrList mapObjects)
        """
        return apply(_AriaPy.ArMapObjectsInterface_setMapObjects, args)

    def writeObjectListToFunctor(*args):
        """writeObjectListToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMapObjectsInterface_writeObjectListToFunctor, args)

ArMapObjectsInterface_swigregister = _AriaPy.ArMapObjectsInterface_swigregister
ArMapObjectsInterface_swigregister(ArMapObjectsInterface)

class ArMapInfoInterface:
    """Proxy of C++ ArMapInfoInterface class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMapInfoInterface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArMapInfoInterface, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_setmethods__["MAP_INFO_NAME"] = _AriaPy.ArMapInfoInterface_MAP_INFO_NAME_set
    __swig_getmethods__["MAP_INFO_NAME"] = _AriaPy.ArMapInfoInterface_MAP_INFO_NAME_get
    __swig_setmethods__["META_INFO_NAME"] = _AriaPy.ArMapInfoInterface_META_INFO_NAME_set
    __swig_getmethods__["META_INFO_NAME"] = _AriaPy.ArMapInfoInterface_META_INFO_NAME_get
    __swig_setmethods__["TASK_INFO_NAME"] = _AriaPy.ArMapInfoInterface_TASK_INFO_NAME_set
    __swig_getmethods__["TASK_INFO_NAME"] = _AriaPy.ArMapInfoInterface_TASK_INFO_NAME_get
    __swig_setmethods__["ROUTE_INFO_NAME"] = _AriaPy.ArMapInfoInterface_ROUTE_INFO_NAME_set
    __swig_getmethods__["ROUTE_INFO_NAME"] = _AriaPy.ArMapInfoInterface_ROUTE_INFO_NAME_get
    __swig_setmethods__["SCHED_TASK_INFO_NAME"] = _AriaPy.ArMapInfoInterface_SCHED_TASK_INFO_NAME_set
    __swig_getmethods__["SCHED_TASK_INFO_NAME"] = _AriaPy.ArMapInfoInterface_SCHED_TASK_INFO_NAME_get
    __swig_setmethods__["SCHED_INFO_NAME"] = _AriaPy.ArMapInfoInterface_SCHED_INFO_NAME_set
    __swig_getmethods__["SCHED_INFO_NAME"] = _AriaPy.ArMapInfoInterface_SCHED_INFO_NAME_get
    __swig_setmethods__["CAIRN_INFO_NAME"] = _AriaPy.ArMapInfoInterface_CAIRN_INFO_NAME_set
    __swig_getmethods__["CAIRN_INFO_NAME"] = _AriaPy.ArMapInfoInterface_CAIRN_INFO_NAME_get
    __swig_setmethods__["CUSTOM_INFO_NAME"] = _AriaPy.ArMapInfoInterface_CUSTOM_INFO_NAME_set
    __swig_getmethods__["CUSTOM_INFO_NAME"] = _AriaPy.ArMapInfoInterface_CUSTOM_INFO_NAME_get
    __swig_destroy__ = _AriaPy.delete_ArMapInfoInterface
    __del__ = lambda self : None;
    def getInfoCount(*args):
        """getInfoCount(self) -> int"""
        return apply(_AriaPy.ArMapInfoInterface_getInfoCount, args)

    def getInfoNames(*args):
        """getInfoNames(self) -> std::list<(std::string,std::allocator<(std::string)>)>"""
        return apply(_AriaPy.ArMapInfoInterface_getInfoNames, args)

    def getInfo(*args):
        """
        getInfo(self, char infoName) -> ArArgumentBuilderPtrList
        getInfo(self, int infoType) -> ArArgumentBuilderPtrList
        """
        return apply(_AriaPy.ArMapInfoInterface_getInfo, args)

    def getMapInfo(*args):
        """getMapInfo(self) -> ArArgumentBuilderPtrList"""
        return apply(_AriaPy.ArMapInfoInterface_getMapInfo, args)

    def setInfo(*args):
        """
        setInfo(self, char infoName, ArArgumentBuilderPtrList infoList, ArMapChangeDetails changeDetails=None) -> bool
        setInfo(self, char infoName, ArArgumentBuilderPtrList infoList) -> bool
        setInfo(self, int infoType, ArArgumentBuilderPtrList infoList, ArMapChangeDetails changeDetails=None) -> bool
        setInfo(self, int infoType, ArArgumentBuilderPtrList infoList) -> bool
        """
        return apply(_AriaPy.ArMapInfoInterface_setInfo, args)

    def setMapInfo(*args):
        """
        setMapInfo(self, ArArgumentBuilderPtrList mapInfo, ArMapChangeDetails changeDetails=None) -> bool
        setMapInfo(self, ArArgumentBuilderPtrList mapInfo) -> bool
        """
        return apply(_AriaPy.ArMapInfoInterface_setMapInfo, args)

    def writeInfoToFunctor(*args):
        """writeInfoToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMapInfoInterface_writeInfoToFunctor, args)

    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(*args):
        """getInfoName(self, int infoType) -> char"""
        return apply(_AriaPy.ArMapInfoInterface_getInfoName, args)

ArMapInfoInterface_swigregister = _AriaPy.ArMapInfoInterface_swigregister
ArMapInfoInterface_swigregister(ArMapInfoInterface)

class ArMapSupplementInterface:
    """Proxy of C++ ArMapSupplementInterface class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMapSupplementInterface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArMapSupplementInterface, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArMapSupplementInterface
    __del__ = lambda self : None;
    def hasOriginLatLongAlt(*args):
        """hasOriginLatLongAlt(self) -> bool"""
        return apply(_AriaPy.ArMapSupplementInterface_hasOriginLatLongAlt, args)

    def getOriginLatLong(*args):
        """getOriginLatLong(self) -> ArPose"""
        return apply(_AriaPy.ArMapSupplementInterface_getOriginLatLong, args)

    def getOriginAltitude(*args):
        """getOriginAltitude(self) -> double"""
        return apply(_AriaPy.ArMapSupplementInterface_getOriginAltitude, args)

    def setOriginLatLongAlt(*args):
        """
        setOriginLatLongAlt(self, bool hasOriginLatLong, ArPose originLatLong, double altitude, 
            ArMapChangeDetails changeDetails=None)
        setOriginLatLongAlt(self, bool hasOriginLatLong, ArPose originLatLong, double altitude)
        """
        return apply(_AriaPy.ArMapSupplementInterface_setOriginLatLongAlt, args)

    def writeSupplementToFunctor(*args):
        """writeSupplementToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMapSupplementInterface_writeSupplementToFunctor, args)

ArMapSupplementInterface_swigregister = _AriaPy.ArMapSupplementInterface_swigregister
ArMapSupplementInterface_swigregister(ArMapSupplementInterface)

class ArMapInterface(ArMapInfoInterface,ArMapObjectsInterface,ArMapScanInterface,ArMapSupplementInterface):
    """Proxy of C++ ArMapInterface class"""
    __swig_setmethods__ = {}
    for _s in [ArMapInfoInterface,ArMapObjectsInterface,ArMapScanInterface,ArMapSupplementInterface]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMapInterface, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMapInfoInterface,ArMapObjectsInterface,ArMapScanInterface,ArMapSupplementInterface]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArMapInterface, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    MAX_MAP_NAME_LENGTH = _AriaPy.ArMapInterface_MAX_MAP_NAME_LENGTH
    __swig_setmethods__["MAP_CATEGORY_2D"] = _AriaPy.ArMapInterface_MAP_CATEGORY_2D_set
    __swig_getmethods__["MAP_CATEGORY_2D"] = _AriaPy.ArMapInterface_MAP_CATEGORY_2D_get
    __swig_setmethods__["MAP_CATEGORY_2D_MULTI_SOURCES"] = _AriaPy.ArMapInterface_MAP_CATEGORY_2D_MULTI_SOURCES_set
    __swig_getmethods__["MAP_CATEGORY_2D_MULTI_SOURCES"] = _AriaPy.ArMapInterface_MAP_CATEGORY_2D_MULTI_SOURCES_get
    __swig_setmethods__["MAP_CATEGORY_2D_EXTENDED"] = _AriaPy.ArMapInterface_MAP_CATEGORY_2D_EXTENDED_set
    __swig_getmethods__["MAP_CATEGORY_2D_EXTENDED"] = _AriaPy.ArMapInterface_MAP_CATEGORY_2D_EXTENDED_get
    __swig_destroy__ = _AriaPy.delete_ArMapInterface
    __del__ = lambda self : None;
    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArMapInterface_clear, args)

    def set(*args):
        """set(self, ArMapInterface other) -> bool"""
        return apply(_AriaPy.ArMapInterface_set, args)

    def clone(*args):
        """clone(self) -> ArMapInterface"""
        return apply(_AriaPy.ArMapInterface_clone, args)

    def getScanTypes(*args):
        """getScanTypes(self) -> std::list<(std::string,std::allocator<(std::string)>)>"""
        return apply(_AriaPy.ArMapInterface_getScanTypes, args)

    def setScanTypes(*args):
        """setScanTypes(self, std::list<(std::string,std::allocator<(std::string)>)> scanTypeList) -> bool"""
        return apply(_AriaPy.ArMapInterface_setScanTypes, args)

    def lock(*args):
        """lock(self) -> int"""
        return apply(_AriaPy.ArMapInterface_lock, args)

    def tryLock(*args):
        """tryLock(self) -> int"""
        return apply(_AriaPy.ArMapInterface_tryLock, args)

    def unlock(*args):
        """unlock(self) -> int"""
        return apply(_AriaPy.ArMapInterface_unlock, args)

    def mapChanged(*args):
        """mapChanged(self)"""
        return apply(_AriaPy.ArMapInterface_mapChanged, args)

    def addMapChangedCB(*args):
        """
        addMapChangedCB(self, ArFunctor functor, Pos position=LAST)
        addMapChangedCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArMapInterface_addMapChangedCB, args)

    def remMapChangedCB(*args):
        """remMapChangedCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArMapInterface_remMapChangedCB, args)

    def addPreMapChangedCB(*args):
        """
        addPreMapChangedCB(self, ArFunctor functor, Pos position=LAST)
        addPreMapChangedCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArMapInterface_addPreMapChangedCB, args)

    def remPreMapChangedCB(*args):
        """remPreMapChangedCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArMapInterface_remPreMapChangedCB, args)

    def setMapChangedLogLevel(*args):
        """setMapChangedLogLevel(self, LogLevel level)"""
        return apply(_AriaPy.ArMapInterface_setMapChangedLogLevel, args)

    def getMapChangedLogLevel(*args):
        """getMapChangedLogLevel(self) -> int"""
        return apply(_AriaPy.ArMapInterface_getMapChangedLogLevel, args)

    def writeToFunctor(*args):
        """writeToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMapInterface_writeToFunctor, args)

    def writeObjectsToFunctor(*args):
        """
        writeObjectsToFunctor(self, ArFunctor1_CString functor, char endOfLineChars, bool isOverrideAsSingleScan=False, 
            char maxCategory=None)
        writeObjectsToFunctor(self, ArFunctor1_CString functor, char endOfLineChars, bool isOverrideAsSingleScan=False)
        writeObjectsToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)
        """
        return apply(_AriaPy.ArMapInterface_writeObjectsToFunctor, args)

    def addPreWriteFileCB(*args):
        """
        addPreWriteFileCB(self, ArFunctor functor, Pos position=LAST)
        addPreWriteFileCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArMapInterface_addPreWriteFileCB, args)

    def remPreWriteFileCB(*args):
        """remPreWriteFileCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArMapInterface_remPreWriteFileCB, args)

    def addPostWriteFileCB(*args):
        """
        addPostWriteFileCB(self, ArFunctor functor, Pos position=LAST)
        addPostWriteFileCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArMapInterface_addPostWriteFileCB, args)

    def remPostWriteFileCB(*args):
        """remPostWriteFileCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArMapInterface_remPostWriteFileCB, args)

    def getMapId(*args):
        """
        getMapId(self, ArMapId mapIdOut, bool isInternalCall=False) -> bool
        getMapId(self, ArMapId mapIdOut) -> bool
        """
        return apply(_AriaPy.ArMapInterface_getMapId, args)

    def calculateChecksum(*args):
        """calculateChecksum(self, unsigned char md5DigestBuffer, size_t md5DigestBufferLen) -> bool"""
        return apply(_AriaPy.ArMapInterface_calculateChecksum, args)

    def getBaseDirectory(*args):
        """getBaseDirectory(self) -> char"""
        return apply(_AriaPy.ArMapInterface_getBaseDirectory, args)

    def setBaseDirectory(*args):
        """setBaseDirectory(self, char baseDirectory)"""
        return apply(_AriaPy.ArMapInterface_setBaseDirectory, args)

    def getTempDirectory(*args):
        """getTempDirectory(self) -> char"""
        return apply(_AriaPy.ArMapInterface_getTempDirectory, args)

    def setTempDirectory(*args):
        """setTempDirectory(self, char tempDirectory)"""
        return apply(_AriaPy.ArMapInterface_setTempDirectory, args)

    def createRealFileName(*args):
        """
        createRealFileName(self, char baseDirectory, char fileName, bool isIgnoreCase) -> std::string
        createRealFileName(self, char fileName) -> std::string
        """
        return apply(_AriaPy.ArMapInterface_createRealFileName, args)

    def getFileName(*args):
        """getFileName(self) -> char"""
        return apply(_AriaPy.ArMapInterface_getFileName, args)

    def setSourceFileName(*args):
        """
        setSourceFileName(self, char sourceName, char fileName, bool isInternalCall=False)
        setSourceFileName(self, char sourceName, char fileName)
        """
        return apply(_AriaPy.ArMapInterface_setSourceFileName, args)

    def refresh(*args):
        """refresh(self) -> bool"""
        return apply(_AriaPy.ArMapInterface_refresh, args)

    def setIgnoreEmptyFileName(*args):
        """setIgnoreEmptyFileName(self, bool ignore)"""
        return apply(_AriaPy.ArMapInterface_setIgnoreEmptyFileName, args)

    def getIgnoreEmptyFileName(*args):
        """getIgnoreEmptyFileName(self) -> bool"""
        return apply(_AriaPy.ArMapInterface_getIgnoreEmptyFileName, args)

    def setIgnoreCase(*args):
        """
        setIgnoreCase(self, bool ignoreCase=False)
        setIgnoreCase(self)
        """
        return apply(_AriaPy.ArMapInterface_setIgnoreCase, args)

    def getIgnoreCase(*args):
        """getIgnoreCase(self) -> bool"""
        return apply(_AriaPy.ArMapInterface_getIgnoreCase, args)

    def getInactiveInfo(*args):
        """getInactiveInfo(self) -> ArMapInfoInterface"""
        return apply(_AriaPy.ArMapInterface_getInactiveInfo, args)

    def getInactiveObjects(*args):
        """getInactiveObjects(self) -> ArMapObjectsInterface"""
        return apply(_AriaPy.ArMapInterface_getInactiveObjects, args)

    def findMapObjectParams(*args):
        """findMapObjectParams(self, char mapObjectName) -> ArArgumentBuilder"""
        return apply(_AriaPy.ArMapInterface_findMapObjectParams, args)

    def setMapObjectParams(*args):
        """
        setMapObjectParams(self, char mapObjectName, ArArgumentBuilder params, ArMapChangeDetails changeDetails=None) -> bool
        setMapObjectParams(self, char mapObjectName, ArArgumentBuilder params) -> bool
        """
        return apply(_AriaPy.ArMapInterface_setMapObjectParams, args)

    def getRemainder(*args):
        """getRemainder(self) -> ArArgumentBuilderPtrList"""
        return apply(_AriaPy.ArMapInterface_getRemainder, args)

    def setQuiet(*args):
        """setQuiet(self, bool isQuiet)"""
        return apply(_AriaPy.ArMapInterface_setQuiet, args)

    def parseLine(*args):
        """parseLine(self, char line) -> bool"""
        return apply(_AriaPy.ArMapInterface_parseLine, args)

    def parsingComplete(*args):
        """parsingComplete(self)"""
        return apply(_AriaPy.ArMapInterface_parsingComplete, args)

    def isLoadingDataStarted(*args):
        """isLoadingDataStarted(self) -> bool"""
        return apply(_AriaPy.ArMapInterface_isLoadingDataStarted, args)

    def isLoadingLinesAndDataStarted(*args):
        """isLoadingLinesAndDataStarted(self) -> bool"""
        return apply(_AriaPy.ArMapInterface_isLoadingLinesAndDataStarted, args)

ArMapInterface_swigregister = _AriaPy.ArMapInterface_swigregister
ArMapInterface_swigregister(ArMapInterface)

class ArMap(ArMapInterface):
    """Proxy of C++ ArMap class"""
    __swig_setmethods__ = {}
    for _s in [ArMapInterface]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMap, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMapInterface]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArMap, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char baseDirectory="./", bool addToGlobalConfig=True, 
            char configSection="Files", char configParam="Map", 
            char configDesc="Map of the environment that the robot uses for navigation", 
            bool ignoreEmptyFileName=True, 
            Priority priority=IMPORTANT, 
            char tempDirectory=None) -> ArMap
        __init__(self, char baseDirectory="./", bool addToGlobalConfig=True, 
            char configSection="Files", char configParam="Map", 
            char configDesc="Map of the environment that the robot uses for navigation", 
            bool ignoreEmptyFileName=True, 
            Priority priority=IMPORTANT) -> ArMap
        __init__(self, char baseDirectory="./", bool addToGlobalConfig=True, 
            char configSection="Files", char configParam="Map", 
            char configDesc="Map of the environment that the robot uses for navigation", 
            bool ignoreEmptyFileName=True) -> ArMap
        __init__(self, char baseDirectory="./", bool addToGlobalConfig=True, 
            char configSection="Files", char configParam="Map", 
            char configDesc="Map of the environment that the robot uses for navigation") -> ArMap
        __init__(self, char baseDirectory="./", bool addToGlobalConfig=True, 
            char configSection="Files", char configParam="Map") -> ArMap
        __init__(self, char baseDirectory="./", bool addToGlobalConfig=True, 
            char configSection="Files") -> ArMap
        __init__(self, char baseDirectory="./", bool addToGlobalConfig=True) -> ArMap
        __init__(self, char baseDirectory="./") -> ArMap
        __init__(self) -> ArMap
        __init__(self, ArMap other) -> ArMap
        """
        this = apply(_AriaPy.new_ArMap, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMap
    __del__ = lambda self : None;
    def getScanTypes(*args):
        """getScanTypes(self) -> std::list<(std::string,std::allocator<(std::string)>)>"""
        return apply(_AriaPy.ArMap_getScanTypes, args)

    def setScanTypes(*args):
        """setScanTypes(self, std::list<(std::string,std::allocator<(std::string)>)> scanTypeList) -> bool"""
        return apply(_AriaPy.ArMap_setScanTypes, args)

    def lock(*args):
        """lock(self) -> int"""
        return apply(_AriaPy.ArMap_lock, args)

    def tryLock(*args):
        """tryLock(self) -> int"""
        return apply(_AriaPy.ArMap_tryLock, args)

    def unlock(*args):
        """unlock(self) -> int"""
        return apply(_AriaPy.ArMap_unlock, args)

    def getDisplayString(*args):
        """
        getDisplayString(self, char scanType="") -> char
        getDisplayString(self) -> char
        """
        return apply(_AriaPy.ArMap_getDisplayString, args)

    def getPoints(*args):
        """
        getPoints(self, char scanType="") -> std::vector<(ArPose,std::allocator<(ArPose)>)>
        getPoints(self) -> std::vector<(ArPose,std::allocator<(ArPose)>)>
        """
        return apply(_AriaPy.ArMap_getPoints, args)

    def getMinPose(*args):
        """
        getMinPose(self, char scanType="") -> ArPose
        getMinPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMap_getMinPose, args)

    def getMaxPose(*args):
        """
        getMaxPose(self, char scanType="") -> ArPose
        getMaxPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMap_getMaxPose, args)

    def getNumPoints(*args):
        """
        getNumPoints(self, char scanType="") -> int
        getNumPoints(self) -> int
        """
        return apply(_AriaPy.ArMap_getNumPoints, args)

    def isSortedPoints(*args):
        """
        isSortedPoints(self, char scanType="") -> bool
        isSortedPoints(self) -> bool
        """
        return apply(_AriaPy.ArMap_isSortedPoints, args)

    def setPoints(*args):
        """
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points, 
            char scanType="", bool isSortedPoints=False, 
            ArMapChangeDetails changeDetails=None)
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points, 
            char scanType="", bool isSortedPoints=False)
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points, 
            char scanType="")
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points)
        """
        return apply(_AriaPy.ArMap_setPoints, args)

    def getLines(*args):
        """
        getLines(self, char scanType="") -> std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>
        getLines(self) -> std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>
        """
        return apply(_AriaPy.ArMap_getLines, args)

    def getLineMinPose(*args):
        """
        getLineMinPose(self, char scanType="") -> ArPose
        getLineMinPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMap_getLineMinPose, args)

    def getLineMaxPose(*args):
        """
        getLineMaxPose(self, char scanType="") -> ArPose
        getLineMaxPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMap_getLineMaxPose, args)

    def getNumLines(*args):
        """
        getNumLines(self, char scanType="") -> int
        getNumLines(self) -> int
        """
        return apply(_AriaPy.ArMap_getNumLines, args)

    def isSortedLines(*args):
        """
        isSortedLines(self, char scanType="") -> bool
        isSortedLines(self) -> bool
        """
        return apply(_AriaPy.ArMap_isSortedLines, args)

    def setLines(*args):
        """
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines, 
            char scanType="", bool isSortedLines=False, 
            ArMapChangeDetails changeDetails=None)
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines, 
            char scanType="", bool isSortedLines=False)
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines, 
            char scanType="")
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines)
        """
        return apply(_AriaPy.ArMap_setLines, args)

    def getResolution(*args):
        """
        getResolution(self, char scanType="") -> int
        getResolution(self) -> int
        """
        return apply(_AriaPy.ArMap_getResolution, args)

    def setResolution(*args):
        """
        setResolution(self, int resolution, char scanType="", ArMapChangeDetails changeDetails=None)
        setResolution(self, int resolution, char scanType="")
        setResolution(self, int resolution)
        """
        return apply(_AriaPy.ArMap_setResolution, args)

    def writeScanToFunctor(*args):
        """
        writeScanToFunctor(self, ArFunctor1_CString functor, char endOfLineChars, char scanType="")
        writeScanToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)
        """
        return apply(_AriaPy.ArMap_writeScanToFunctor, args)

    def writePointsToFunctor(*args):
        """
        writePointsToFunctor(self, ArFunctor2<(int,p.std::vector<(ArPose,std::allocator<(ArPose)>)>)> functor, 
            char scanType="", ArFunctor1_CString keywordFunctor=None)
        writePointsToFunctor(self, ArFunctor2<(int,p.std::vector<(ArPose,std::allocator<(ArPose)>)>)> functor, 
            char scanType="")
        writePointsToFunctor(self, ArFunctor2<(int,p.std::vector<(ArPose,std::allocator<(ArPose)>)>)> functor)
        """
        return apply(_AriaPy.ArMap_writePointsToFunctor, args)

    def writeLinesToFunctor(*args):
        """
        writeLinesToFunctor(self, ArFunctor2<(int,p.std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>)> functor, 
            char scanType="", 
            ArFunctor1_CString keywordFunctor=None)
        writeLinesToFunctor(self, ArFunctor2<(int,p.std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>)> functor, 
            char scanType="")
        writeLinesToFunctor(self, ArFunctor2<(int,p.std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>)> functor)
        """
        return apply(_AriaPy.ArMap_writeLinesToFunctor, args)

    def addToFileParser(*args):
        """addToFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMap_addToFileParser, args)

    def remFromFileParser(*args):
        """remFromFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMap_remFromFileParser, args)

    def readDataPoint(*args):
        """readDataPoint(self, char line) -> bool"""
        return apply(_AriaPy.ArMap_readDataPoint, args)

    def readLineSegment(*args):
        """readLineSegment(self, char line) -> bool"""
        return apply(_AriaPy.ArMap_readLineSegment, args)

    def loadDataPoint(*args):
        """loadDataPoint(self, double x, double y)"""
        return apply(_AriaPy.ArMap_loadDataPoint, args)

    def loadLineSegment(*args):
        """loadLineSegment(self, double x1, double y1, double x2, double y2)"""
        return apply(_AriaPy.ArMap_loadLineSegment, args)

    def findFirstMapObject(*args):
        """
        findFirstMapObject(self, char name, char type, bool isIncludeWithHeading=False) -> ArMapObject
        findFirstMapObject(self, char name, char type) -> ArMapObject
        """
        return apply(_AriaPy.ArMap_findFirstMapObject, args)

    def findMapObject(*args):
        """
        findMapObject(self, char name, char type=None, bool isIncludeWithHeading=False) -> ArMapObject
        findMapObject(self, char name, char type=None) -> ArMapObject
        findMapObject(self, char name) -> ArMapObject
        """
        return apply(_AriaPy.ArMap_findMapObject, args)

    def findMapObjectsOfType(*args):
        """
        findMapObjectsOfType(self, char type, bool isIncludeWithHeading=False) -> ArMapObjectPtrList
        findMapObjectsOfType(self, char type) -> ArMapObjectPtrList
        """
        return apply(_AriaPy.ArMap_findMapObjectsOfType, args)

    def getMapObjects(*args):
        """getMapObjects(self) -> ArMapObjectPtrList"""
        return apply(_AriaPy.ArMap_getMapObjects, args)

    def setMapObjects(*args):
        """
        setMapObjects(self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False, 
            ArMapChangeDetails changeDetails=None)
        setMapObjects(self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False)
        setMapObjects(self, ArMapObjectPtrList mapObjects)
        """
        return apply(_AriaPy.ArMap_setMapObjects, args)

    def writeObjectListToFunctor(*args):
        """writeObjectListToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMap_writeObjectListToFunctor, args)

    def getInfo(*args):
        """
        getInfo(self, char infoName) -> ArArgumentBuilderPtrList
        getInfo(self, int infoType) -> ArArgumentBuilderPtrList
        """
        return apply(_AriaPy.ArMap_getInfo, args)

    def getMapInfo(*args):
        """getMapInfo(self) -> ArArgumentBuilderPtrList"""
        return apply(_AriaPy.ArMap_getMapInfo, args)

    def getInfoCount(*args):
        """getInfoCount(self) -> int"""
        return apply(_AriaPy.ArMap_getInfoCount, args)

    def getInfoNames(*args):
        """getInfoNames(self) -> std::list<(std::string,std::allocator<(std::string)>)>"""
        return apply(_AriaPy.ArMap_getInfoNames, args)

    def setInfo(*args):
        """
        setInfo(self, char infoName, ArArgumentBuilderPtrList infoList, ArMapChangeDetails changeDetails=None) -> bool
        setInfo(self, char infoName, ArArgumentBuilderPtrList infoList) -> bool
        setInfo(self, int infoType, ArArgumentBuilderPtrList infoList, ArMapChangeDetails changeDetails=None) -> bool
        setInfo(self, int infoType, ArArgumentBuilderPtrList infoList) -> bool
        """
        return apply(_AriaPy.ArMap_setInfo, args)

    def setMapInfo(*args):
        """
        setMapInfo(self, ArArgumentBuilderPtrList mapInfo, ArMapChangeDetails changeDetails=None) -> bool
        setMapInfo(self, ArArgumentBuilderPtrList mapInfo) -> bool
        """
        return apply(_AriaPy.ArMap_setMapInfo, args)

    def getInfoName(*args):
        """getInfoName(self, int infoType) -> char"""
        return apply(_AriaPy.ArMap_getInfoName, args)

    def writeInfoToFunctor(*args):
        """writeInfoToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMap_writeInfoToFunctor, args)

    def hasOriginLatLongAlt(*args):
        """hasOriginLatLongAlt(self) -> bool"""
        return apply(_AriaPy.ArMap_hasOriginLatLongAlt, args)

    def getOriginLatLong(*args):
        """getOriginLatLong(self) -> ArPose"""
        return apply(_AriaPy.ArMap_getOriginLatLong, args)

    def getOriginAltitude(*args):
        """getOriginAltitude(self) -> double"""
        return apply(_AriaPy.ArMap_getOriginAltitude, args)

    def setOriginLatLongAlt(*args):
        """
        setOriginLatLongAlt(self, bool hasOriginLatLong, ArPose originLatLong, double altitude, 
            ArMapChangeDetails changeDetails=None)
        setOriginLatLongAlt(self, bool hasOriginLatLong, ArPose originLatLong, double altitude)
        """
        return apply(_AriaPy.ArMap_setOriginLatLongAlt, args)

    def writeSupplementToFunctor(*args):
        """writeSupplementToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMap_writeSupplementToFunctor, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArMap_clear, args)

    def set(*args):
        """set(self, ArMapInterface other) -> bool"""
        return apply(_AriaPy.ArMap_set, args)

    def clone(*args):
        """clone(self) -> ArMapInterface"""
        return apply(_AriaPy.ArMap_clone, args)

    def mapChanged(*args):
        """mapChanged(self)"""
        return apply(_AriaPy.ArMap_mapChanged, args)

    def addMapChangedCB(*args):
        """
        addMapChangedCB(self, ArFunctor functor, Pos position=LAST)
        addMapChangedCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArMap_addMapChangedCB, args)

    def remMapChangedCB(*args):
        """remMapChangedCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArMap_remMapChangedCB, args)

    def addPreMapChangedCB(*args):
        """
        addPreMapChangedCB(self, ArFunctor functor, Pos position=LAST)
        addPreMapChangedCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArMap_addPreMapChangedCB, args)

    def remPreMapChangedCB(*args):
        """remPreMapChangedCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArMap_remPreMapChangedCB, args)

    def setMapChangedLogLevel(*args):
        """setMapChangedLogLevel(self, LogLevel level)"""
        return apply(_AriaPy.ArMap_setMapChangedLogLevel, args)

    def getMapChangedLogLevel(*args):
        """getMapChangedLogLevel(self) -> int"""
        return apply(_AriaPy.ArMap_getMapChangedLogLevel, args)

    def writeToFunctor(*args):
        """writeToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMap_writeToFunctor, args)

    def writeObjectsToFunctor(*args):
        """
        writeObjectsToFunctor(self, ArFunctor1_CString functor, char endOfLineChars, bool isOverrideAsSingleScan=False, 
            char maxCategory=None)
        writeObjectsToFunctor(self, ArFunctor1_CString functor, char endOfLineChars, bool isOverrideAsSingleScan=False)
        writeObjectsToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)
        """
        return apply(_AriaPy.ArMap_writeObjectsToFunctor, args)

    def addPreWriteFileCB(*args):
        """
        addPreWriteFileCB(self, ArFunctor functor, Pos position=LAST)
        addPreWriteFileCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArMap_addPreWriteFileCB, args)

    def remPreWriteFileCB(*args):
        """remPreWriteFileCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArMap_remPreWriteFileCB, args)

    def addPostWriteFileCB(*args):
        """
        addPostWriteFileCB(self, ArFunctor functor, Pos position=LAST)
        addPostWriteFileCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArMap_addPostWriteFileCB, args)

    def remPostWriteFileCB(*args):
        """remPostWriteFileCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArMap_remPostWriteFileCB, args)

    def readFile(*args):
        """readFile(self, char fileName) -> bool"""
        return apply(_AriaPy.ArMap_readFile, args)

    def writeFile(*args):
        """writeFile(self, char fileName) -> bool"""
        return apply(_AriaPy.ArMap_writeFile, args)

    def getMapId(*args):
        """
        getMapId(self, ArMapId mapIdOut, bool isInternalCall=False) -> bool
        getMapId(self, ArMapId mapIdOut) -> bool
        """
        return apply(_AriaPy.ArMap_getMapId, args)

    def calculateChecksum(*args):
        """calculateChecksum(self, unsigned char md5DigestBuffer, size_t md5DigestBufferLen) -> bool"""
        return apply(_AriaPy.ArMap_calculateChecksum, args)

    def getBaseDirectory(*args):
        """getBaseDirectory(self) -> char"""
        return apply(_AriaPy.ArMap_getBaseDirectory, args)

    def setBaseDirectory(*args):
        """setBaseDirectory(self, char baseDirectory)"""
        return apply(_AriaPy.ArMap_setBaseDirectory, args)

    def getTempDirectory(*args):
        """getTempDirectory(self) -> char"""
        return apply(_AriaPy.ArMap_getTempDirectory, args)

    def setTempDirectory(*args):
        """setTempDirectory(self, char tempDirectory)"""
        return apply(_AriaPy.ArMap_setTempDirectory, args)

    def createRealFileName(*args):
        """createRealFileName(self, char fileName) -> std::string"""
        return apply(_AriaPy.ArMap_createRealFileName, args)

    def getFileName(*args):
        """getFileName(self) -> char"""
        return apply(_AriaPy.ArMap_getFileName, args)

    def setSourceFileName(*args):
        """
        setSourceFileName(self, char sourceName, char fileName, bool isInternalCall=False)
        setSourceFileName(self, char sourceName, char fileName)
        """
        return apply(_AriaPy.ArMap_setSourceFileName, args)

    def refresh(*args):
        """refresh(self) -> bool"""
        return apply(_AriaPy.ArMap_refresh, args)

    def setIgnoreEmptyFileName(*args):
        """setIgnoreEmptyFileName(self, bool ignore)"""
        return apply(_AriaPy.ArMap_setIgnoreEmptyFileName, args)

    def getIgnoreEmptyFileName(*args):
        """getIgnoreEmptyFileName(self) -> bool"""
        return apply(_AriaPy.ArMap_getIgnoreEmptyFileName, args)

    def setIgnoreCase(*args):
        """
        setIgnoreCase(self, bool ignoreCase=False)
        setIgnoreCase(self)
        """
        return apply(_AriaPy.ArMap_setIgnoreCase, args)

    def getIgnoreCase(*args):
        """getIgnoreCase(self) -> bool"""
        return apply(_AriaPy.ArMap_getIgnoreCase, args)

    def getInactiveInfo(*args):
        """getInactiveInfo(self) -> ArMapInfoInterface"""
        return apply(_AriaPy.ArMap_getInactiveInfo, args)

    def getInactiveObjects(*args):
        """getInactiveObjects(self) -> ArMapObjectsInterface"""
        return apply(_AriaPy.ArMap_getInactiveObjects, args)

    def findMapObjectParams(*args):
        """findMapObjectParams(self, char mapObjectName) -> ArArgumentBuilder"""
        return apply(_AriaPy.ArMap_findMapObjectParams, args)

    def setMapObjectParams(*args):
        """
        setMapObjectParams(self, char mapObjectName, ArArgumentBuilder params, ArMapChangeDetails changeDetails=None) -> bool
        setMapObjectParams(self, char mapObjectName, ArArgumentBuilder params) -> bool
        """
        return apply(_AriaPy.ArMap_setMapObjectParams, args)

    def getRemainder(*args):
        """getRemainder(self) -> ArArgumentBuilderPtrList"""
        return apply(_AriaPy.ArMap_getRemainder, args)

    def setQuiet(*args):
        """setQuiet(self, bool isQuiet)"""
        return apply(_AriaPy.ArMap_setQuiet, args)

    def parseLine(*args):
        """parseLine(self, char line) -> bool"""
        return apply(_AriaPy.ArMap_parseLine, args)

    def parsingComplete(*args):
        """parsingComplete(self)"""
        return apply(_AriaPy.ArMap_parsingComplete, args)

    def isLoadingDataStarted(*args):
        """isLoadingDataStarted(self) -> bool"""
        return apply(_AriaPy.ArMap_isLoadingDataStarted, args)

    def isLoadingLinesAndDataStarted(*args):
        """isLoadingLinesAndDataStarted(self) -> bool"""
        return apply(_AriaPy.ArMap_isLoadingLinesAndDataStarted, args)

    def readFileAndChangeConfig(*args):
        """readFileAndChangeConfig(self, char fileName) -> bool"""
        return apply(_AriaPy.ArMap_readFileAndChangeConfig, args)

    def changeConfigMapName(*args):
        """changeConfigMapName(self, char fileName)"""
        return apply(_AriaPy.ArMap_changeConfigMapName, args)

ArMap_swigregister = _AriaPy.ArMap_swigregister
ArMap_swigregister(ArMap)

class ArMapScan(ArMapScanInterface):
    """Proxy of C++ ArMapScan class"""
    __swig_setmethods__ = {}
    for _s in [ArMapScanInterface]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMapScan, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMapScanInterface]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArMapScan, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char scanType="") -> ArMapScan
        __init__(self) -> ArMapScan
        __init__(self, ArMapScan other) -> ArMapScan
        """
        this = apply(_AriaPy.new_ArMapScan, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMapScan
    __del__ = lambda self : None;
    def getDisplayString(*args):
        """
        getDisplayString(self, char scanType="") -> char
        getDisplayString(self) -> char
        """
        return apply(_AriaPy.ArMapScan_getDisplayString, args)

    def getPoints(*args):
        """
        getPoints(self, char scanType="") -> std::vector<(ArPose,std::allocator<(ArPose)>)>
        getPoints(self) -> std::vector<(ArPose,std::allocator<(ArPose)>)>
        """
        return apply(_AriaPy.ArMapScan_getPoints, args)

    def getLines(*args):
        """
        getLines(self, char scanType="") -> std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>
        getLines(self) -> std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>
        """
        return apply(_AriaPy.ArMapScan_getLines, args)

    def getMinPose(*args):
        """
        getMinPose(self, char scanType="") -> ArPose
        getMinPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMapScan_getMinPose, args)

    def getMaxPose(*args):
        """
        getMaxPose(self, char scanType="") -> ArPose
        getMaxPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMapScan_getMaxPose, args)

    def getNumPoints(*args):
        """
        getNumPoints(self, char scanType="") -> int
        getNumPoints(self) -> int
        """
        return apply(_AriaPy.ArMapScan_getNumPoints, args)

    def isSortedPoints(*args):
        """
        isSortedPoints(self, char scanType="") -> bool
        isSortedPoints(self) -> bool
        """
        return apply(_AriaPy.ArMapScan_isSortedPoints, args)

    def setPoints(*args):
        """
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points, 
            char scanType="", bool isSortedPoints=False, 
            ArMapChangeDetails changeDetails=None)
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points, 
            char scanType="", bool isSortedPoints=False)
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points, 
            char scanType="")
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points)
        """
        return apply(_AriaPy.ArMapScan_setPoints, args)

    def getLineMinPose(*args):
        """
        getLineMinPose(self, char scanType="") -> ArPose
        getLineMinPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMapScan_getLineMinPose, args)

    def getLineMaxPose(*args):
        """
        getLineMaxPose(self, char scanType="") -> ArPose
        getLineMaxPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMapScan_getLineMaxPose, args)

    def getNumLines(*args):
        """
        getNumLines(self, char scanType="") -> int
        getNumLines(self) -> int
        """
        return apply(_AriaPy.ArMapScan_getNumLines, args)

    def isSortedLines(*args):
        """
        isSortedLines(self, char scanType="") -> bool
        isSortedLines(self) -> bool
        """
        return apply(_AriaPy.ArMapScan_isSortedLines, args)

    def setLines(*args):
        """
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines, 
            char scanType="", bool isSortedLines=False, 
            ArMapChangeDetails changeDetails=None)
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines, 
            char scanType="", bool isSortedLines=False)
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines, 
            char scanType="")
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines)
        """
        return apply(_AriaPy.ArMapScan_setLines, args)

    def getResolution(*args):
        """
        getResolution(self, char scanType="") -> int
        getResolution(self) -> int
        """
        return apply(_AriaPy.ArMapScan_getResolution, args)

    def setResolution(*args):
        """
        setResolution(self, int resolution, char scanType="", ArMapChangeDetails changeDetails=None)
        setResolution(self, int resolution, char scanType="")
        setResolution(self, int resolution)
        """
        return apply(_AriaPy.ArMapScan_setResolution, args)

    def writeScanToFunctor(*args):
        """
        writeScanToFunctor(self, ArFunctor1_CString functor, char endOfLineChars, char scanType="")
        writeScanToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)
        """
        return apply(_AriaPy.ArMapScan_writeScanToFunctor, args)

    def addToFileParser(*args):
        """addToFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMapScan_addToFileParser, args)

    def remFromFileParser(*args):
        """remFromFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMapScan_remFromFileParser, args)

    def readDataPoint(*args):
        """readDataPoint(self, char line) -> bool"""
        return apply(_AriaPy.ArMapScan_readDataPoint, args)

    def readLineSegment(*args):
        """readLineSegment(self, char line) -> bool"""
        return apply(_AriaPy.ArMapScan_readLineSegment, args)

    def loadDataPoint(*args):
        """loadDataPoint(self, double x, double y)"""
        return apply(_AriaPy.ArMapScan_loadDataPoint, args)

    def loadLineSegment(*args):
        """loadLineSegment(self, double x1, double y1, double x2, double y2)"""
        return apply(_AriaPy.ArMapScan_loadLineSegment, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArMapScan_clear, args)

    def unite(*args):
        """
        unite(self, ArMapScan other, bool isIncludeDataPointsAndLines=False) -> bool
        unite(self, ArMapScan other) -> bool
        """
        return apply(_AriaPy.ArMapScan_unite, args)

    def getTimeChanged(*args):
        """getTimeChanged(self) -> ArTime"""
        return apply(_AriaPy.ArMapScan_getTimeChanged, args)

    def getScanType(*args):
        """getScanType(self) -> char"""
        return apply(_AriaPy.ArMapScan_getScanType, args)

    def getPointsKeyword(*args):
        """getPointsKeyword(self) -> char"""
        return apply(_AriaPy.ArMapScan_getPointsKeyword, args)

    def getLinesKeyword(*args):
        """getLinesKeyword(self) -> char"""
        return apply(_AriaPy.ArMapScan_getLinesKeyword, args)

    def writePointsToFunctor(*args):
        """
        writePointsToFunctor(self, ArFunctor2<(int,p.std::vector<(ArPose,std::allocator<(ArPose)>)>)> functor, 
            char scanType="", ArFunctor1_CString keywordFunctor=None)
        writePointsToFunctor(self, ArFunctor2<(int,p.std::vector<(ArPose,std::allocator<(ArPose)>)>)> functor, 
            char scanType="")
        writePointsToFunctor(self, ArFunctor2<(int,p.std::vector<(ArPose,std::allocator<(ArPose)>)>)> functor)
        writePointsToFunctor(self, ArFunctor1_CString functor, char endOfLineChars, char scanType="")
        writePointsToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)
        """
        return apply(_AriaPy.ArMapScan_writePointsToFunctor, args)

    def writeLinesToFunctor(*args):
        """
        writeLinesToFunctor(self, ArFunctor2<(int,p.std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>)> functor, 
            char scanType="", 
            ArFunctor1_CString keywordFunctor=None)
        writeLinesToFunctor(self, ArFunctor2<(int,p.std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>)> functor, 
            char scanType="")
        writeLinesToFunctor(self, ArFunctor2<(int,p.std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>)> functor)
        writeLinesToFunctor(self, ArFunctor1_CString functor, char endOfLineChars, char scanType="")
        writeLinesToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)
        """
        return apply(_AriaPy.ArMapScan_writeLinesToFunctor, args)

    def addExtraToFileParser(*args):
        """addExtraToFileParser(self, ArFileParser fileParser, bool isAddLineHandler) -> bool"""
        return apply(_AriaPy.ArMapScan_addExtraToFileParser, args)

    def remExtraFromFileParser(*args):
        """remExtraFromFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMapScan_remExtraFromFileParser, args)

ArMapScan_swigregister = _AriaPy.ArMapScan_swigregister
ArMapScan_swigregister(ArMapScan)

class ArMapObjects(ArMapObjectsInterface):
    """Proxy of C++ ArMapObjects class"""
    __swig_setmethods__ = {}
    for _s in [ArMapObjectsInterface]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMapObjects, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMapObjectsInterface]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArMapObjects, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char keyword="Cairn:") -> ArMapObjects
        __init__(self) -> ArMapObjects
        __init__(self, ArMapObjects other) -> ArMapObjects
        """
        this = apply(_AriaPy.new_ArMapObjects, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMapObjects
    __del__ = lambda self : None;
    def findFirstMapObject(*args):
        """
        findFirstMapObject(self, char name, char type, bool isIncludeWithHeading=False) -> ArMapObject
        findFirstMapObject(self, char name, char type) -> ArMapObject
        """
        return apply(_AriaPy.ArMapObjects_findFirstMapObject, args)

    def findMapObject(*args):
        """
        findMapObject(self, char name, char type=None, bool isIncludeWithHeading=False) -> ArMapObject
        findMapObject(self, char name, char type=None) -> ArMapObject
        findMapObject(self, char name) -> ArMapObject
        """
        return apply(_AriaPy.ArMapObjects_findMapObject, args)

    def findMapObjectsOfType(*args):
        """
        findMapObjectsOfType(self, char type, bool isIncludeWithHeading=False) -> ArMapObjectPtrList
        findMapObjectsOfType(self, char type) -> ArMapObjectPtrList
        """
        return apply(_AriaPy.ArMapObjects_findMapObjectsOfType, args)

    def getMapObjects(*args):
        """getMapObjects(self) -> ArMapObjectPtrList"""
        return apply(_AriaPy.ArMapObjects_getMapObjects, args)

    def setMapObjects(*args):
        """
        setMapObjects(self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False, 
            ArMapChangeDetails changeDetails=None)
        setMapObjects(self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False)
        setMapObjects(self, ArMapObjectPtrList mapObjects)
        """
        return apply(_AriaPy.ArMapObjects_setMapObjects, args)

    def writeObjectListToFunctor(*args):
        """writeObjectListToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMapObjects_writeObjectListToFunctor, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArMapObjects_clear, args)

    def addToFileParser(*args):
        """addToFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMapObjects_addToFileParser, args)

    def remFromFileParser(*args):
        """remFromFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMapObjects_remFromFileParser, args)

    def getTimeChanged(*args):
        """getTimeChanged(self) -> ArTime"""
        return apply(_AriaPy.ArMapObjects_getTimeChanged, args)

ArMapObjects_swigregister = _AriaPy.ArMapObjects_swigregister
ArMapObjects_swigregister(ArMapObjects)

class ArMapInfo(ArMapInfoInterface):
    """Proxy of C++ ArMapInfo class"""
    __swig_setmethods__ = {}
    for _s in [ArMapInfoInterface]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMapInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMapInfoInterface]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArMapInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char infoNameList=None, size_t infoNameCount=0, char keywordPrefix=None) -> ArMapInfo
        __init__(self, char infoNameList=None, size_t infoNameCount=0) -> ArMapInfo
        __init__(self, char infoNameList=None) -> ArMapInfo
        __init__(self) -> ArMapInfo
        __init__(self, ArMapInfo other) -> ArMapInfo
        """
        this = apply(_AriaPy.new_ArMapInfo, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMapInfo
    __del__ = lambda self : None;
    def getInfo(*args):
        """
        getInfo(self, char infoName) -> ArArgumentBuilderPtrList
        getInfo(self, int infoType) -> ArArgumentBuilderPtrList
        """
        return apply(_AriaPy.ArMapInfo_getInfo, args)

    def getMapInfo(*args):
        """getMapInfo(self) -> ArArgumentBuilderPtrList"""
        return apply(_AriaPy.ArMapInfo_getMapInfo, args)

    def getInfoCount(*args):
        """getInfoCount(self) -> int"""
        return apply(_AriaPy.ArMapInfo_getInfoCount, args)

    def getInfoNames(*args):
        """getInfoNames(self) -> std::list<(std::string,std::allocator<(std::string)>)>"""
        return apply(_AriaPy.ArMapInfo_getInfoNames, args)

    def setInfo(*args):
        """
        setInfo(self, char infoName, ArArgumentBuilderPtrList infoList, ArMapChangeDetails changeDetails) -> bool
        setInfo(self, int infoType, ArArgumentBuilderPtrList infoList, ArMapChangeDetails changeDetails=None) -> bool
        setInfo(self, int infoType, ArArgumentBuilderPtrList infoList) -> bool
        """
        return apply(_AriaPy.ArMapInfo_setInfo, args)

    def setMapInfo(*args):
        """
        setMapInfo(self, ArArgumentBuilderPtrList mapInfo, ArMapChangeDetails changeDetails=None) -> bool
        setMapInfo(self, ArArgumentBuilderPtrList mapInfo) -> bool
        """
        return apply(_AriaPy.ArMapInfo_setMapInfo, args)

    def getInfoName(*args):
        """getInfoName(self, int infoType) -> char"""
        return apply(_AriaPy.ArMapInfo_getInfoName, args)

    def writeInfoToFunctor(*args):
        """writeInfoToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMapInfo_writeInfoToFunctor, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArMapInfo_clear, args)

    def addToFileParser(*args):
        """addToFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMapInfo_addToFileParser, args)

    def remFromFileParser(*args):
        """remFromFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMapInfo_remFromFileParser, args)

    def getTimeChanged(*args):
        """getTimeChanged(self) -> ArTime"""
        return apply(_AriaPy.ArMapInfo_getTimeChanged, args)

ArMapInfo_swigregister = _AriaPy.ArMapInfo_swigregister
ArMapInfo_swigregister(ArMapInfo)

class ArMapSupplement(ArMapSupplementInterface):
    """Proxy of C++ ArMapSupplement class"""
    __swig_setmethods__ = {}
    for _s in [ArMapSupplementInterface]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMapSupplement, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMapSupplementInterface]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArMapSupplement, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> ArMapSupplement
        __init__(self, ArMapSupplement other) -> ArMapSupplement
        """
        this = apply(_AriaPy.new_ArMapSupplement, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMapSupplement
    __del__ = lambda self : None;
    def hasOriginLatLongAlt(*args):
        """hasOriginLatLongAlt(self) -> bool"""
        return apply(_AriaPy.ArMapSupplement_hasOriginLatLongAlt, args)

    def getOriginLatLong(*args):
        """getOriginLatLong(self) -> ArPose"""
        return apply(_AriaPy.ArMapSupplement_getOriginLatLong, args)

    def getOriginAltitude(*args):
        """getOriginAltitude(self) -> double"""
        return apply(_AriaPy.ArMapSupplement_getOriginAltitude, args)

    def setOriginLatLongAlt(*args):
        """
        setOriginLatLongAlt(self, bool hasOriginLatLong, ArPose originLatLong, double altitude, 
            ArMapChangeDetails changeDetails=None)
        setOriginLatLongAlt(self, bool hasOriginLatLong, ArPose originLatLong, double altitude)
        """
        return apply(_AriaPy.ArMapSupplement_setOriginLatLongAlt, args)

    def writeSupplementToFunctor(*args):
        """writeSupplementToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMapSupplement_writeSupplementToFunctor, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArMapSupplement_clear, args)

    def addToFileParser(*args):
        """addToFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMapSupplement_addToFileParser, args)

    def remFromFileParser(*args):
        """remFromFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMapSupplement_remFromFileParser, args)

    def getTimeChanged(*args):
        """getTimeChanged(self) -> ArTime"""
        return apply(_AriaPy.ArMapSupplement_getTimeChanged, args)

ArMapSupplement_swigregister = _AriaPy.ArMapSupplement_swigregister
ArMapSupplement_swigregister(ArMapSupplement)

class ArDataTagCaseCmpOp:
    """Proxy of C++ ArDataTagCaseCmpOp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArDataTagCaseCmpOp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArDataTagCaseCmpOp, name)
    __repr__ = _swig_repr
    def __call__(*args):
        """__call__(self, std::string s1, std::string s2) -> bool"""
        return apply(_AriaPy.ArDataTagCaseCmpOp___call__, args)

    def __init__(self, *args): 
        """__init__(self) -> ArDataTagCaseCmpOp"""
        this = apply(_AriaPy.new_ArDataTagCaseCmpOp, args)
        try: self.this.append(this)
        except: 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"""
    __swig_setmethods__ = {}
    for _s in [ArMapInterface]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMapSimple, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMapInterface]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArMapSimple, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char baseDirectory="./", char tempDirectory=None, char overrideMutexName=None) -> ArMapSimple
        __init__(self, char baseDirectory="./", char tempDirectory=None) -> ArMapSimple
        __init__(self, char baseDirectory="./") -> ArMapSimple
        __init__(self) -> ArMapSimple
        __init__(self, ArMapSimple other) -> ArMapSimple
        """
        this = apply(_AriaPy.new_ArMapSimple, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMapSimple
    __del__ = lambda self : None;
    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArMapSimple_clear, args)

    def set(*args):
        """set(self, ArMapInterface other) -> bool"""
        return apply(_AriaPy.ArMapSimple_set, args)

    def clone(*args):
        """clone(self) -> ArMapInterface"""
        return apply(_AriaPy.ArMapSimple_clone, args)

    def getScanTypes(*args):
        """getScanTypes(self) -> std::list<(std::string,std::allocator<(std::string)>)>"""
        return apply(_AriaPy.ArMapSimple_getScanTypes, args)

    def setScanTypes(*args):
        """setScanTypes(self, std::list<(std::string,std::allocator<(std::string)>)> scanTypeList) -> bool"""
        return apply(_AriaPy.ArMapSimple_setScanTypes, args)

    def lock(*args):
        """lock(self) -> int"""
        return apply(_AriaPy.ArMapSimple_lock, args)

    def tryLock(*args):
        """tryLock(self) -> int"""
        return apply(_AriaPy.ArMapSimple_tryLock, args)

    def unlock(*args):
        """unlock(self) -> int"""
        return apply(_AriaPy.ArMapSimple_unlock, args)

    def getInfo(*args):
        """
        getInfo(self, char infoName) -> ArArgumentBuilderPtrList
        getInfo(self, int infoType) -> ArArgumentBuilderPtrList
        """
        return apply(_AriaPy.ArMapSimple_getInfo, args)

    def getMapInfo(*args):
        """getMapInfo(self) -> ArArgumentBuilderPtrList"""
        return apply(_AriaPy.ArMapSimple_getMapInfo, args)

    def getInfoCount(*args):
        """getInfoCount(self) -> int"""
        return apply(_AriaPy.ArMapSimple_getInfoCount, args)

    def getInfoNames(*args):
        """getInfoNames(self) -> std::list<(std::string,std::allocator<(std::string)>)>"""
        return apply(_AriaPy.ArMapSimple_getInfoNames, args)

    def setInfo(*args):
        """
        setInfo(self, char infoName, ArArgumentBuilderPtrList infoList, ArMapChangeDetails changeDetails=None) -> bool
        setInfo(self, char infoName, ArArgumentBuilderPtrList infoList) -> bool
        setInfo(self, int infoType, ArArgumentBuilderPtrList infoList, ArMapChangeDetails changeDetails=None) -> bool
        setInfo(self, int infoType, ArArgumentBuilderPtrList infoList) -> bool
        """
        return apply(_AriaPy.ArMapSimple_setInfo, args)

    def setMapInfo(*args):
        """
        setMapInfo(self, ArArgumentBuilderPtrList mapInfo, ArMapChangeDetails changeDetails=None) -> bool
        setMapInfo(self, ArArgumentBuilderPtrList mapInfo) -> bool
        """
        return apply(_AriaPy.ArMapSimple_setMapInfo, args)

    def writeInfoToFunctor(*args):
        """writeInfoToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMapSimple_writeInfoToFunctor, args)

    def getInfoName(*args):
        """getInfoName(self, int infoType) -> char"""
        return apply(_AriaPy.ArMapSimple_getInfoName, args)

    def findFirstMapObject(*args):
        """
        findFirstMapObject(self, char name, char type, bool isIncludeWithHeading=False) -> ArMapObject
        findFirstMapObject(self, char name, char type) -> ArMapObject
        """
        return apply(_AriaPy.ArMapSimple_findFirstMapObject, args)

    def findMapObject(*args):
        """
        findMapObject(self, char name, char type=None, bool isIncludeWithHeading=False) -> ArMapObject
        findMapObject(self, char name, char type=None) -> ArMapObject
        findMapObject(self, char name) -> ArMapObject
        """
        return apply(_AriaPy.ArMapSimple_findMapObject, args)

    def findMapObjectsOfType(*args):
        """
        findMapObjectsOfType(self, char type, bool isIncludeWithHeading=False) -> ArMapObjectPtrList
        findMapObjectsOfType(self, char type) -> ArMapObjectPtrList
        """
        return apply(_AriaPy.ArMapSimple_findMapObjectsOfType, args)

    def getMapObjects(*args):
        """getMapObjects(self) -> ArMapObjectPtrList"""
        return apply(_AriaPy.ArMapSimple_getMapObjects, args)

    def setMapObjects(*args):
        """
        setMapObjects(self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False, 
            ArMapChangeDetails changeDetails=None)
        setMapObjects(self, ArMapObjectPtrList mapObjects, bool isSortedObjects=False)
        setMapObjects(self, ArMapObjectPtrList mapObjects)
        """
        return apply(_AriaPy.ArMapSimple_setMapObjects, args)

    def writeObjectListToFunctor(*args):
        """writeObjectListToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMapSimple_writeObjectListToFunctor, args)

    def hasOriginLatLongAlt(*args):
        """hasOriginLatLongAlt(self) -> bool"""
        return apply(_AriaPy.ArMapSimple_hasOriginLatLongAlt, args)

    def getOriginLatLong(*args):
        """getOriginLatLong(self) -> ArPose"""
        return apply(_AriaPy.ArMapSimple_getOriginLatLong, args)

    def getOriginAltitude(*args):
        """getOriginAltitude(self) -> double"""
        return apply(_AriaPy.ArMapSimple_getOriginAltitude, args)

    def setOriginLatLongAlt(*args):
        """
        setOriginLatLongAlt(self, bool hasOriginLatLong, ArPose originLatLong, double altitude, 
            ArMapChangeDetails changeDetails=None)
        setOriginLatLongAlt(self, bool hasOriginLatLong, ArPose originLatLong, double altitude)
        """
        return apply(_AriaPy.ArMapSimple_setOriginLatLongAlt, args)

    def writeSupplementToFunctor(*args):
        """writeSupplementToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMapSimple_writeSupplementToFunctor, args)

    def getDisplayString(*args):
        """
        getDisplayString(self, char scanType="") -> char
        getDisplayString(self) -> char
        """
        return apply(_AriaPy.ArMapSimple_getDisplayString, args)

    def getPoints(*args):
        """
        getPoints(self, char scanType="") -> std::vector<(ArPose,std::allocator<(ArPose)>)>
        getPoints(self) -> std::vector<(ArPose,std::allocator<(ArPose)>)>
        """
        return apply(_AriaPy.ArMapSimple_getPoints, args)

    def getMinPose(*args):
        """
        getMinPose(self, char scanType="") -> ArPose
        getMinPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMapSimple_getMinPose, args)

    def getMaxPose(*args):
        """
        getMaxPose(self, char scanType="") -> ArPose
        getMaxPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMapSimple_getMaxPose, args)

    def getNumPoints(*args):
        """
        getNumPoints(self, char scanType="") -> int
        getNumPoints(self) -> int
        """
        return apply(_AriaPy.ArMapSimple_getNumPoints, args)

    def isSortedPoints(*args):
        """
        isSortedPoints(self, char scanType="") -> bool
        isSortedPoints(self) -> bool
        """
        return apply(_AriaPy.ArMapSimple_isSortedPoints, args)

    def setPoints(*args):
        """
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points, 
            char scanType="", bool isSortedPoints=False, 
            ArMapChangeDetails changeDetails=None)
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points, 
            char scanType="", bool isSortedPoints=False)
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points, 
            char scanType="")
        setPoints(self, std::vector<(ArPose,std::allocator<(ArPose)>)> points)
        """
        return apply(_AriaPy.ArMapSimple_setPoints, args)

    def getLines(*args):
        """
        getLines(self, char scanType="") -> std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>
        getLines(self) -> std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>
        """
        return apply(_AriaPy.ArMapSimple_getLines, args)

    def getLineMinPose(*args):
        """
        getLineMinPose(self, char scanType="") -> ArPose
        getLineMinPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMapSimple_getLineMinPose, args)

    def getLineMaxPose(*args):
        """
        getLineMaxPose(self, char scanType="") -> ArPose
        getLineMaxPose(self) -> ArPose
        """
        return apply(_AriaPy.ArMapSimple_getLineMaxPose, args)

    def getNumLines(*args):
        """
        getNumLines(self, char scanType="") -> int
        getNumLines(self) -> int
        """
        return apply(_AriaPy.ArMapSimple_getNumLines, args)

    def isSortedLines(*args):
        """
        isSortedLines(self, char scanType="") -> bool
        isSortedLines(self) -> bool
        """
        return apply(_AriaPy.ArMapSimple_isSortedLines, args)

    def setLines(*args):
        """
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines, 
            char scanType="", bool isSortedLines=False, 
            ArMapChangeDetails changeDetails=None)
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines, 
            char scanType="", bool isSortedLines=False)
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines, 
            char scanType="")
        setLines(self, std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)> lines)
        """
        return apply(_AriaPy.ArMapSimple_setLines, args)

    def getResolution(*args):
        """
        getResolution(self, char scanType="") -> int
        getResolution(self) -> int
        """
        return apply(_AriaPy.ArMapSimple_getResolution, args)

    def setResolution(*args):
        """
        setResolution(self, int resolution, char scanType="", ArMapChangeDetails changeDetails=None)
        setResolution(self, int resolution, char scanType="")
        setResolution(self, int resolution)
        """
        return apply(_AriaPy.ArMapSimple_setResolution, args)

    def writeScanToFunctor(*args):
        """
        writeScanToFunctor(self, ArFunctor1_CString functor, char endOfLineChars, char scanType="")
        writeScanToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)
        """
        return apply(_AriaPy.ArMapSimple_writeScanToFunctor, args)

    def writePointsToFunctor(*args):
        """
        writePointsToFunctor(self, ArFunctor2<(int,p.std::vector<(ArPose,std::allocator<(ArPose)>)>)> functor, 
            char scanType="", ArFunctor1_CString keywordFunctor=None)
        writePointsToFunctor(self, ArFunctor2<(int,p.std::vector<(ArPose,std::allocator<(ArPose)>)>)> functor, 
            char scanType="")
        writePointsToFunctor(self, ArFunctor2<(int,p.std::vector<(ArPose,std::allocator<(ArPose)>)>)> functor)
        """
        return apply(_AriaPy.ArMapSimple_writePointsToFunctor, args)

    def writeLinesToFunctor(*args):
        """
        writeLinesToFunctor(self, ArFunctor2<(int,p.std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>)> functor, 
            char scanType="", 
            ArFunctor1_CString keywordFunctor=None)
        writeLinesToFunctor(self, ArFunctor2<(int,p.std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>)> functor, 
            char scanType="")
        writeLinesToFunctor(self, ArFunctor2<(int,p.std::vector<(ArLineSegment,std::allocator<(ArLineSegment)>)>)> functor)
        """
        return apply(_AriaPy.ArMapSimple_writeLinesToFunctor, args)

    def addToFileParser(*args):
        """addToFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMapSimple_addToFileParser, args)

    def remFromFileParser(*args):
        """remFromFileParser(self, ArFileParser fileParser) -> bool"""
        return apply(_AriaPy.ArMapSimple_remFromFileParser, args)

    def readDataPoint(*args):
        """readDataPoint(self, char line) -> bool"""
        return apply(_AriaPy.ArMapSimple_readDataPoint, args)

    def readLineSegment(*args):
        """readLineSegment(self, char line) -> bool"""
        return apply(_AriaPy.ArMapSimple_readLineSegment, args)

    def loadDataPoint(*args):
        """loadDataPoint(self, double x, double y)"""
        return apply(_AriaPy.ArMapSimple_loadDataPoint, args)

    def loadLineSegment(*args):
        """loadLineSegment(self, double x1, double y1, double x2, double y2)"""
        return apply(_AriaPy.ArMapSimple_loadLineSegment, args)

    def mapChanged(*args):
        """mapChanged(self)"""
        return apply(_AriaPy.ArMapSimple_mapChanged, args)

    def addMapChangedCB(*args):
        """
        addMapChangedCB(self, ArFunctor functor, Pos position=LAST)
        addMapChangedCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArMapSimple_addMapChangedCB, args)

    def remMapChangedCB(*args):
        """remMapChangedCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArMapSimple_remMapChangedCB, args)

    def addPreMapChangedCB(*args):
        """
        addPreMapChangedCB(self, ArFunctor functor, Pos position=LAST)
        addPreMapChangedCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArMapSimple_addPreMapChangedCB, args)

    def remPreMapChangedCB(*args):
        """remPreMapChangedCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArMapSimple_remPreMapChangedCB, args)

    def setMapChangedLogLevel(*args):
        """setMapChangedLogLevel(self, LogLevel level)"""
        return apply(_AriaPy.ArMapSimple_setMapChangedLogLevel, args)

    def getMapChangedLogLevel(*args):
        """getMapChangedLogLevel(self) -> int"""
        return apply(_AriaPy.ArMapSimple_getMapChangedLogLevel, args)

    def writeToFunctor(*args):
        """writeToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)"""
        return apply(_AriaPy.ArMapSimple_writeToFunctor, args)

    def writeObjectsToFunctor(*args):
        """
        writeObjectsToFunctor(self, ArFunctor1_CString functor, char endOfLineChars, bool isOverrideAsSingleScan=False, 
            char maxCategory=None)
        writeObjectsToFunctor(self, ArFunctor1_CString functor, char endOfLineChars, bool isOverrideAsSingleScan=False)
        writeObjectsToFunctor(self, ArFunctor1_CString functor, char endOfLineChars)
        """
        return apply(_AriaPy.ArMapSimple_writeObjectsToFunctor, args)

    def addPreWriteFileCB(*args):
        """
        addPreWriteFileCB(self, ArFunctor functor, Pos position=LAST)
        addPreWriteFileCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArMapSimple_addPreWriteFileCB, args)

    def remPreWriteFileCB(*args):
        """remPreWriteFileCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArMapSimple_remPreWriteFileCB, args)

    def addPostWriteFileCB(*args):
        """
        addPostWriteFileCB(self, ArFunctor functor, Pos position=LAST)
        addPostWriteFileCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArMapSimple_addPostWriteFileCB, args)

    def remPostWriteFileCB(*args):
        """remPostWriteFileCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArMapSimple_remPostWriteFileCB, args)

    def readFile(*args):
        """
        readFile(self, char fileName, char errorBuffer=None, size_t errorBufferLen=0, 
            unsigned char md5DigestBuffer=None, 
            size_t md5DigestBufferLen=0) -> bool
        readFile(self, char fileName, char errorBuffer=None, size_t errorBufferLen=0, 
            unsigned char md5DigestBuffer=None) -> bool
        readFile(self, char fileName, char errorBuffer=None, size_t errorBufferLen=0) -> bool
        readFile(self, char fileName, char errorBuffer=None) -> bool
        readFile(self, char fileName) -> bool
        """
        return apply(_AriaPy.ArMapSimple_readFile, args)

    def writeFile(*args):
        """
        writeFile(self, char fileName, bool internalCall=False, unsigned char md5DigestBuffer=None, 
            size_t md5DigestBufferLen=0, 
            time_t fileTimestamp=-1) -> bool
        writeFile(self, char fileName, bool internalCall=False, unsigned char md5DigestBuffer=None, 
            size_t md5DigestBufferLen=0) -> bool
        writeFile(self, char fileName, bool internalCall=False, unsigned char md5DigestBuffer=None) -> bool
        writeFile(self, char fileName, bool internalCall=False) -> bool
        writeFile(self, char fileName) -> bool
        """
        return apply(_AriaPy.ArMapSimple_writeFile, args)

    def getMapId(*args):
        """
        getMapId(self, ArMapId mapIdOut, bool isInternalCall=False) -> bool
        getMapId(self, ArMapId mapIdOut) -> bool
        """
        return apply(_AriaPy.ArMapSimple_getMapId, args)

    def calculateChecksum(*args):
        """calculateChecksum(self, unsigned char md5DigestBuffer, size_t md5DigestBufferLen) -> bool"""
        return apply(_AriaPy.ArMapSimple_calculateChecksum, args)

    def getBaseDirectory(*args):
        """getBaseDirectory(self) -> char"""
        return apply(_AriaPy.ArMapSimple_getBaseDirectory, args)

    def setBaseDirectory(*args):
        """setBaseDirectory(self, char baseDirectory)"""
        return apply(_AriaPy.ArMapSimple_setBaseDirectory, args)

    def getTempDirectory(*args):
        """getTempDirectory(self) -> char"""
        return apply(_AriaPy.ArMapSimple_getTempDirectory, args)

    def setTempDirectory(*args):
        """setTempDirectory(self, char tempDirectory)"""
        return apply(_AriaPy.ArMapSimple_setTempDirectory, args)

    def createRealFileName(*args):
        """createRealFileName(self, char fileName) -> std::string"""
        return apply(_AriaPy.ArMapSimple_createRealFileName, args)

    def getFileName(*args):
        """getFileName(self) -> char"""
        return apply(_AriaPy.ArMapSimple_getFileName, args)

    def setSourceFileName(*args):
        """
        setSourceFileName(self, char sourceName, char fileName, bool isInternalCall=False)
        setSourceFileName(self, char sourceName, char fileName)
        """
        return apply(_AriaPy.ArMapSimple_setSourceFileName, args)

    def refresh(*args):
        """refresh(self) -> bool"""
        return apply(_AriaPy.ArMapSimple_refresh, args)

    def setIgnoreEmptyFileName(*args):
        """setIgnoreEmptyFileName(self, bool ignore)"""
        return apply(_AriaPy.ArMapSimple_setIgnoreEmptyFileName, args)

    def getIgnoreEmptyFileName(*args):
        """getIgnoreEmptyFileName(self) -> bool"""
        return apply(_AriaPy.ArMapSimple_getIgnoreEmptyFileName, args)

    def setIgnoreCase(*args):
        """
        setIgnoreCase(self, bool ignoreCase=False)
        setIgnoreCase(self)
        """
        return apply(_AriaPy.ArMapSimple_setIgnoreCase, args)

    def getIgnoreCase(*args):
        """getIgnoreCase(self) -> bool"""
        return apply(_AriaPy.ArMapSimple_getIgnoreCase, args)

    def getInactiveInfo(*args):
        """getInactiveInfo(self) -> ArMapInfoInterface"""
        return apply(_AriaPy.ArMapSimple_getInactiveInfo, args)

    def getInactiveObjects(*args):
        """getInactiveObjects(self) -> ArMapObjectsInterface"""
        return apply(_AriaPy.ArMapSimple_getInactiveObjects, args)

    def findMapObjectParams(*args):
        """findMapObjectParams(self, char mapObjectName) -> ArArgumentBuilder"""
        return apply(_AriaPy.ArMapSimple_findMapObjectParams, args)

    def setMapObjectParams(*args):
        """
        setMapObjectParams(self, char mapObjectName, ArArgumentBuilder params, ArMapChangeDetails changeDetails=None) -> bool
        setMapObjectParams(self, char mapObjectName, ArArgumentBuilder params) -> bool
        """
        return apply(_AriaPy.ArMapSimple_setMapObjectParams, args)

    def getRemainder(*args):
        """getRemainder(self) -> ArArgumentBuilderPtrList"""
        return apply(_AriaPy.ArMapSimple_getRemainder, args)

    def setQuiet(*args):
        """setQuiet(self, bool isQuiet)"""
        return apply(_AriaPy.ArMapSimple_setQuiet, args)

    def parseLine(*args):
        """parseLine(self, char line) -> bool"""
        return apply(_AriaPy.ArMapSimple_parseLine, args)

    def parsingComplete(*args):
        """parsingComplete(self)"""
        return apply(_AriaPy.ArMapSimple_parsingComplete, args)

    def isLoadingDataStarted(*args):
        """isLoadingDataStarted(self) -> bool"""
        return apply(_AriaPy.ArMapSimple_isLoadingDataStarted, args)

    def isLoadingLinesAndDataStarted(*args):
        """isLoadingLinesAndDataStarted(self) -> bool"""
        return apply(_AriaPy.ArMapSimple_isLoadingLinesAndDataStarted, args)

    __swig_getmethods__["findMapObjectParamInfo"] = lambda x: _AriaPy.ArMapSimple_findMapObjectParamInfo
ArMapSimple_swigregister = _AriaPy.ArMapSimple_swigregister
ArMapSimple_swigregister(ArMapSimple)

def ArMapSimple_findMapObjectParamInfo(*args):
  """ArMapSimple_findMapObjectParamInfo(char mapObjectName, ArArgumentBuilderPtrList cairnInfoList) -> std::list<(p.ArArgumentBuilder,std::allocator<(p.ArArgumentBuilder)>)>::iterator"""
  return apply(_AriaPy.ArMapSimple_findMapObjectParamInfo, args)

class ArMapObject:
    """Proxy of C++ ArMapObject class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMapObject, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArMapObject, name)
    __repr__ = _swig_repr
    __swig_getmethods__["createMapObject"] = lambda x: _AriaPy.ArMapObject_createMapObject
    def __init__(self, *args): 
        """
        __init__(self, char type, ArPose pose, char description, char iconName, 
            char name, bool hasFromTo, ArPose fromPose, 
            ArPose toPose) -> ArMapObject
        __init__(self, ArMapObject mapObject) -> ArMapObject
        """
        this = apply(_AriaPy.new_ArMapObject, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMapObject
    __del__ = lambda self : None;
    def getType(*args):
        """getType(self) -> char"""
        return apply(_AriaPy.ArMapObject_getType, args)

    def getBaseType(*args):
        """getBaseType(self) -> char"""
        return apply(_AriaPy.ArMapObject_getBaseType, args)

    def getName(*args):
        """getName(self) -> char"""
        return apply(_AriaPy.ArMapObject_getName, args)

    def getDescription(*args):
        """getDescription(self) -> char"""
        return apply(_AriaPy.ArMapObject_getDescription, args)

    def getIconName(*args):
        """getIconName(self) -> char"""
        return apply(_AriaPy.ArMapObject_getIconName, args)

    def setDescription(*args):
        """setDescription(self, char description)"""
        return apply(_AriaPy.ArMapObject_setDescription, args)

    def getPose(*args):
        """getPose(self) -> ArPose"""
        return apply(_AriaPy.ArMapObject_getPose, args)

    def hasFromTo(*args):
        """hasFromTo(self) -> bool"""
        return apply(_AriaPy.ArMapObject_hasFromTo, args)

    def getFromPose(*args):
        """getFromPose(self) -> ArPose"""
        return apply(_AriaPy.ArMapObject_getFromPose, args)

    def getToPose(*args):
        """getToPose(self) -> ArPose"""
        return apply(_AriaPy.ArMapObject_getToPose, args)

    def getFromToRotation(*args):
        """getFromToRotation(self) -> double"""
        return apply(_AriaPy.ArMapObject_getFromToRotation, args)

    def getFromToSegments(*args):
        """getFromToSegments(self) -> ArLineSegmentList"""
        return apply(_AriaPy.ArMapObject_getFromToSegments, args)

    def findCenter(*args):
        """findCenter(self) -> ArPose"""
        return apply(_AriaPy.ArMapObject_findCenter, args)

    def toString(*args):
        """toString(self) -> char"""
        return apply(_AriaPy.ArMapObject_toString, args)

    def getStringRepresentation(*args):
        """getStringRepresentation(self) -> char"""
        return apply(_AriaPy.ArMapObject_getStringRepresentation, args)

    def log(*args):
        """
        log(self, char intro=None)
        log(self)
        """
        return apply(_AriaPy.ArMapObject_log, args)

    def __lt__(*args):
        """__lt__(self, ArMapObject other) -> bool"""
        return apply(_AriaPy.ArMapObject___lt__, args)

    def getFileName(*args):
        """getFileName(self) -> char"""
        return apply(_AriaPy.ArMapObject_getFileName, args)

ArMapObject_swigregister = _AriaPy.ArMapObject_swigregister
ArMapObject_swigregister(ArMapObject)

def ArMapObject_createMapObject(*args):
  """ArMapObject_createMapObject(ArArgumentBuilder arg) -> ArMapObject"""
  return apply(_AriaPy.ArMapObject_createMapObject, args)

class ArMapId:
    """Proxy of C++ ArMapId class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMapId, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArMapId, name)
    __repr__ = _swig_repr
    __swig_getmethods__["create"] = lambda x: _AriaPy.ArMapId_create
    __swig_getmethods__["toPacket"] = lambda x: _AriaPy.ArMapId_toPacket
    __swig_getmethods__["fromPacket"] = lambda x: _AriaPy.ArMapId_fromPacket
    def __init__(self, *args): 
        """
        __init__(self) -> ArMapId
        __init__(self, char sourceName, char fileName, unsigned char checksum, 
            size_t checksumLength, long size, time_t timestamp) -> ArMapId
        __init__(self, ArMapId other) -> ArMapId
        """
        this = apply(_AriaPy.new_ArMapId, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArMapId
    __del__ = lambda self : None;
    def isNull(*args):
        """isNull(self) -> bool"""
        return apply(_AriaPy.ArMapId_isNull, args)

    def getSourceName(*args):
        """getSourceName(self) -> char"""
        return apply(_AriaPy.ArMapId_getSourceName, args)

    def getFileName(*args):
        """getFileName(self) -> char"""
        return apply(_AriaPy.ArMapId_getFileName, args)

    def getChecksum(*args):
        """getChecksum(self) -> unsigned char"""
        return apply(_AriaPy.ArMapId_getChecksum, args)

    def getChecksumLength(*args):
        """getChecksumLength(self) -> size_t"""
        return apply(_AriaPy.ArMapId_getChecksumLength, args)

    def getDisplayChecksum(*args):
        """getDisplayChecksum(self) -> char"""
        return apply(_AriaPy.ArMapId_getDisplayChecksum, args)

    def getSize(*args):
        """getSize(self) -> long"""
        return apply(_AriaPy.ArMapId_getSize, args)

    def getTimestamp(*args):
        """getTimestamp(self) -> time_t"""
        return apply(_AriaPy.ArMapId_getTimestamp, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArMapId_clear, args)

    def setSourceName(*args):
        """setSourceName(self, char sourceName)"""
        return apply(_AriaPy.ArMapId_setSourceName, args)

    def setFileName(*args):
        """setFileName(self, char fileName)"""
        return apply(_AriaPy.ArMapId_setFileName, args)

    def setChecksum(*args):
        """setChecksum(self, unsigned char checksum, size_t checksumLen)"""
        return apply(_AriaPy.ArMapId_setChecksum, args)

    def setSize(*args):
        """setSize(self, long size)"""
        return apply(_AriaPy.ArMapId_setSize, args)

    def setTimestamp(*args):
        """setTimestamp(self, time_t timestamp)"""
        return apply(_AriaPy.ArMapId_setTimestamp, args)

    def isSameFile(*args):
        """isSameFile(self, ArMapId other) -> bool"""
        return apply(_AriaPy.ArMapId_isSameFile, args)

    def isVersionOfSameFile(*args):
        """isVersionOfSameFile(self, ArMapId other) -> bool"""
        return apply(_AriaPy.ArMapId_isVersionOfSameFile, args)

    def log(*args):
        """log(self, char prefix)"""
        return apply(_AriaPy.ArMapId_log, args)

ArMapId_swigregister = _AriaPy.ArMapId_swigregister
ArMapId_swigregister(ArMapId)

def ArMapId_create(*args):
  """ArMapId_create(char fileName, ArMapId mapIdOut) -> bool"""
  return apply(_AriaPy.ArMapId_create, args)

def ArMapId_toPacket(*args):
  """ArMapId_toPacket(ArMapId mapId, ArBasePacket packetOut) -> bool"""
  return apply(_AriaPy.ArMapId_toPacket, args)

def ArMapId_fromPacket(*args):
  """ArMapId_fromPacket(ArBasePacket packetIn, ArMapId mapIdOut) -> bool"""
  return apply(_AriaPy.ArMapId_fromPacket, args)

class ArMode:
    """Proxy of C++ ArMode class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArMode, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArMode
    __del__ = lambda self : None;
    def getName(*args):
        """getName(self) -> char"""
        return apply(_AriaPy.ArMode_getName, args)

    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArMode_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArMode_deactivate, args)

    def userTask(*args):
        """userTask(self)"""
        return apply(_AriaPy.ArMode_userTask, args)

    def help(*args):
        """help(self)"""
        return apply(_AriaPy.ArMode_help, args)

    def baseActivate(*args):
        """baseActivate(self) -> bool"""
        return apply(_AriaPy.ArMode_baseActivate, args)

    def baseDeactivate(*args):
        """baseDeactivate(self) -> bool"""
        return apply(_AriaPy.ArMode_baseDeactivate, args)

    __swig_getmethods__["baseHelp"] = lambda x: _AriaPy.ArMode_baseHelp
    def getKey(*args):
        """getKey(self) -> char"""
        return apply(_AriaPy.ArMode_getKey, args)

    def getKey2(*args):
        """getKey2(self) -> char"""
        return apply(_AriaPy.ArMode_getKey2, args)

ArMode_swigregister = _AriaPy.ArMode_swigregister
ArMode_swigregister(ArMode)

def ArMode_baseHelp(*args):
  """ArMode_baseHelp()"""
  return apply(_AriaPy.ArMode_baseHelp, args)

class ArModeTeleop(ArMode):
    """Proxy of C++ ArModeTeleop class"""
    __swig_setmethods__ = {}
    for _s in [ArMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModeTeleop, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArModeTeleop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot, char name, char key, char key2) -> ArModeTeleop"""
        this = apply(_AriaPy.new_ArModeTeleop, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeTeleop
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArModeTeleop_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArModeTeleop_deactivate, args)

    def help(*args):
        """help(self)"""
        return apply(_AriaPy.ArModeTeleop_help, args)

    def userTask(*args):
        """userTask(self)"""
        return apply(_AriaPy.ArModeTeleop_userTask, args)

ArModeTeleop_swigregister = _AriaPy.ArModeTeleop_swigregister
ArModeTeleop_swigregister(ArModeTeleop)

class ArModeUnguardedTeleop(ArMode):
    """Proxy of C++ ArModeUnguardedTeleop class"""
    __swig_setmethods__ = {}
    for _s in [ArMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModeUnguardedTeleop, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArModeUnguardedTeleop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot, char name, char key, char key2) -> ArModeUnguardedTeleop"""
        this = apply(_AriaPy.new_ArModeUnguardedTeleop, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeUnguardedTeleop
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArModeUnguardedTeleop_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArModeUnguardedTeleop_deactivate, args)

    def help(*args):
        """help(self)"""
        return apply(_AriaPy.ArModeUnguardedTeleop_help, args)

    def userTask(*args):
        """userTask(self)"""
        return apply(_AriaPy.ArModeUnguardedTeleop_userTask, args)

ArModeUnguardedTeleop_swigregister = _AriaPy.ArModeUnguardedTeleop_swigregister
ArModeUnguardedTeleop_swigregister(ArModeUnguardedTeleop)

class ArModeWander(ArMode):
    """Proxy of C++ ArModeWander class"""
    __swig_setmethods__ = {}
    for _s in [ArMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModeWander, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArModeWander, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot, char name, char key, char key2) -> ArModeWander"""
        this = apply(_AriaPy.new_ArModeWander, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeWander
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArModeWander_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArModeWander_deactivate, args)

    def help(*args):
        """help(self)"""
        return apply(_AriaPy.ArModeWander_help, args)

    def userTask(*args):
        """userTask(self)"""
        return apply(_AriaPy.ArModeWander_userTask, args)

ArModeWander_swigregister = _AriaPy.ArModeWander_swigregister
ArModeWander_swigregister(ArModeWander)

class ArModeGripper(ArMode):
    """Proxy of C++ ArModeGripper class"""
    __swig_setmethods__ = {}
    for _s in [ArMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModeGripper, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArModeGripper, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot, char name, char key, char key2) -> ArModeGripper"""
        this = apply(_AriaPy.new_ArModeGripper, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeGripper
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArModeGripper_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArModeGripper_deactivate, args)

    def userTask(*args):
        """userTask(self)"""
        return apply(_AriaPy.ArModeGripper_userTask, args)

    def help(*args):
        """help(self)"""
        return apply(_AriaPy.ArModeGripper_help, args)

    def open(*args):
        """open(self)"""
        return apply(_AriaPy.ArModeGripper_open, args)

    def close(*args):
        """close(self)"""
        return apply(_AriaPy.ArModeGripper_close, args)

    def up(*args):
        """up(self)"""
        return apply(_AriaPy.ArModeGripper_up, args)

    def down(*args):
        """down(self)"""
        return apply(_AriaPy.ArModeGripper_down, args)

    def stop(*args):
        """stop(self)"""
        return apply(_AriaPy.ArModeGripper_stop, args)

    def exercise(*args):
        """exercise(self)"""
        return apply(_AriaPy.ArModeGripper_exercise, args)

ArModeGripper_swigregister = _AriaPy.ArModeGripper_swigregister
ArModeGripper_swigregister(ArModeGripper)

class ArModeCamera(ArMode):
    """Proxy of C++ ArModeCamera class"""
    __swig_setmethods__ = {}
    for _s in [ArMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModeCamera, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArModeCamera, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot, char name, char key, char key2) -> ArModeCamera"""
        this = apply(_AriaPy.new_ArModeCamera, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeCamera
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArModeCamera_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArModeCamera_deactivate, args)

    def userTask(*args):
        """userTask(self)"""
        return apply(_AriaPy.ArModeCamera_userTask, args)

    def help(*args):
        """help(self)"""
        return apply(_AriaPy.ArModeCamera_help, args)

    def up(*args):
        """up(self)"""
        return apply(_AriaPy.ArModeCamera_up, args)

    def down(*args):
        """down(self)"""
        return apply(_AriaPy.ArModeCamera_down, args)

    def left(*args):
        """left(self)"""
        return apply(_AriaPy.ArModeCamera_left, args)

    def right(*args):
        """right(self)"""
        return apply(_AriaPy.ArModeCamera_right, args)

    def center(*args):
        """center(self)"""
        return apply(_AriaPy.ArModeCamera_center, args)

    def zoomIn(*args):
        """zoomIn(self)"""
        return apply(_AriaPy.ArModeCamera_zoomIn, args)

    def zoomOut(*args):
        """zoomOut(self)"""
        return apply(_AriaPy.ArModeCamera_zoomOut, args)

    def exercise(*args):
        """exercise(self)"""
        return apply(_AriaPy.ArModeCamera_exercise, args)

    def sony(*args):
        """sony(self)"""
        return apply(_AriaPy.ArModeCamera_sony, args)

    def canon(*args):
        """canon(self)"""
        return apply(_AriaPy.ArModeCamera_canon, args)

    def dpptu(*args):
        """dpptu(self)"""
        return apply(_AriaPy.ArModeCamera_dpptu, args)

    def amptu(*args):
        """amptu(self)"""
        return apply(_AriaPy.ArModeCamera_amptu, args)

    def canonInverted(*args):
        """canonInverted(self)"""
        return apply(_AriaPy.ArModeCamera_canonInverted, args)

    def sonySerial(*args):
        """sonySerial(self)"""
        return apply(_AriaPy.ArModeCamera_sonySerial, args)

    def canonSerial(*args):
        """canonSerial(self)"""
        return apply(_AriaPy.ArModeCamera_canonSerial, args)

    def dpptuSerial(*args):
        """dpptuSerial(self)"""
        return apply(_AriaPy.ArModeCamera_dpptuSerial, args)

    def amptuSerial(*args):
        """amptuSerial(self)"""
        return apply(_AriaPy.ArModeCamera_amptuSerial, args)

    def canonInvertedSerial(*args):
        """canonInvertedSerial(self)"""
        return apply(_AriaPy.ArModeCamera_canonInvertedSerial, args)

    def rvisionSerial(*args):
        """rvisionSerial(self)"""
        return apply(_AriaPy.ArModeCamera_rvisionSerial, args)

    def com1(*args):
        """com1(self)"""
        return apply(_AriaPy.ArModeCamera_com1, args)

    def com2(*args):
        """com2(self)"""
        return apply(_AriaPy.ArModeCamera_com2, args)

    def com3(*args):
        """com3(self)"""
        return apply(_AriaPy.ArModeCamera_com3, args)

    def com4(*args):
        """com4(self)"""
        return apply(_AriaPy.ArModeCamera_com4, args)

    def aux1(*args):
        """aux1(self)"""
        return apply(_AriaPy.ArModeCamera_aux1, args)

    def aux2(*args):
        """aux2(self)"""
        return apply(_AriaPy.ArModeCamera_aux2, args)

ArModeCamera_swigregister = _AriaPy.ArModeCamera_swigregister
ArModeCamera_swigregister(ArModeCamera)

class ArModeSonar(ArMode):
    """Proxy of C++ ArModeSonar class"""
    __swig_setmethods__ = {}
    for _s in [ArMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModeSonar, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArModeSonar, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot, char name, char key, char key2) -> ArModeSonar"""
        this = apply(_AriaPy.new_ArModeSonar, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeSonar
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArModeSonar_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArModeSonar_deactivate, args)

    def userTask(*args):
        """userTask(self)"""
        return apply(_AriaPy.ArModeSonar_userTask, args)

    def help(*args):
        """help(self)"""
        return apply(_AriaPy.ArModeSonar_help, args)

    def allSonar(*args):
        """allSonar(self)"""
        return apply(_AriaPy.ArModeSonar_allSonar, args)

    def firstSonar(*args):
        """firstSonar(self)"""
        return apply(_AriaPy.ArModeSonar_firstSonar, args)

    def secondSonar(*args):
        """secondSonar(self)"""
        return apply(_AriaPy.ArModeSonar_secondSonar, args)

    def thirdSonar(*args):
        """thirdSonar(self)"""
        return apply(_AriaPy.ArModeSonar_thirdSonar, args)

    def fourthSonar(*args):
        """fourthSonar(self)"""
        return apply(_AriaPy.ArModeSonar_fourthSonar, args)

ArModeSonar_swigregister = _AriaPy.ArModeSonar_swigregister
ArModeSonar_swigregister(ArModeSonar)

class ArModeBumps(ArMode):
    """Proxy of C++ ArModeBumps class"""
    __swig_setmethods__ = {}
    for _s in [ArMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModeBumps, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArModeBumps, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot, char name, char key, char key2) -> ArModeBumps"""
        this = apply(_AriaPy.new_ArModeBumps, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeBumps
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArModeBumps_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArModeBumps_deactivate, args)

    def userTask(*args):
        """userTask(self)"""
        return apply(_AriaPy.ArModeBumps_userTask, args)

    def help(*args):
        """help(self)"""
        return apply(_AriaPy.ArModeBumps_help, args)

ArModeBumps_swigregister = _AriaPy.ArModeBumps_swigregister
ArModeBumps_swigregister(ArModeBumps)

class ArModePosition(ArMode):
    """Proxy of C++ ArModePosition class"""
    __swig_setmethods__ = {}
    for _s in [ArMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModePosition, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArModePosition, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, char name, char key, char key2, ArAnalogGyro gyro=None) -> ArModePosition
        __init__(self, ArRobot robot, char name, char key, char key2) -> ArModePosition
        """
        this = apply(_AriaPy.new_ArModePosition, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModePosition
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArModePosition_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArModePosition_deactivate, args)

    def userTask(*args):
        """userTask(self)"""
        return apply(_AriaPy.ArModePosition_userTask, args)

    def help(*args):
        """help(self)"""
        return apply(_AriaPy.ArModePosition_help, args)

    def up(*args):
        """up(self)"""
        return apply(_AriaPy.ArModePosition_up, args)

    def down(*args):
        """down(self)"""
        return apply(_AriaPy.ArModePosition_down, args)

    def left(*args):
        """left(self)"""
        return apply(_AriaPy.ArModePosition_left, args)

    def right(*args):
        """right(self)"""
        return apply(_AriaPy.ArModePosition_right, args)

    def stop(*args):
        """stop(self)"""
        return apply(_AriaPy.ArModePosition_stop, args)

    def reset(*args):
        """reset(self)"""
        return apply(_AriaPy.ArModePosition_reset, args)

    def mode(*args):
        """mode(self)"""
        return apply(_AriaPy.ArModePosition_mode, args)

    def gyro(*args):
        """gyro(self)"""
        return apply(_AriaPy.ArModePosition_gyro, args)

    def incDistance(*args):
        """incDistance(self)"""
        return apply(_AriaPy.ArModePosition_incDistance, args)

    def decDistance(*args):
        """decDistance(self)"""
        return apply(_AriaPy.ArModePosition_decDistance, args)

ArModePosition_swigregister = _AriaPy.ArModePosition_swigregister
ArModePosition_swigregister(ArModePosition)

class ArModeIO(ArMode):
    """Proxy of C++ ArModeIO class"""
    __swig_setmethods__ = {}
    for _s in [ArMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModeIO, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArModeIO, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot, char name, char key, char key2) -> ArModeIO"""
        this = apply(_AriaPy.new_ArModeIO, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeIO
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArModeIO_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArModeIO_deactivate, args)

    def userTask(*args):
        """userTask(self)"""
        return apply(_AriaPy.ArModeIO_userTask, args)

    def help(*args):
        """help(self)"""
        return apply(_AriaPy.ArModeIO_help, args)

ArModeIO_swigregister = _AriaPy.ArModeIO_swigregister
ArModeIO_swigregister(ArModeIO)

class ArModeLaser(ArMode):
    """Proxy of C++ ArModeLaser class"""
    __swig_setmethods__ = {}
    for _s in [ArMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModeLaser, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArModeLaser, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, char name, char key, char key2, ArSick obsolete=None) -> ArModeLaser
        __init__(self, ArRobot robot, char name, char key, char key2) -> ArModeLaser
        """
        this = apply(_AriaPy.new_ArModeLaser, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeLaser
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArModeLaser_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArModeLaser_deactivate, args)

    def userTask(*args):
        """userTask(self)"""
        return apply(_AriaPy.ArModeLaser_userTask, args)

    def help(*args):
        """help(self)"""
        return apply(_AriaPy.ArModeLaser_help, args)

    def switchToLaser(*args):
        """switchToLaser(self, int laserNumber)"""
        return apply(_AriaPy.ArModeLaser_switchToLaser, args)

ArModeLaser_swigregister = _AriaPy.ArModeLaser_swigregister
ArModeLaser_swigregister(ArModeLaser)

class ArModeActs(ArMode):
    """Proxy of C++ ArModeActs class"""
    __swig_setmethods__ = {}
    for _s in [ArMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModeActs, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArModeActs, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, char name, char key, char key2, ArACTS_1_2 acts=None) -> ArModeActs
        __init__(self, ArRobot robot, char name, char key, char key2) -> ArModeActs
        """
        this = apply(_AriaPy.new_ArModeActs, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeActs
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArModeActs_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArModeActs_deactivate, args)

    def help(*args):
        """help(self)"""
        return apply(_AriaPy.ArModeActs_help, args)

    def userTask(*args):
        """userTask(self)"""
        return apply(_AriaPy.ArModeActs_userTask, args)

    def channel1(*args):
        """channel1(self)"""
        return apply(_AriaPy.ArModeActs_channel1, args)

    def channel2(*args):
        """channel2(self)"""
        return apply(_AriaPy.ArModeActs_channel2, args)

    def channel3(*args):
        """channel3(self)"""
        return apply(_AriaPy.ArModeActs_channel3, args)

    def channel4(*args):
        """channel4(self)"""
        return apply(_AriaPy.ArModeActs_channel4, args)

    def channel5(*args):
        """channel5(self)"""
        return apply(_AriaPy.ArModeActs_channel5, args)

    def channel6(*args):
        """channel6(self)"""
        return apply(_AriaPy.ArModeActs_channel6, args)

    def channel7(*args):
        """channel7(self)"""
        return apply(_AriaPy.ArModeActs_channel7, args)

    def channel8(*args):
        """channel8(self)"""
        return apply(_AriaPy.ArModeActs_channel8, args)

    def stop(*args):
        """stop(self)"""
        return apply(_AriaPy.ArModeActs_stop, args)

    def start(*args):
        """start(self)"""
        return apply(_AriaPy.ArModeActs_start, args)

    def toggleAcquire(*args):
        """toggleAcquire(self)"""
        return apply(_AriaPy.ArModeActs_toggleAcquire, args)

ArModeActs_swigregister = _AriaPy.ArModeActs_swigregister
ArModeActs_swigregister(ArModeActs)

class ArModeCommand(ArMode):
    """Proxy of C++ ArModeCommand class"""
    __swig_setmethods__ = {}
    for _s in [ArMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModeCommand, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArModeCommand, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot, char name, char key, char key2) -> ArModeCommand"""
        this = apply(_AriaPy.new_ArModeCommand, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeCommand
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArModeCommand_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArModeCommand_deactivate, args)

    def help(*args):
        """help(self)"""
        return apply(_AriaPy.ArModeCommand_help, args)

ArModeCommand_swigregister = _AriaPy.ArModeCommand_swigregister
ArModeCommand_swigregister(ArModeCommand)

class ArModeTCM2(ArMode):
    """Proxy of C++ ArModeTCM2 class"""
    __swig_setmethods__ = {}
    for _s in [ArMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModeTCM2, name, value)
    __swig_getmethods__ = {}
    for _s in [ArMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArModeTCM2, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, char name, char key, char key2, ArTCM2 tcm2=None) -> ArModeTCM2
        __init__(self, ArRobot robot, char name, char key, char key2) -> ArModeTCM2
        """
        this = apply(_AriaPy.new_ArModeTCM2, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModeTCM2
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return apply(_AriaPy.ArModeTCM2_activate, args)

    def deactivate(*args):
        """deactivate(self)"""
        return apply(_AriaPy.ArModeTCM2_deactivate, args)

    def help(*args):
        """help(self)"""
        return apply(_AriaPy.ArModeTCM2_help, args)

    def userTask(*args):
        """userTask(self)"""
        return apply(_AriaPy.ArModeTCM2_userTask, args)

ArModeTCM2_swigregister = _AriaPy.ArModeTCM2_swigregister
ArModeTCM2_swigregister(ArModeTCM2)

class ArModule:
    """Proxy of C++ ArModule class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModule, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArModule, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArModule
    __del__ = lambda self : None;
    def init(*args):
        """
        init(self, ArRobot robot, void argument=None) -> bool
        init(self, ArRobot robot) -> bool
        """
        return apply(_AriaPy.ArModule_init, args)

    def exit(*args):
        """exit(self) -> bool"""
        return apply(_AriaPy.ArModule_exit, args)

    def getRobot(*args):
        """getRobot(self) -> ArRobot"""
        return apply(_AriaPy.ArModule_getRobot, args)

    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArModule_setRobot, args)

ArModule_swigregister = _AriaPy.ArModule_swigregister
ArModule_swigregister(ArModule)

class ArModuleLoader:
    """Proxy of C++ ArModuleLoader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArModuleLoader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArModuleLoader, name)
    __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
    __swig_getmethods__["load"] = lambda x: _AriaPy.ArModuleLoader_load
    __swig_getmethods__["reload"] = lambda x: _AriaPy.ArModuleLoader_reload
    __swig_getmethods__["close"] = lambda x: _AriaPy.ArModuleLoader_close
    __swig_getmethods__["closeAll"] = lambda x: _AriaPy.ArModuleLoader_closeAll
    def __init__(self, *args): 
        """__init__(self) -> ArModuleLoader"""
        this = apply(_AriaPy.new_ArModuleLoader, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArModuleLoader
    __del__ = lambda self : None;
ArModuleLoader_swigregister = _AriaPy.ArModuleLoader_swigregister
ArModuleLoader_swigregister(ArModuleLoader)

def ArModuleLoader_load(*args):
  """
    load(char modName, ArRobot robot, void modArgument=None, 
        bool quiet=False) -> int
    load(char modName, ArRobot robot, void modArgument=None) -> int
    ArModuleLoader_load(char modName, ArRobot robot) -> int
    """
  return apply(_AriaPy.ArModuleLoader_load, args)

def ArModuleLoader_reload(*args):
  """
    reload(char modName, ArRobot robot, void modArgument=None, 
        bool quiet=False) -> int
    reload(char modName, ArRobot robot, void modArgument=None) -> int
    ArModuleLoader_reload(char modName, ArRobot robot) -> int
    """
  return apply(_AriaPy.ArModuleLoader_reload, args)

def ArModuleLoader_close(*args):
  """
    close(char modName, bool quiet=False) -> int
    ArModuleLoader_close(char modName) -> int
    """
  return apply(_AriaPy.ArModuleLoader_close, args)

def ArModuleLoader_closeAll(*args):
  """ArModuleLoader_closeAll()"""
  return apply(_AriaPy.ArModuleLoader_closeAll, args)

class ArMutex:
    """Proxy of C++ ArMutex class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArMutex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArMutex, name)
    __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__(self, bool recursive=True) -> ArMutex
        __init__(self) -> ArMutex
        __init__(self, ArMutex mutex) -> ArMutex
        """
        this = apply(_AriaPy.new_ArMutex, args)
        try: self.this.append(this)
        except: self.this = this
    def lock(*args):
        """lock(self) -> int"""
        return apply(_AriaPy.ArMutex_lock, args)

    def tryLock(*args):
        """tryLock(self) -> int"""
        return apply(_AriaPy.ArMutex_tryLock, args)

    def unlock(*args):
        """unlock(self) -> int"""
        return apply(_AriaPy.ArMutex_unlock, args)

    def getError(*args):
        """getError(self, int messageNumber) -> char"""
        return apply(_AriaPy.ArMutex_getError, args)

    def setLog(*args):
        """setLog(self, bool log)"""
        return apply(_AriaPy.ArMutex_setLog, args)

    def setLogName(*args):
        """setLogName(self, char logName)"""
        return apply(_AriaPy.ArMutex_setLogName, args)

    def getMutex(*args):
        """getMutex(self) -> MutexType"""
        return apply(_AriaPy.ArMutex_getMutex, args)

    __swig_getmethods__["setLockWarningTime"] = lambda x: _AriaPy.ArMutex_setLockWarningTime
    __swig_getmethods__["getLockWarningTime"] = lambda x: _AriaPy.ArMutex_getLockWarningTime
    __swig_getmethods__["setUnlockWarningTime"] = lambda x: _AriaPy.ArMutex_setUnlockWarningTime
    __swig_getmethods__["getUnlockWarningTime"] = lambda x: _AriaPy.ArMutex_getUnlockWarningTime
ArMutex_swigregister = _AriaPy.ArMutex_swigregister
ArMutex_swigregister(ArMutex)

def ArMutex_setLockWarningTime(*args):
  """ArMutex_setLockWarningTime(double lockWarningSeconds)"""
  return apply(_AriaPy.ArMutex_setLockWarningTime, args)

def ArMutex_getLockWarningTime(*args):
  """ArMutex_getLockWarningTime() -> double"""
  return apply(_AriaPy.ArMutex_getLockWarningTime, args)

def ArMutex_setUnlockWarningTime(*args):
  """ArMutex_setUnlockWarningTime(double unlockWarningSeconds)"""
  return apply(_AriaPy.ArMutex_setUnlockWarningTime, args)

def ArMutex_getUnlockWarningTime(*args):
  """ArMutex_getUnlockWarningTime() -> double"""
  return apply(_AriaPy.ArMutex_getUnlockWarningTime, args)

class ArNMEAParser:
    """Proxy of C++ ArNMEAParser class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNMEAParser, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArNMEAParser, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name="NMEA Parser") -> ArNMEAParser
        __init__(self) -> ArNMEAParser
        """
        this = apply(_AriaPy.new_ArNMEAParser, args)
        try: self.this.append(this)
        except: self.this = this
    ParseFinished = _AriaPy.ArNMEAParser_ParseFinished
    ParseError = _AriaPy.ArNMEAParser_ParseError
    ParseData = _AriaPy.ArNMEAParser_ParseData
    ParseUpdated = _AriaPy.ArNMEAParser_ParseUpdated
    __swig_setmethods__["ParseFlags"] = _AriaPy.ArNMEAParser_ParseFlags_set
    __swig_getmethods__["ParseFlags"] = _AriaPy.ArNMEAParser_ParseFlags_get
    def setIgnoreChecksum(*args):
        """setIgnoreChecksum(self, bool ignore)"""
        return apply(_AriaPy.ArNMEAParser_setIgnoreChecksum, args)

    def addHandler(*args):
        """addHandler(self, char message, Handler handler)"""
        return apply(_AriaPy.ArNMEAParser_addHandler, args)

    def removeHandler(*args):
        """removeHandler(self, char message)"""
        return apply(_AriaPy.ArNMEAParser_removeHandler, args)

    def parse(*args):
        """
        parse(self, ArDeviceConnection dev) -> int
        parse(self, char buf, int n) -> int
        """
        return apply(_AriaPy.ArNMEAParser_parse, args)

    def getHandlersRef(*args):
        """getHandlersRef(self) -> HandlerMap"""
        return apply(_AriaPy.ArNMEAParser_getHandlersRef, args)

    __swig_destroy__ = _AriaPy.delete_ArNMEAParser
    __del__ = lambda self : None;
ArNMEAParser_swigregister = _AriaPy.ArNMEAParser_swigregister
ArNMEAParser_swigregister(ArNMEAParser)

class ArNMEAParser_Message:
    """Proxy of C++ ArNMEAParser_Message class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNMEAParser_Message, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArNMEAParser_Message, name)
    __repr__ = _swig_repr
    __swig_setmethods__["message"] = _AriaPy.ArNMEAParser_Message_message_set
    __swig_getmethods__["message"] = _AriaPy.ArNMEAParser_Message_message_get
    __swig_setmethods__["timeParseStarted"] = _AriaPy.ArNMEAParser_Message_timeParseStarted_set
    __swig_getmethods__["timeParseStarted"] = _AriaPy.ArNMEAParser_Message_timeParseStarted_get
    def __init__(self, *args): 
        """__init__(self) -> ArNMEAParser_Message"""
        this = apply(_AriaPy.new_ArNMEAParser_Message, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArNMEAParser_Message
    __del__ = lambda self : None;
ArNMEAParser_Message_swigregister = _AriaPy.ArNMEAParser_Message_swigregister
ArNMEAParser_Message_swigregister(ArNMEAParser_Message)

class ArNetServer:
    """Proxy of C++ ArNetServer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNetServer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArNetServer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, bool addAriaExitCB=True) -> ArNetServer
        __init__(self) -> ArNetServer
        """
        this = apply(_AriaPy.new_ArNetServer, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArNetServer
    __del__ = lambda self : None;
    def open(*args):
        """
        open(self, ArRobot robot, unsigned int port, char password, bool multipleClients=True, 
            char openOnIP=None) -> bool
        open(self, ArRobot robot, unsigned int port, char password, bool multipleClients=True) -> bool
        open(self, ArRobot robot, unsigned int port, char password) -> bool
        """
        return apply(_AriaPy.ArNetServer_open, args)

    def close(*args):
        """close(self)"""
        return apply(_AriaPy.ArNetServer_close, args)

    def addCommand(*args):
        """
        addCommand(self, char command, ArFunctor3<(p.p.char,int,p.ArSocket)> functor, 
            char help) -> bool
        """
        return apply(_AriaPy.ArNetServer_addCommand, args)

    def remCommand(*args):
        """remCommand(self, char command) -> bool"""
        return apply(_AriaPy.ArNetServer_remCommand, args)

    def sendToAllClientsPlain(*args):
        """sendToAllClientsPlain(self, char str)"""
        return apply(_AriaPy.ArNetServer_sendToAllClientsPlain, args)

    def sendToClientPlain(*args):
        """sendToClientPlain(self, ArSocket socket, char ipString, char str)"""
        return apply(_AriaPy.ArNetServer_sendToClientPlain, args)

    def isOpen(*args):
        """isOpen(self) -> bool"""
        return apply(_AriaPy.ArNetServer_isOpen, args)

    def setLoggingDataSent(*args):
        """setLoggingDataSent(self, bool loggingData)"""
        return apply(_AriaPy.ArNetServer_setLoggingDataSent, args)

    def getLoggingDataSent(*args):
        """getLoggingDataSent(self) -> bool"""
        return apply(_AriaPy.ArNetServer_getLoggingDataSent, args)

    def setLoggingDataReceived(*args):
        """setLoggingDataReceived(self, bool loggingData)"""
        return apply(_AriaPy.ArNetServer_setLoggingDataReceived, args)

    def getLoggingDataReceived(*args):
        """getLoggingDataReceived(self) -> bool"""
        return apply(_AriaPy.ArNetServer_getLoggingDataReceived, args)

    def setUseWrongEndChars(*args):
        """setUseWrongEndChars(self, bool useWrongEndChars)"""
        return apply(_AriaPy.ArNetServer_setUseWrongEndChars, args)

    def getUseWrongEndChars(*args):
        """getUseWrongEndChars(self) -> bool"""
        return apply(_AriaPy.ArNetServer_getUseWrongEndChars, args)

    def runOnce(*args):
        """runOnce(self)"""
        return apply(_AriaPy.ArNetServer_runOnce, args)

    def internalGreeting(*args):
        """internalGreeting(self, ArSocket socket)"""
        return apply(_AriaPy.ArNetServer_internalGreeting, args)

    def internalHelp(*args):
        """
        internalHelp(self, ArSocket socket)
        internalHelp(self, char argv, int argc, ArSocket socket)
        """
        return apply(_AriaPy.ArNetServer_internalHelp, args)

    def internalEcho(*args):
        """internalEcho(self, char argv, int argc, ArSocket socket)"""
        return apply(_AriaPy.ArNetServer_internalEcho, args)

    def internalQuit(*args):
        """internalQuit(self, char argv, int argc, ArSocket socket)"""
        return apply(_AriaPy.ArNetServer_internalQuit, args)

    def internalShutdownServer(*args):
        """internalShutdownServer(self, char argv, int argc, ArSocket socket)"""
        return apply(_AriaPy.ArNetServer_internalShutdownServer, args)

    def parseCommandOnSocket(*args):
        """
        parseCommandOnSocket(self, ArArgumentBuilder args, ArSocket socket, bool allowLog=True)
        parseCommandOnSocket(self, ArArgumentBuilder args, ArSocket socket)
        """
        return apply(_AriaPy.ArNetServer_parseCommandOnSocket, args)

    def internalAddSocketToList(*args):
        """internalAddSocketToList(self, ArSocket socket)"""
        return apply(_AriaPy.ArNetServer_internalAddSocketToList, args)

    def internalAddSocketToDeleteList(*args):
        """internalAddSocketToDeleteList(self, ArSocket socket)"""
        return apply(_AriaPy.ArNetServer_internalAddSocketToDeleteList, args)

    def squelchNormal(*args):
        """squelchNormal(self)"""
        return apply(_AriaPy.ArNetServer_squelchNormal, args)

    def setExtraString(*args):
        """setExtraString(self, char str)"""
        return apply(_AriaPy.ArNetServer_setExtraString, args)

    def getExtraString(*args):
        """getExtraString(self) -> char"""
        return apply(_AriaPy.ArNetServer_getExtraString, args)

    def lock(*args):
        """lock(self) -> int"""
        return apply(_AriaPy.ArNetServer_lock, args)

    def tryLock(*args):
        """tryLock(self) -> int"""
        return apply(_AriaPy.ArNetServer_tryLock, args)

    def unlock(*args):
        """unlock(self) -> int"""
        return apply(_AriaPy.ArNetServer_unlock, args)

ArNetServer_swigregister = _AriaPy.ArNetServer_swigregister
ArNetServer_swigregister(ArNetServer)

class ArNovatelGPS(ArGPS):
    """Proxy of C++ ArNovatelGPS class"""
    __swig_setmethods__ = {}
    for _s in [ArGPS]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNovatelGPS, name, value)
    __swig_getmethods__ = {}
    for _s in [ArGPS]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArNovatelGPS, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArNovatelGPS"""
        this = apply(_AriaPy.new_ArNovatelGPS, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArNovatelGPS
    __del__ = lambda self : None;
ArNovatelGPS_swigregister = _AriaPy.ArNovatelGPS_swigregister
ArNovatelGPS_swigregister(ArNovatelGPS)

class P2ArmJoint:
    """Proxy of C++ P2ArmJoint class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, P2ArmJoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, P2ArmJoint, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> P2ArmJoint"""
        this = apply(_AriaPy.new_P2ArmJoint, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_P2ArmJoint
    __del__ = lambda self : None;
    __swig_setmethods__["myPos"] = _AriaPy.P2ArmJoint_myPos_set
    __swig_getmethods__["myPos"] = _AriaPy.P2ArmJoint_myPos_get
    __swig_setmethods__["myVel"] = _AriaPy.P2ArmJoint_myVel_set
    __swig_getmethods__["myVel"] = _AriaPy.P2ArmJoint_myVel_get
    __swig_setmethods__["myHome"] = _AriaPy.P2ArmJoint_myHome_set
    __swig_getmethods__["myHome"] = _AriaPy.P2ArmJoint_myHome_get
    __swig_setmethods__["myMin"] = _AriaPy.P2ArmJoint_myMin_set
    __swig_getmethods__["myMin"] = _AriaPy.P2ArmJoint_myMin_get
    __swig_setmethods__["myCenter"] = _AriaPy.P2ArmJoint_myCenter_set
    __swig_getmethods__["myCenter"] = _AriaPy.P2ArmJoint_myCenter_get
    __swig_setmethods__["myMax"] = _AriaPy.P2ArmJoint_myMax_set
    __swig_getmethods__["myMax"] = _AriaPy.P2ArmJoint_myMax_get
    __swig_setmethods__["myTicksPer90"] = _AriaPy.P2ArmJoint_myTicksPer90_set
    __swig_getmethods__["myTicksPer90"] = _AriaPy.P2ArmJoint_myTicksPer90_get
P2ArmJoint_swigregister = _AriaPy.P2ArmJoint_swigregister
P2ArmJoint_swigregister(P2ArmJoint)

class ArP2Arm:
    """Proxy of C++ ArP2Arm class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArP2Arm, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArP2Arm, name)
    __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
    __swig_setmethods__["NumJoints"] = _AriaPy.ArP2Arm_NumJoints_set
    __swig_getmethods__["NumJoints"] = _AriaPy.ArP2Arm_NumJoints_get
    def __init__(self, *args): 
        """__init__(self) -> ArP2Arm"""
        this = apply(_AriaPy.new_ArP2Arm, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArP2Arm
    __del__ = lambda self : None;
    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArP2Arm_setRobot, args)

    def init(*args):
        """init(self) -> int"""
        return apply(_AriaPy.ArP2Arm_init, args)

    def uninit(*args):
        """uninit(self) -> int"""
        return apply(_AriaPy.ArP2Arm_uninit, args)

    def powerOn(*args):
        """
        powerOn(self, bool doWait=True) -> int
        powerOn(self) -> int
        """
        return apply(_AriaPy.ArP2Arm_powerOn, args)

    def powerOff(*args):
        """powerOff(self) -> int"""
        return apply(_AriaPy.ArP2Arm_powerOff, args)

    def requestInfo(*args):
        """requestInfo(self) -> int"""
        return apply(_AriaPy.ArP2Arm_requestInfo, args)

    def requestStatus(*args):
        """requestStatus(self, StatusType status) -> int"""
        return apply(_AriaPy.ArP2Arm_requestStatus, args)

    def requestInit(*args):
        """requestInit(self) -> int"""
        return apply(_AriaPy.ArP2Arm_requestInit, args)

    def checkArm(*args):
        """
        checkArm(self, bool waitForResponse=True) -> int
        checkArm(self) -> int
        """
        return apply(_AriaPy.ArP2Arm_checkArm, args)

    def home(*args):
        """
        home(self, int joint=-1) -> int
        home(self) -> int
        """
        return apply(_AriaPy.ArP2Arm_home, args)

    def park(*args):
        """park(self) -> int"""
        return apply(_AriaPy.ArP2Arm_park, args)

    def moveTo(*args):
        """
        moveTo(self, int joint, float pos, unsigned char vel=0) -> int
        moveTo(self, int joint, float pos) -> int
        """
        return apply(_AriaPy.ArP2Arm_moveTo, args)

    def moveToTicks(*args):
        """moveToTicks(self, int joint, unsigned char pos) -> int"""
        return apply(_AriaPy.ArP2Arm_moveToTicks, args)

    def moveStep(*args):
        """
        moveStep(self, int joint, float pos, unsigned char vel=0) -> int
        moveStep(self, int joint, float pos) -> int
        """
        return apply(_AriaPy.ArP2Arm_moveStep, args)

    def moveStepTicks(*args):
        """moveStepTicks(self, int joint, signed char pos) -> int"""
        return apply(_AriaPy.ArP2Arm_moveStepTicks, args)

    def moveVel(*args):
        """moveVel(self, int joint, int vel) -> int"""
        return apply(_AriaPy.ArP2Arm_moveVel, args)

    def stop(*args):
        """stop(self) -> int"""
        return apply(_AriaPy.ArP2Arm_stop, args)

    def setAutoParkTimer(*args):
        """setAutoParkTimer(self, int waitSecs) -> int"""
        return apply(_AriaPy.ArP2Arm_setAutoParkTimer, args)

    def setGripperParkTimer(*args):
        """setGripperParkTimer(self, int waitSecs) -> int"""
        return apply(_AriaPy.ArP2Arm_setGripperParkTimer, args)

    def setStoppedCB(*args):
        """setStoppedCB(self, ArFunctor func)"""
        return apply(_AriaPy.ArP2Arm_setStoppedCB, args)

    def setPacketCB(*args):
        """setPacketCB(self, ArFunctor1<(ArP2Arm::PacketType)> func)"""
        return apply(_AriaPy.ArP2Arm_setPacketCB, args)

    def getArmVersion(*args):
        """getArmVersion(self) -> std::string"""
        return apply(_AriaPy.ArP2Arm_getArmVersion, args)

    def getJointPos(*args):
        """getJointPos(self, int joint) -> float"""
        return apply(_AriaPy.ArP2Arm_getJointPos, args)

    def getJointPosTicks(*args):
        """getJointPosTicks(self, int joint) -> unsigned char"""
        return apply(_AriaPy.ArP2Arm_getJointPosTicks, args)

    def getMoving(*args):
        """
        getMoving(self, int joint=-1) -> bool
        getMoving(self) -> bool
        """
        return apply(_AriaPy.ArP2Arm_getMoving, args)

    def isPowered(*args):
        """isPowered(self) -> bool"""
        return apply(_AriaPy.ArP2Arm_isPowered, args)

    def isGood(*args):
        """isGood(self) -> bool"""
        return apply(_AriaPy.ArP2Arm_isGood, args)

    def getStatus(*args):
        """getStatus(self) -> int"""
        return apply(_AriaPy.ArP2Arm_getStatus, args)

    def getLastStatusTime(*args):
        """getLastStatusTime(self) -> ArTime"""
        return apply(_AriaPy.ArP2Arm_getLastStatusTime, args)

    def getRobot(*args):
        """getRobot(self) -> ArRobot"""
        return apply(_AriaPy.ArP2Arm_getRobot, args)

    def getJoint(*args):
        """getJoint(self, int joint) -> P2ArmJoint"""
        return apply(_AriaPy.ArP2Arm_getJoint, args)

    def convertDegToTicks(*args):
        """convertDegToTicks(self, int joint, float pos, unsigned char ticks) -> bool"""
        return apply(_AriaPy.ArP2Arm_convertDegToTicks, args)

    def convertTicksToDeg(*args):
        """convertTicksToDeg(self, int joint, unsigned char pos, float degrees) -> bool"""
        return apply(_AriaPy.ArP2Arm_convertTicksToDeg, args)

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"""
    __swig_setmethods__ = {}
    for _s in [ArResolver]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPriorityResolver, name, value)
    __swig_getmethods__ = {}
    for _s in [ArResolver]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArPriorityResolver, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArPriorityResolver"""
        this = apply(_AriaPy.new_ArPriorityResolver, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArPriorityResolver
    __del__ = lambda self : None;
    def resolve(*args):
        """
        resolve(self, ActionMap actions, ArRobot robot, bool logActions=False) -> ArActionDesired
        resolve(self, ActionMap actions, ArRobot robot) -> ArActionDesired
        """
        return apply(_AriaPy.ArPriorityResolver_resolve, args)

ArPriorityResolver_swigregister = _AriaPy.ArPriorityResolver_swigregister
ArPriorityResolver_swigregister(ArPriorityResolver)

class ArRangeBuffer:
    """Proxy of C++ ArRangeBuffer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRangeBuffer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArRangeBuffer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, int size) -> ArRangeBuffer"""
        this = apply(_AriaPy.new_ArRangeBuffer, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRangeBuffer
    __del__ = lambda self : None;
    def getSize(*args):
        """getSize(self) -> size_t"""
        return apply(_AriaPy.ArRangeBuffer_getSize, args)

    def setSize(*args):
        """setSize(self, size_t size)"""
        return apply(_AriaPy.ArRangeBuffer_setSize, args)

    def getPoseTaken(*args):
        """getPoseTaken(self) -> ArPose"""
        return apply(_AriaPy.ArRangeBuffer_getPoseTaken, args)

    def setPoseTaken(*args):
        """setPoseTaken(self, ArPose p)"""
        return apply(_AriaPy.ArRangeBuffer_setPoseTaken, args)

    def getEncoderPoseTaken(*args):
        """getEncoderPoseTaken(self) -> ArPose"""
        return apply(_AriaPy.ArRangeBuffer_getEncoderPoseTaken, args)

    def setEncoderPoseTaken(*args):
        """setEncoderPoseTaken(self, ArPose p)"""
        return apply(_AriaPy.ArRangeBuffer_setEncoderPoseTaken, args)

    def addReading(*args):
        """addReading(self, double x, double y)"""
        return apply(_AriaPy.ArRangeBuffer_addReading, args)

    def addReadingConditional(*args):
        """addReadingConditional(self, double x, double y, double closeDist)"""
        return apply(_AriaPy.ArRangeBuffer_addReadingConditional, args)

    def beginInvalidationSweep(*args):
        """beginInvalidationSweep(self)"""
        return apply(_AriaPy.ArRangeBuffer_beginInvalidationSweep, args)

    def invalidateReading(*args):
        """invalidateReading(self, std::list<(p.ArPoseWithTime,std::allocator<(p.ArPoseWithTime)>)>::iterator readingIt)"""
        return apply(_AriaPy.ArRangeBuffer_invalidateReading, args)

    def endInvalidationSweep(*args):
        """endInvalidationSweep(self)"""
        return apply(_AriaPy.ArRangeBuffer_endInvalidationSweep, args)

    def getBuffer(*args):
        """getBuffer(self) -> ArPoseWithTimePtrList"""
        return apply(_AriaPy.ArRangeBuffer_getBuffer, args)

    def getClosestPolar(*args):
        """
        getClosestPolar(self, double startAngle, double endAngle, ArPose position, 
            unsigned int maxRange, double angle=None) -> double
        getClosestPolar(self, double startAngle, double endAngle, ArPose position, 
            unsigned int maxRange) -> double
        """
        return apply(_AriaPy.ArRangeBuffer_getClosestPolar, args)

    def getClosestBox(*args):
        """
        getClosestBox(self, double x1, double y1, double x2, double y2, ArPose position, 
            unsigned int maxRange, ArPose readingPos=None, 
            ArPose targetPose=ArPose(0, 0, 0)) -> double
        getClosestBox(self, double x1, double y1, double x2, double y2, ArPose position, 
            unsigned int maxRange, ArPose readingPos=None) -> double
        getClosestBox(self, double x1, double y1, double x2, double y2, ArPose position, 
            unsigned int maxRange) -> double
        """
        return apply(_AriaPy.ArRangeBuffer_getClosestBox, args)

    def applyTransform(*args):
        """applyTransform(self, ArTransform trans)"""
        return apply(_AriaPy.ArRangeBuffer_applyTransform, args)

    def clear(*args):
        """clear(self)"""
        return apply(_AriaPy.ArRangeBuffer_clear, args)

    def clearOlderThan(*args):
        """clearOlderThan(self, int milliSeconds)"""
        return apply(_AriaPy.ArRangeBuffer_clearOlderThan, args)

    def clearOlderThanSeconds(*args):
        """clearOlderThanSeconds(self, int seconds)"""
        return apply(_AriaPy.ArRangeBuffer_clearOlderThanSeconds, args)

    def reset(*args):
        """reset(self)"""
        return apply(_AriaPy.ArRangeBuffer_reset, args)

    def beginRedoBuffer(*args):
        """beginRedoBuffer(self)"""
        return apply(_AriaPy.ArRangeBuffer_beginRedoBuffer, args)

    def redoReading(*args):
        """redoReading(self, double x, double y)"""
        return apply(_AriaPy.ArRangeBuffer_redoReading, args)

    def endRedoBuffer(*args):
        """endRedoBuffer(self)"""
        return apply(_AriaPy.ArRangeBuffer_endRedoBuffer, args)

    def getBufferAsVector(*args):
        """getBufferAsVector(self) -> ArPoseWithTimeVector"""
        return apply(_AriaPy.ArRangeBuffer_getBufferAsVector, args)

    __swig_getmethods__["getClosestPolarInList"] = lambda x: _AriaPy.ArRangeBuffer_getClosestPolarInList
    __swig_getmethods__["getClosestBoxInList"] = lambda x: _AriaPy.ArRangeBuffer_getClosestBoxInList
ArRangeBuffer_swigregister = _AriaPy.ArRangeBuffer_swigregister
ArRangeBuffer_swigregister(ArRangeBuffer)

def ArRangeBuffer_getClosestPolarInList(*args):
  """
    ArRangeBuffer_getClosestPolarInList(double startAngle, double endAngle, ArPose position, 
        unsigned int maxRange, double angle, ArPoseWithTimePtrList buffer) -> double
    """
  return apply(_AriaPy.ArRangeBuffer_getClosestPolarInList, args)

def ArRangeBuffer_getClosestBoxInList(*args):
  """
    ArRangeBuffer_getClosestBoxInList(double x1, double y1, double x2, double y2, ArPose position, 
        unsigned int maxRange, ArPose readingPos, 
        ArPose targetPose, ArPoseWithTimePtrList buffer) -> double
    """
  return apply(_AriaPy.ArRangeBuffer_getClosestBoxInList, args)

class ArRatioInputJoydrive:
    """Proxy of C++ ArRatioInputJoydrive class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRatioInputJoydrive, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArRatioInputJoydrive, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, ArActionRatioInput input, int priority=50, 
            bool stopIfNoButtonPressed=False, bool useOSCalForJoystick=True) -> ArRatioInputJoydrive
        __init__(self, ArRobot robot, ArActionRatioInput input, int priority=50, 
            bool stopIfNoButtonPressed=False) -> ArRatioInputJoydrive
        __init__(self, ArRobot robot, ArActionRatioInput input, int priority=50) -> ArRatioInputJoydrive
        __init__(self, ArRobot robot, ArActionRatioInput input) -> ArRatioInputJoydrive
        """
        this = apply(_AriaPy.new_ArRatioInputJoydrive, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRatioInputJoydrive
    __del__ = lambda self : None;
    def joystickInited(*args):
        """joystickInited(self) -> bool"""
        return apply(_AriaPy.ArRatioInputJoydrive_joystickInited, args)

    def setStopIfNoButtonPressed(*args):
        """setStopIfNoButtonPressed(self, bool stopIfNoButtonPressed)"""
        return apply(_AriaPy.ArRatioInputJoydrive_setStopIfNoButtonPressed, args)

    def getStopIfNoButtonPressed(*args):
        """getStopIfNoButtonPressed(self) -> bool"""
        return apply(_AriaPy.ArRatioInputJoydrive_getStopIfNoButtonPressed, args)

    def setUseOSCal(*args):
        """setUseOSCal(self, bool useOSCal)"""
        return apply(_AriaPy.ArRatioInputJoydrive_setUseOSCal, args)

    def getUseOSCal(*args):
        """getUseOSCal(self) -> bool"""
        return apply(_AriaPy.ArRatioInputJoydrive_getUseOSCal, args)

    def getJoyHandler(*args):
        """getJoyHandler(self) -> ArJoyHandler"""
        return apply(_AriaPy.ArRatioInputJoydrive_getJoyHandler, args)

ArRatioInputJoydrive_swigregister = _AriaPy.ArRatioInputJoydrive_swigregister
ArRatioInputJoydrive_swigregister(ArRatioInputJoydrive)

class ArRatioInputKeydrive:
    """Proxy of C++ ArRatioInputKeydrive class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRatioInputKeydrive, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArRatioInputKeydrive, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, ArActionRatioInput input, int priority=25, 
            double velIncrement=5) -> ArRatioInputKeydrive
        __init__(self, ArRobot robot, ArActionRatioInput input, int priority=25) -> ArRatioInputKeydrive
        __init__(self, ArRobot robot, ArActionRatioInput input) -> ArRatioInputKeydrive
        """
        this = apply(_AriaPy.new_ArRatioInputKeydrive, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRatioInputKeydrive
    __del__ = lambda self : None;
    def takeKeys(*args):
        """takeKeys(self)"""
        return apply(_AriaPy.ArRatioInputKeydrive_takeKeys, args)

    def giveUpKeys(*args):
        """giveUpKeys(self)"""
        return apply(_AriaPy.ArRatioInputKeydrive_giveUpKeys, args)

    def up(*args):
        """up(self)"""
        return apply(_AriaPy.ArRatioInputKeydrive_up, args)

    def down(*args):
        """down(self)"""
        return apply(_AriaPy.ArRatioInputKeydrive_down, args)

    def z(*args):
        """z(self)"""
        return apply(_AriaPy.ArRatioInputKeydrive_z, args)

    def x(*args):
        """x(self)"""
        return apply(_AriaPy.ArRatioInputKeydrive_x, args)

    def left(*args):
        """left(self)"""
        return apply(_AriaPy.ArRatioInputKeydrive_left, args)

    def right(*args):
        """right(self)"""
        return apply(_AriaPy.ArRatioInputKeydrive_right, args)

    def space(*args):
        """space(self)"""
        return apply(_AriaPy.ArRatioInputKeydrive_space, args)

    def getFireCB(*args):
        """getFireCB(self) -> ArFunctor"""
        return apply(_AriaPy.ArRatioInputKeydrive_getFireCB, args)

ArRatioInputKeydrive_swigregister = _AriaPy.ArRatioInputKeydrive_swigregister
ArRatioInputKeydrive_swigregister(ArRatioInputKeydrive)

class ArRatioInputRobotJoydrive:
    """Proxy of C++ ArRatioInputRobotJoydrive class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRatioInputRobotJoydrive, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArRatioInputRobotJoydrive, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, ArActionRatioInput input, int priority=75, 
            bool requireDeadmanPushed=True) -> ArRatioInputRobotJoydrive
        __init__(self, ArRobot robot, ArActionRatioInput input, int priority=75) -> ArRatioInputRobotJoydrive
        __init__(self, ArRobot robot, ArActionRatioInput input) -> ArRatioInputRobotJoydrive
        """
        this = apply(_AriaPy.new_ArRatioInputRobotJoydrive, args)
        try: self.this.append(this)
        except: 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"""
    __swig_setmethods__ = {}
    for _s in [ArASyncTask]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRecurrentTask, name, value)
    __swig_getmethods__ = {}
    for _s in [ArASyncTask]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRecurrentTask, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArRecurrentTask
    __del__ = lambda self : None;
    def task(*args):
        """task(self)"""
        return apply(_AriaPy.ArRecurrentTask_task, args)

    def go(*args):
        """go(self)"""
        return apply(_AriaPy.ArRecurrentTask_go, args)

    def done(*args):
        """done(self) -> int"""
        return apply(_AriaPy.ArRecurrentTask_done, args)

    def reset(*args):
        """reset(self)"""
        return apply(_AriaPy.ArRecurrentTask_reset, args)

    def kill(*args):
        """kill(self)"""
        return apply(_AriaPy.ArRecurrentTask_kill, args)

    def runThread(*args):
        """runThread(self, void ptr) -> void"""
        return apply(_AriaPy.ArRecurrentTask_runThread, args)

ArRecurrentTask_swigregister = _AriaPy.ArRecurrentTask_swigregister
ArRecurrentTask_swigregister(ArRecurrentTask)

class ArRobot:
    """Proxy of C++ ArRobot class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRobot, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArRobot, name)
    __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
    def __init__(self, *args): 
        """
        __init__(self, char name=None, bool ignored=True, bool doSigHandle=True, 
            bool normalInit=True, bool addAriaExitCallback=True) -> ArRobot
        __init__(self, char name=None, bool ignored=True, bool doSigHandle=True, 
            bool normalInit=True) -> ArRobot
        __init__(self, char name=None, bool ignored=True, bool doSigHandle=True) -> ArRobot
        __init__(self, char name=None, bool ignored=True) -> ArRobot
        __init__(self, char name=None) -> ArRobot
        __init__(self) -> ArRobot
        """
        this = apply(_AriaPy.new_ArRobot, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobot
    __del__ = lambda self : None;
    def run(*args):
        """run(self, bool stopRunIfNotConnected)"""
        return apply(_AriaPy.ArRobot_run, args)

    def runAsync(*args):
        """runAsync(self, bool stopRunIfNotConnected)"""
        return apply(_AriaPy.ArRobot_runAsync, args)

    def isRunning(*args):
        """isRunning(self) -> bool"""
        return apply(_AriaPy.ArRobot_isRunning, args)

    def stopRunning(*args):
        """
        stopRunning(self, bool doDisconnect=True)
        stopRunning(self)
        """
        return apply(_AriaPy.ArRobot_stopRunning, args)

    def setDeviceConnection(*args):
        """setDeviceConnection(self, ArDeviceConnection connection)"""
        return apply(_AriaPy.ArRobot_setDeviceConnection, args)

    def getDeviceConnection(*args):
        """getDeviceConnection(self) -> ArDeviceConnection"""
        return apply(_AriaPy.ArRobot_getDeviceConnection, args)

    def isConnected(*args):
        """isConnected(self) -> bool"""
        return apply(_AriaPy.ArRobot_isConnected, args)

    def blockingConnect(*args):
        """blockingConnect(self) -> bool"""
        return apply(_AriaPy.ArRobot_blockingConnect, args)

    def asyncConnect(*args):
        """asyncConnect(self) -> bool"""
        return apply(_AriaPy.ArRobot_asyncConnect, args)

    def disconnect(*args):
        """disconnect(self) -> bool"""
        return apply(_AriaPy.ArRobot_disconnect, args)

    def clearDirectMotion(*args):
        """clearDirectMotion(self)"""
        return apply(_AriaPy.ArRobot_clearDirectMotion, args)

    def isDirectMotion(*args):
        """isDirectMotion(self) -> bool"""
        return apply(_AriaPy.ArRobot_isDirectMotion, args)

    def stopStateReflection(*args):
        """stopStateReflection(self)"""
        return apply(_AriaPy.ArRobot_stopStateReflection, args)

    def enableMotors(*args):
        """enableMotors(self)"""
        return apply(_AriaPy.ArRobot_enableMotors, args)

    def disableMotors(*args):
        """disableMotors(self)"""
        return apply(_AriaPy.ArRobot_disableMotors, args)

    def enableSonar(*args):
        """enableSonar(self)"""
        return apply(_AriaPy.ArRobot_enableSonar, args)

    def disableSonar(*args):
        """disableSonar(self)"""
        return apply(_AriaPy.ArRobot_disableSonar, args)

    def stop(*args):
        """stop(self)"""
        return apply(_AriaPy.ArRobot_stop, args)

    def setVel(*args):
        """setVel(self, double velocity)"""
        return apply(_AriaPy.ArRobot_setVel, args)

    def setVel2(*args):
        """setVel2(self, double leftVelocity, double rightVelocity)"""
        return apply(_AriaPy.ArRobot_setVel2, args)

    def move(*args):
        """move(self, double distance)"""
        return apply(_AriaPy.ArRobot_move, args)

    def isMoveDone(*args):
        """
        isMoveDone(self, double delta=0.0) -> bool
        isMoveDone(self) -> bool
        """
        return apply(_AriaPy.ArRobot_isMoveDone, args)

    def setMoveDoneDist(*args):
        """setMoveDoneDist(self, double dist)"""
        return apply(_AriaPy.ArRobot_setMoveDoneDist, args)

    def getMoveDoneDist(*args):
        """getMoveDoneDist(self) -> double"""
        return apply(_AriaPy.ArRobot_getMoveDoneDist, args)

    def setHeading(*args):
        """setHeading(self, double heading)"""
        return apply(_AriaPy.ArRobot_setHeading, args)

    def setRotVel(*args):
        """setRotVel(self, double velocity)"""
        return apply(_AriaPy.ArRobot_setRotVel, args)

    def setDeltaHeading(*args):
        """setDeltaHeading(self, double deltaHeading)"""
        return apply(_AriaPy.ArRobot_setDeltaHeading, args)

    def isHeadingDone(*args):
        """
        isHeadingDone(self, double delta=0.0) -> bool
        isHeadingDone(self) -> bool
        """
        return apply(_AriaPy.ArRobot_isHeadingDone, args)

    def setHeadingDoneDiff(*args):
        """setHeadingDoneDiff(self, double degrees)"""
        return apply(_AriaPy.ArRobot_setHeadingDoneDiff, args)

    def getHeadingDoneDiff(*args):
        """getHeadingDoneDiff(self) -> double"""
        return apply(_AriaPy.ArRobot_getHeadingDoneDiff, args)

    def setLatVel(*args):
        """setLatVel(self, double latVelocity)"""
        return apply(_AriaPy.ArRobot_setLatVel, args)

    def setDirectMotionPrecedenceTime(*args):
        """setDirectMotionPrecedenceTime(self, int mSec)"""
        return apply(_AriaPy.ArRobot_setDirectMotionPrecedenceTime, args)

    def getDirectMotionPrecedenceTime(*args):
        """getDirectMotionPrecedenceTime(self) -> unsigned int"""
        return apply(_AriaPy.ArRobot_getDirectMotionPrecedenceTime, args)

    def com(*args):
        """com(self, unsigned char command) -> bool"""
        return apply(_AriaPy.ArRobot_com, args)

    def comInt(*args):
        """comInt(self, unsigned char command, short argument) -> bool"""
        return apply(_AriaPy.ArRobot_comInt, args)

    def com2Bytes(*args):
        """com2Bytes(self, unsigned char command, char high, char low) -> bool"""
        return apply(_AriaPy.ArRobot_com2Bytes, args)

    def comStr(*args):
        """comStr(self, unsigned char command, char argument) -> bool"""
        return apply(_AriaPy.ArRobot_comStr, args)

    def comStrN(*args):
        """comStrN(self, unsigned char command, char str, int size) -> bool"""
        return apply(_AriaPy.ArRobot_comStrN, args)

    def comDataN(*args):
        """comDataN(self, unsigned char command, char data, int size) -> bool"""
        return apply(_AriaPy.ArRobot_comDataN, args)

    def getRobotName(*args):
        """getRobotName(self) -> char"""
        return apply(_AriaPy.ArRobot_getRobotName, args)

    def getRobotType(*args):
        """getRobotType(self) -> char"""
        return apply(_AriaPy.ArRobot_getRobotType, args)

    def getRobotSubType(*args):
        """getRobotSubType(self) -> char"""
        return apply(_AriaPy.ArRobot_getRobotSubType, args)

    def getAbsoluteMaxTransVel(*args):
        """getAbsoluteMaxTransVel(self) -> double"""
        return apply(_AriaPy.ArRobot_getAbsoluteMaxTransVel, args)

    def setAbsoluteMaxTransVel(*args):
        """setAbsoluteMaxTransVel(self, double maxVel) -> bool"""
        return apply(_AriaPy.ArRobot_setAbsoluteMaxTransVel, args)

    def getAbsoluteMaxTransAccel(*args):
        """getAbsoluteMaxTransAccel(self) -> double"""
        return apply(_AriaPy.ArRobot_getAbsoluteMaxTransAccel, args)

    def setAbsoluteMaxTransAccel(*args):
        """setAbsoluteMaxTransAccel(self, double maxAccel) -> bool"""
        return apply(_AriaPy.ArRobot_setAbsoluteMaxTransAccel, args)

    def getAbsoluteMaxTransDecel(*args):
        """getAbsoluteMaxTransDecel(self) -> double"""
        return apply(_AriaPy.ArRobot_getAbsoluteMaxTransDecel, args)

    def setAbsoluteMaxTransDecel(*args):
        """setAbsoluteMaxTransDecel(self, double maxDecel) -> bool"""
        return apply(_AriaPy.ArRobot_setAbsoluteMaxTransDecel, args)

    def getAbsoluteMaxRotVel(*args):
        """getAbsoluteMaxRotVel(self) -> double"""
        return apply(_AriaPy.ArRobot_getAbsoluteMaxRotVel, args)

    def setAbsoluteMaxRotVel(*args):
        """setAbsoluteMaxRotVel(self, double maxVel) -> bool"""
        return apply(_AriaPy.ArRobot_setAbsoluteMaxRotVel, args)

    def getAbsoluteMaxRotAccel(*args):
        """getAbsoluteMaxRotAccel(self) -> double"""
        return apply(_AriaPy.ArRobot_getAbsoluteMaxRotAccel, args)

    def setAbsoluteMaxRotAccel(*args):
        """setAbsoluteMaxRotAccel(self, double maxAccel) -> bool"""
        return apply(_AriaPy.ArRobot_setAbsoluteMaxRotAccel, args)

    def getAbsoluteMaxRotDecel(*args):
        """getAbsoluteMaxRotDecel(self) -> double"""
        return apply(_AriaPy.ArRobot_getAbsoluteMaxRotDecel, args)

    def setAbsoluteMaxRotDecel(*args):
        """setAbsoluteMaxRotDecel(self, double maxDecel) -> bool"""
        return apply(_AriaPy.ArRobot_setAbsoluteMaxRotDecel, args)

    def getAbsoluteMaxLatVel(*args):
        """getAbsoluteMaxLatVel(self) -> double"""
        return apply(_AriaPy.ArRobot_getAbsoluteMaxLatVel, args)

    def setAbsoluteMaxLatVel(*args):
        """setAbsoluteMaxLatVel(self, double maxVel) -> bool"""
        return apply(_AriaPy.ArRobot_setAbsoluteMaxLatVel, args)

    def getAbsoluteMaxLatAccel(*args):
        """getAbsoluteMaxLatAccel(self) -> double"""
        return apply(_AriaPy.ArRobot_getAbsoluteMaxLatAccel, args)

    def setAbsoluteMaxLatAccel(*args):
        """setAbsoluteMaxLatAccel(self, double maxAccel) -> bool"""
        return apply(_AriaPy.ArRobot_setAbsoluteMaxLatAccel, args)

    def getAbsoluteMaxLatDecel(*args):
        """getAbsoluteMaxLatDecel(self) -> double"""
        return apply(_AriaPy.ArRobot_getAbsoluteMaxLatDecel, args)

    def setAbsoluteMaxLatDecel(*args):
        """setAbsoluteMaxLatDecel(self, double maxDecel) -> bool"""
        return apply(_AriaPy.ArRobot_setAbsoluteMaxLatDecel, args)

    def getPose(*args):
        """getPose(self) -> ArPose"""
        return apply(_AriaPy.ArRobot_getPose, args)

    def getX(*args):
        """getX(self) -> double"""
        return apply(_AriaPy.ArRobot_getX, args)

    def getY(*args):
        """getY(self) -> double"""
        return apply(_AriaPy.ArRobot_getY, args)

    def getTh(*args):
        """getTh(self) -> double"""
        return apply(_AriaPy.ArRobot_getTh, args)

    def findDistanceTo(*args):
        """findDistanceTo(self, ArPose pose) -> double"""
        return apply(_AriaPy.ArRobot_findDistanceTo, args)

    def findAngleTo(*args):
        """findAngleTo(self, ArPose pose) -> double"""
        return apply(_AriaPy.ArRobot_findAngleTo, args)

    def findDeltaHeadingTo(*args):
        """findDeltaHeadingTo(self, ArPose pose) -> double"""
        return apply(_AriaPy.ArRobot_findDeltaHeadingTo, args)

    def getVel(*args):
        """getVel(self) -> double"""
        return apply(_AriaPy.ArRobot_getVel, args)

    def getRotVel(*args):
        """getRotVel(self) -> double"""
        return apply(_AriaPy.ArRobot_getRotVel, args)

    def getLatVel(*args):
        """getLatVel(self) -> double"""
        return apply(_AriaPy.ArRobot_getLatVel, args)

    def hasLatVel(*args):
        """hasLatVel(self) -> bool"""
        return apply(_AriaPy.ArRobot_hasLatVel, args)

    def getRobotRadius(*args):
        """getRobotRadius(self) -> double"""
        return apply(_AriaPy.ArRobot_getRobotRadius, args)

    def getRobotWidth(*args):
        """getRobotWidth(self) -> double"""
        return apply(_AriaPy.ArRobot_getRobotWidth, args)

    def getRobotLength(*args):
        """getRobotLength(self) -> double"""
        return apply(_AriaPy.ArRobot_getRobotLength, args)

    def getRobotLengthFront(*args):
        """getRobotLengthFront(self) -> double"""
        return apply(_AriaPy.ArRobot_getRobotLengthFront, args)

    def getRobotLengthRear(*args):
        """getRobotLengthRear(self) -> double"""
        return apply(_AriaPy.ArRobot_getRobotLengthRear, args)

    def getRobotDiagonal(*args):
        """getRobotDiagonal(self) -> double"""
        return apply(_AriaPy.ArRobot_getRobotDiagonal, args)

    def getBatteryVoltage(*args):
        """getBatteryVoltage(self) -> double"""
        return apply(_AriaPy.ArRobot_getBatteryVoltage, args)

    def getBatteryVoltageNow(*args):
        """getBatteryVoltageNow(self) -> double"""
        return apply(_AriaPy.ArRobot_getBatteryVoltageNow, args)

    def getRealBatteryVoltage(*args):
        """getRealBatteryVoltage(self) -> double"""
        return apply(_AriaPy.ArRobot_getRealBatteryVoltage, args)

    def getRealBatteryVoltageNow(*args):
        """getRealBatteryVoltageNow(self) -> double"""
        return apply(_AriaPy.ArRobot_getRealBatteryVoltageNow, args)

    def haveStateOfCharge(*args):
        """haveStateOfCharge(self) -> bool"""
        return apply(_AriaPy.ArRobot_haveStateOfCharge, args)

    def getStateOfCharge(*args):
        """getStateOfCharge(self) -> double"""
        return apply(_AriaPy.ArRobot_getStateOfCharge, args)

    def getStateOfChargeSetTime(*args):
        """getStateOfChargeSetTime(self) -> ArTime"""
        return apply(_AriaPy.ArRobot_getStateOfChargeSetTime, args)

    def getStateOfChargeLow(*args):
        """getStateOfChargeLow(self) -> double"""
        return apply(_AriaPy.ArRobot_getStateOfChargeLow, args)

    def getStateOfChargeShutdown(*args):
        """getStateOfChargeShutdown(self) -> double"""
        return apply(_AriaPy.ArRobot_getStateOfChargeShutdown, args)

    def getLeftVel(*args):
        """getLeftVel(self) -> double"""
        return apply(_AriaPy.ArRobot_getLeftVel, args)

    def getRightVel(*args):
        """getRightVel(self) -> double"""
        return apply(_AriaPy.ArRobot_getRightVel, args)

    def getStallValue(*args):
        """getStallValue(self) -> int"""
        return apply(_AriaPy.ArRobot_getStallValue, args)

    def isLeftMotorStalled(*args):
        """isLeftMotorStalled(self) -> bool"""
        return apply(_AriaPy.ArRobot_isLeftMotorStalled, args)

    def isRightMotorStalled(*args):
        """isRightMotorStalled(self) -> bool"""
        return apply(_AriaPy.ArRobot_isRightMotorStalled, args)

    def getControl(*args):
        """getControl(self) -> double"""
        return apply(_AriaPy.ArRobot_getControl, args)

    def getFlags(*args):
        """getFlags(self) -> int"""
        return apply(_AriaPy.ArRobot_getFlags, args)

    def getFaultFlags(*args):
        """getFaultFlags(self) -> int"""
        return apply(_AriaPy.ArRobot_getFaultFlags, args)

    def hasFaultFlags(*args):
        """hasFaultFlags(self) -> bool"""
        return apply(_AriaPy.ArRobot_hasFaultFlags, args)

    def areMotorsEnabled(*args):
        """areMotorsEnabled(self) -> bool"""
        return apply(_AriaPy.ArRobot_areMotorsEnabled, args)

    def areSonarsEnabled(*args):
        """areSonarsEnabled(self) -> bool"""
        return apply(_AriaPy.ArRobot_areSonarsEnabled, args)

    def isEStopPressed(*args):
        """isEStopPressed(self) -> bool"""
        return apply(_AriaPy.ArRobot_isEStopPressed, args)

    def getCompass(*args):
        """getCompass(self) -> double"""
        return apply(_AriaPy.ArRobot_getCompass, args)

    def getAnalogPortSelected(*args):
        """getAnalogPortSelected(self) -> int"""
        return apply(_AriaPy.ArRobot_getAnalogPortSelected, args)

    def getAnalog(*args):
        """getAnalog(self) -> unsigned char"""
        return apply(_AriaPy.ArRobot_getAnalog, args)

    def getDigIn(*args):
        """getDigIn(self) -> unsigned char"""
        return apply(_AriaPy.ArRobot_getDigIn, args)

    def getDigOut(*args):
        """getDigOut(self) -> unsigned char"""
        return apply(_AriaPy.ArRobot_getDigOut, args)

    def getChargeState(*args):
        """getChargeState(self) -> int"""
        return apply(_AriaPy.ArRobot_getChargeState, args)

    def getIOAnalogSize(*args):
        """getIOAnalogSize(self) -> int"""
        return apply(_AriaPy.ArRobot_getIOAnalogSize, args)

    def getIODigInSize(*args):
        """getIODigInSize(self) -> int"""
        return apply(_AriaPy.ArRobot_getIODigInSize, args)

    def getIODigOutSize(*args):
        """getIODigOutSize(self) -> int"""
        return apply(_AriaPy.ArRobot_getIODigOutSize, args)

    def getIOAnalog(*args):
        """getIOAnalog(self, int num) -> int"""
        return apply(_AriaPy.ArRobot_getIOAnalog, args)

    def getIOAnalogVoltage(*args):
        """getIOAnalogVoltage(self, int num) -> double"""
        return apply(_AriaPy.ArRobot_getIOAnalogVoltage, args)

    def getIODigIn(*args):
        """getIODigIn(self, int num) -> unsigned char"""
        return apply(_AriaPy.ArRobot_getIODigIn, args)

    def getIODigOut(*args):
        """getIODigOut(self, int num) -> unsigned char"""
        return apply(_AriaPy.ArRobot_getIODigOut, args)

    def hasTableSensingIR(*args):
        """hasTableSensingIR(self) -> bool"""
        return apply(_AriaPy.ArRobot_hasTableSensingIR, args)

    def isLeftTableSensingIRTriggered(*args):
        """isLeftTableSensingIRTriggered(self) -> bool"""
        return apply(_AriaPy.ArRobot_isLeftTableSensingIRTriggered, args)

    def isRightTableSensingIRTriggered(*args):
        """isRightTableSensingIRTriggered(self) -> bool"""
        return apply(_AriaPy.ArRobot_isRightTableSensingIRTriggered, args)

    def isLeftBreakBeamTriggered(*args):
        """isLeftBreakBeamTriggered(self) -> bool"""
        return apply(_AriaPy.ArRobot_isLeftBreakBeamTriggered, args)

    def isRightBreakBeamTriggered(*args):
        """isRightBreakBeamTriggered(self) -> bool"""
        return apply(_AriaPy.ArRobot_isRightBreakBeamTriggered, args)

    def getIOPacketTime(*args):
        """getIOPacketTime(self) -> ArTime"""
        return apply(_AriaPy.ArRobot_getIOPacketTime, args)

    def getEstop(*args):
        """getEstop(self) -> bool"""
        return apply(_AriaPy.ArRobot_getEstop, args)

    def hasFrontBumpers(*args):
        """hasFrontBumpers(self) -> bool"""
        return apply(_AriaPy.ArRobot_hasFrontBumpers, args)

    def getNumFrontBumpers(*args):
        """getNumFrontBumpers(self) -> unsigned int"""
        return apply(_AriaPy.ArRobot_getNumFrontBumpers, args)

    def hasRearBumpers(*args):
        """hasRearBumpers(self) -> bool"""
        return apply(_AriaPy.ArRobot_hasRearBumpers, args)

    def getNumRearBumpers(*args):
        """getNumRearBumpers(self) -> unsigned int"""
        return apply(_AriaPy.ArRobot_getNumRearBumpers, args)

    def getEncoderPose(*args):
        """getEncoderPose(self) -> ArPose"""
        return apply(_AriaPy.ArRobot_getEncoderPose, args)

    def isTryingToMove(*args):
        """isTryingToMove(self) -> bool"""
        return apply(_AriaPy.ArRobot_isTryingToMove, args)

    def forceTryingToMove(*args):
        """forceTryingToMove(self)"""
        return apply(_AriaPy.ArRobot_forceTryingToMove, args)

    def getMotorPacCount(*args):
        """getMotorPacCount(self) -> int"""
        return apply(_AriaPy.ArRobot_getMotorPacCount, args)

    def getSonarPacCount(*args):
        """getSonarPacCount(self) -> int"""
        return apply(_AriaPy.ArRobot_getSonarPacCount, args)

    def getSonarRange(*args):
        """getSonarRange(self, int num) -> int"""
        return apply(_AriaPy.ArRobot_getSonarRange, args)

    def isSonarNew(*args):
        """isSonarNew(self, int num) -> bool"""
        return apply(_AriaPy.ArRobot_isSonarNew, args)

    def getNumSonar(*args):
        """getNumSonar(self) -> int"""
        return apply(_AriaPy.ArRobot_getNumSonar, args)

    def getSonarReading(*args):
        """getSonarReading(self, int num) -> ArSensorReading"""
        return apply(_AriaPy.ArRobot_getSonarReading, args)

    def getClosestSonarRange(*args):
        """getClosestSonarRange(self, double startAngle, double endAngle) -> int"""
        return apply(_AriaPy.ArRobot_getClosestSonarRange, args)

    def getClosestSonarNumber(*args):
        """getClosestSonarNumber(self, double startAngle, double endAngle) -> int"""
        return apply(_AriaPy.ArRobot_getClosestSonarNumber, args)

    def getName(*args):
        """getName(self) -> char"""
        return apply(_AriaPy.ArRobot_getName, args)

    def setName(*args):
        """setName(self, char name)"""
        return apply(_AriaPy.ArRobot_setName, args)

    def moveTo(*args):
        """
        moveTo(self, ArPose pose, bool doCumulative=True)
        moveTo(self, ArPose pose)
        moveTo(self, ArPose to, ArPose from, bool doCumulative=True)
        moveTo(self, ArPose to, ArPose from)
        """
        return apply(_AriaPy.ArRobot_moveTo, args)

    def setStateOfCharge(*args):
        """setStateOfCharge(self, double stateOfCharge)"""
        return apply(_AriaPy.ArRobot_setStateOfCharge, args)

    def setStateOfChargeLow(*args):
        """setStateOfChargeLow(self, double stateOfChargeLow)"""
        return apply(_AriaPy.ArRobot_setStateOfChargeLow, args)

    def setStateOfChargeShutdown(*args):
        """setStateOfChargeShutdown(self, double stateOfChargeShutdown)"""
        return apply(_AriaPy.ArRobot_setStateOfChargeShutdown, args)

    def setChargeState(*args):
        """setChargeState(self, ChargeState chargeState)"""
        return apply(_AriaPy.ArRobot_setChargeState, args)

    def getBatteryVoltageAverageOfNum(*args):
        """getBatteryVoltageAverageOfNum(self) -> size_t"""
        return apply(_AriaPy.ArRobot_getBatteryVoltageAverageOfNum, args)

    def setBatteryVoltageAverageOfNum(*args):
        """setBatteryVoltageAverageOfNum(self, size_t numToAverage)"""
        return apply(_AriaPy.ArRobot_setBatteryVoltageAverageOfNum, args)

    def getRealBatteryVoltageAverageOfNum(*args):
        """getRealBatteryVoltageAverageOfNum(self) -> size_t"""
        return apply(_AriaPy.ArRobot_getRealBatteryVoltageAverageOfNum, args)

    def setRealBatteryVoltageAverageOfNum(*args):
        """setRealBatteryVoltageAverageOfNum(self, size_t numToAverage)"""
        return apply(_AriaPy.ArRobot_setRealBatteryVoltageAverageOfNum, args)

    def hasTemperature(*args):
        """hasTemperature(self) -> bool"""
        return apply(_AriaPy.ArRobot_hasTemperature, args)

    def getTemperature(*args):
        """getTemperature(self) -> int"""
        return apply(_AriaPy.ArRobot_getTemperature, args)

    def requestEncoderPackets(*args):
        """requestEncoderPackets(self)"""
        return apply(_AriaPy.ArRobot_requestEncoderPackets, args)

    def requestIOPackets(*args):
        """requestIOPackets(self)"""
        return apply(_AriaPy.ArRobot_requestIOPackets, args)

    def stopEncoderPackets(*args):
        """stopEncoderPackets(self)"""
        return apply(_AriaPy.ArRobot_stopEncoderPackets, args)

    def stopIOPackets(*args):
        """stopIOPackets(self)"""
        return apply(_AriaPy.ArRobot_stopIOPackets, args)

    def getLeftEncoder(*args):
        """getLeftEncoder(self) -> long"""
        return apply(_AriaPy.ArRobot_getLeftEncoder, args)

    def getRightEncoder(*args):
        """getRightEncoder(self) -> long"""
        return apply(_AriaPy.ArRobot_getRightEncoder, args)

    def setEncoderTransform(*args):
        """
        setEncoderTransform(self, ArPose deadReconPos, ArPose globalPos)
        setEncoderTransform(self, ArPose transformPos)
        """
        return apply(_AriaPy.ArRobot_setEncoderTransform, args)

    def getEncoderTransform(*args):
        """getEncoderTransform(self) -> ArTransform"""
        return apply(_AriaPy.ArRobot_getEncoderTransform, args)

    def getToGlobalTransform(*args):
        """getToGlobalTransform(self) -> ArTransform"""
        return apply(_AriaPy.ArRobot_getToGlobalTransform, args)

    def getToLocalTransform(*args):
        """getToLocalTransform(self) -> ArTransform"""
        return apply(_AriaPy.ArRobot_getToLocalTransform, args)

    def applyTransform(*args):
        """
        applyTransform(self, ArTransform trans, bool doCumulative=True)
        applyTransform(self, ArTransform trans)
        """
        return apply(_AriaPy.ArRobot_applyTransform, args)

    def setDeadReconPose(*args):
        """setDeadReconPose(self, ArPose pose)"""
        return apply(_AriaPy.ArRobot_setDeadReconPose, args)

    def getTripOdometerDistance(*args):
        """getTripOdometerDistance(self) -> double"""
        return apply(_AriaPy.ArRobot_getTripOdometerDistance, args)

    def getTripOdometerDegrees(*args):
        """getTripOdometerDegrees(self) -> double"""
        return apply(_AriaPy.ArRobot_getTripOdometerDegrees, args)

    def getTripOdometerTime(*args):
        """getTripOdometerTime(self) -> double"""
        return apply(_AriaPy.ArRobot_getTripOdometerTime, args)

    def resetTripOdometer(*args):
        """resetTripOdometer(self)"""
        return apply(_AriaPy.ArRobot_resetTripOdometer, args)

    def getOdometerDistance(*args):
        """getOdometerDistance(self) -> double"""
        return apply(_AriaPy.ArRobot_getOdometerDistance, args)

    def getOdometerDegrees(*args):
        """getOdometerDegrees(self) -> double"""
        return apply(_AriaPy.ArRobot_getOdometerDegrees, args)

    def getOdometerTime(*args):
        """getOdometerTime(self) -> double"""
        return apply(_AriaPy.ArRobot_getOdometerTime, args)

    def addRangeDevice(*args):
        """addRangeDevice(self, ArRangeDevice device)"""
        return apply(_AriaPy.ArRobot_addRangeDevice, args)

    def remRangeDevice(*args):
        """
        remRangeDevice(self, char name)
        remRangeDevice(self, ArRangeDevice device)
        """
        return apply(_AriaPy.ArRobot_remRangeDevice, args)

    def findRangeDevice(*args):
        """
        findRangeDevice(self, char name, bool ignoreCase=False) -> ArRangeDevice
        findRangeDevice(self, char name) -> ArRangeDevice
        findRangeDevice(self, char name, bool ignoreCase=False) -> ArRangeDevice
        findRangeDevice(self, char name) -> ArRangeDevice
        """
        return apply(_AriaPy.ArRobot_findRangeDevice, args)

    def getRangeDeviceList(*args):
        """getRangeDeviceList(self) -> ArRangeDevicePtrList"""
        return apply(_AriaPy.ArRobot_getRangeDeviceList, args)

    def hasRangeDevice(*args):
        """hasRangeDevice(self, ArRangeDevice device) -> bool"""
        return apply(_AriaPy.ArRobot_hasRangeDevice, args)

    def checkRangeDevicesCurrentPolar(*args):
        """
        checkRangeDevicesCurrentPolar(self, double startAngle, double endAngle, double angle=None, 
            ArRangeDevice rangeDevice=None, bool useLocationDependentDevices=True) -> double
        checkRangeDevicesCurrentPolar(self, double startAngle, double endAngle, double angle=None, 
            ArRangeDevice rangeDevice=None) -> double
        checkRangeDevicesCurrentPolar(self, double startAngle, double endAngle, double angle=None) -> double
        checkRangeDevicesCurrentPolar(self, double startAngle, double endAngle) -> double
        """
        return apply(_AriaPy.ArRobot_checkRangeDevicesCurrentPolar, args)

    def checkRangeDevicesCumulativePolar(*args):
        """
        checkRangeDevicesCumulativePolar(self, double startAngle, double endAngle, double angle=None, 
            ArRangeDevice rangeDevice=None, bool useLocationDependentDevices=True) -> double
        checkRangeDevicesCumulativePolar(self, double startAngle, double endAngle, double angle=None, 
            ArRangeDevice rangeDevice=None) -> double
        checkRangeDevicesCumulativePolar(self, double startAngle, double endAngle, double angle=None) -> double
        checkRangeDevicesCumulativePolar(self, double startAngle, double endAngle) -> double
        """
        return apply(_AriaPy.ArRobot_checkRangeDevicesCumulativePolar, args)

    def checkRangeDevicesCurrentBox(*args):
        """
        checkRangeDevicesCurrentBox(self, double x1, double y1, double x2, double y2, ArPose readingPos=None, 
            ArRangeDevice rangeDevice=None, 
            bool useLocationDependentDevices=True) -> double
        checkRangeDevicesCurrentBox(self, double x1, double y1, double x2, double y2, ArPose readingPos=None, 
            ArRangeDevice rangeDevice=None) -> double
        checkRangeDevicesCurrentBox(self, double x1, double y1, double x2, double y2, ArPose readingPos=None) -> double
        checkRangeDevicesCurrentBox(self, double x1, double y1, double x2, double y2) -> double
        """
        return apply(_AriaPy.ArRobot_checkRangeDevicesCurrentBox, args)

    def checkRangeDevicesCumulativeBox(*args):
        """
        checkRangeDevicesCumulativeBox(self, double x1, double y1, double x2, double y2, ArPose readingPos=None, 
            ArRangeDevice rangeDevice=None, 
            bool useLocationDependentDevices=True) -> double
        checkRangeDevicesCumulativeBox(self, double x1, double y1, double x2, double y2, ArPose readingPos=None, 
            ArRangeDevice rangeDevice=None) -> double
        checkRangeDevicesCumulativeBox(self, double x1, double y1, double x2, double y2, ArPose readingPos=None) -> double
        checkRangeDevicesCumulativeBox(self, double x1, double y1, double x2, double y2) -> double
        """
        return apply(_AriaPy.ArRobot_checkRangeDevicesCumulativeBox, args)

    def addLaser(*args):
        """
        addLaser(self, ArLaser laser, int laserNumber, bool addAsRangeDevice=True) -> bool
        addLaser(self, ArLaser laser, int laserNumber) -> bool
        """
        return apply(_AriaPy.ArRobot_addLaser, args)

    def remLaser(*args):
        """
        remLaser(self, ArLaser laser, bool removeAsRangeDevice=True) -> bool
        remLaser(self, ArLaser laser) -> bool
        remLaser(self, int laserNumber, bool removeAsRangeDevice=True) -> bool
        remLaser(self, int laserNumber) -> bool
        """
        return apply(_AriaPy.ArRobot_remLaser, args)

    def findLaser(*args):
        """
        findLaser(self, int laserNumber) -> ArLaser
        findLaser(self, int laserNumber) -> ArLaser
        """
        return apply(_AriaPy.ArRobot_findLaser, args)

    def getLaserMap(*args):
        """
        getLaserMap(self) -> std::map<(int,p.ArLaser,std::less<(int)>,std::allocator<(std::pair<(q(const).int,p.ArLaser)>)>)>
        getLaserMap(self) -> std::map<(int,p.ArLaser,std::less<(int)>,std::allocator<(std::pair<(q(const).int,p.ArLaser)>)>)>
        """
        return apply(_AriaPy.ArRobot_getLaserMap, args)

    def hasLaser(*args):
        """hasLaser(self, ArLaser device) -> bool"""
        return apply(_AriaPy.ArRobot_hasLaser, args)

    def setPTZ(*args):
        """setPTZ(self, ArPTZ ptz)"""
        return apply(_AriaPy.ArRobot_setPTZ, args)

    def getPTZ(*args):
        """getPTZ(self) -> ArPTZ"""
        return apply(_AriaPy.ArRobot_getPTZ, args)

    def setStateReflectionRefreshTime(*args):
        """setStateReflectionRefreshTime(self, int msec)"""
        return apply(_AriaPy.ArRobot_setStateReflectionRefreshTime, args)

    def getStateReflectionRefreshTime(*args):
        """getStateReflectionRefreshTime(self) -> int"""
        return apply(_AriaPy.ArRobot_getStateReflectionRefreshTime, args)

    def addPacketHandler(*args):
        """
        addPacketHandler(self, ArRetFunctor1_Bool_ArRobotPacketP functor, Pos position=LAST)
        addPacketHandler(self, ArRetFunctor1_Bool_ArRobotPacketP functor)
        """
        return apply(_AriaPy.ArRobot_addPacketHandler, args)

    def remPacketHandler(*args):
        """remPacketHandler(self, ArRetFunctor1_Bool_ArRobotPacketP functor)"""
        return apply(_AriaPy.ArRobot_remPacketHandler, args)

    def addConnectCB(*args):
        """
        addConnectCB(self, ArFunctor functor, Pos position=LAST)
        addConnectCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArRobot_addConnectCB, args)

    def remConnectCB(*args):
        """remConnectCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArRobot_remConnectCB, args)

    def addFailedConnectCB(*args):
        """
        addFailedConnectCB(self, ArFunctor functor, Pos position=LAST)
        addFailedConnectCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArRobot_addFailedConnectCB, args)

    def remFailedConnectCB(*args):
        """remFailedConnectCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArRobot_remFailedConnectCB, args)

    def addDisconnectNormallyCB(*args):
        """
        addDisconnectNormallyCB(self, ArFunctor functor, Pos position=LAST)
        addDisconnectNormallyCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArRobot_addDisconnectNormallyCB, args)

    def remDisconnectNormallyCB(*args):
        """remDisconnectNormallyCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArRobot_remDisconnectNormallyCB, args)

    def addDisconnectOnErrorCB(*args):
        """
        addDisconnectOnErrorCB(self, ArFunctor functor, Pos position=LAST)
        addDisconnectOnErrorCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArRobot_addDisconnectOnErrorCB, args)

    def remDisconnectOnErrorCB(*args):
        """remDisconnectOnErrorCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArRobot_remDisconnectOnErrorCB, args)

    def addRunExitCB(*args):
        """
        addRunExitCB(self, ArFunctor functor, Pos position=LAST)
        addRunExitCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArRobot_addRunExitCB, args)

    def remRunExitCB(*args):
        """remRunExitCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArRobot_remRunExitCB, args)

    def waitForConnect(*args):
        """
        waitForConnect(self, unsigned int msecs=0) -> int
        waitForConnect(self) -> int
        """
        return apply(_AriaPy.ArRobot_waitForConnect, args)

    def waitForConnectOrConnFail(*args):
        """
        waitForConnectOrConnFail(self, unsigned int msecs=0) -> int
        waitForConnectOrConnFail(self) -> int
        """
        return apply(_AriaPy.ArRobot_waitForConnectOrConnFail, args)

    def waitForRunExit(*args):
        """
        waitForRunExit(self, unsigned int msecs=0) -> int
        waitForRunExit(self) -> int
        """
        return apply(_AriaPy.ArRobot_waitForRunExit, args)

    def wakeAllWaitingThreads(*args):
        """wakeAllWaitingThreads(self)"""
        return apply(_AriaPy.ArRobot_wakeAllWaitingThreads, args)

    def wakeAllConnWaitingThreads(*args):
        """wakeAllConnWaitingThreads(self)"""
        return apply(_AriaPy.ArRobot_wakeAllConnWaitingThreads, args)

    def wakeAllConnOrFailWaitingThreads(*args):
        """wakeAllConnOrFailWaitingThreads(self)"""
        return apply(_AriaPy.ArRobot_wakeAllConnOrFailWaitingThreads, args)

    def wakeAllRunExitWaitingThreads(*args):
        """wakeAllRunExitWaitingThreads(self)"""
        return apply(_AriaPy.ArRobot_wakeAllRunExitWaitingThreads, args)

    def addUserTask(*args):
        """
        addUserTask(self, char name, int position, ArFunctor functor, State state=None) -> bool
        addUserTask(self, char name, int position, ArFunctor functor) -> bool
        """
        return apply(_AriaPy.ArRobot_addUserTask, args)

    def remUserTask(*args):
        """
        remUserTask(self, char name)
        remUserTask(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArRobot_remUserTask, args)

    def findUserTask(*args):
        """
        findUserTask(self, char name) -> ArSyncTask
        findUserTask(self, ArFunctor functor) -> ArSyncTask
        """
        return apply(_AriaPy.ArRobot_findUserTask, args)

    def logUserTasks(*args):
        """logUserTasks(self)"""
        return apply(_AriaPy.ArRobot_logUserTasks, args)

    def logAllTasks(*args):
        """logAllTasks(self)"""
        return apply(_AriaPy.ArRobot_logAllTasks, args)

    def addSensorInterpTask(*args):
        """
        addSensorInterpTask(self, char name, int position, ArFunctor functor, State state=None) -> bool
        addSensorInterpTask(self, char name, int position, ArFunctor functor) -> bool
        """
        return apply(_AriaPy.ArRobot_addSensorInterpTask, args)

    def remSensorInterpTask(*args):
        """
        remSensorInterpTask(self, char name)
        remSensorInterpTask(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArRobot_remSensorInterpTask, args)

    def findTask(*args):
        """
        findTask(self, char name) -> ArSyncTask
        findTask(self, ArFunctor functor) -> ArSyncTask
        """
        return apply(_AriaPy.ArRobot_findTask, args)

    def addAction(*args):
        """addAction(self, ArAction action, int priority) -> bool"""
        return apply(_AriaPy.ArRobot_addAction, args)

    def remAction(*args):
        """
        remAction(self, ArAction action) -> bool
        remAction(self, char actionName) -> bool
        """
        return apply(_AriaPy.ArRobot_remAction, args)

    def findAction(*args):
        """findAction(self, char actionName) -> ArAction"""
        return apply(_AriaPy.ArRobot_findAction, args)

    def getActionMap(*args):
        """getActionMap(self) -> ActionMap"""
        return apply(_AriaPy.ArRobot_getActionMap, args)

    def deactivateActions(*args):
        """deactivateActions(self)"""
        return apply(_AriaPy.ArRobot_deactivateActions, args)

    def logActions(*args):
        """
        logActions(self, bool logDeactivated=False)
        logActions(self)
        """
        return apply(_AriaPy.ArRobot_logActions, args)

    def getResolver(*args):
        """getResolver(self) -> ArResolver"""
        return apply(_AriaPy.ArRobot_getResolver, args)

    def setResolver(*args):
        """setResolver(self, ArResolver resolver)"""
        return apply(_AriaPy.ArRobot_setResolver, args)

    def setEncoderCorrectionCallback(*args):
        """setEncoderCorrectionCallback(self, ArRetFunctor1_Double_ArPoseWithTime functor)"""
        return apply(_AriaPy.ArRobot_setEncoderCorrectionCallback, args)

    def getEncoderCorrectionCallback(*args):
        """getEncoderCorrectionCallback(self) -> ArRetFunctor1_Double_ArPoseWithTime"""
        return apply(_AriaPy.ArRobot_getEncoderCorrectionCallback, args)

    def setCycleTime(*args):
        """setCycleTime(self, unsigned int ms)"""
        return apply(_AriaPy.ArRobot_setCycleTime, args)

    def getCycleTime(*args):
        """getCycleTime(self) -> unsigned int"""
        return apply(_AriaPy.ArRobot_getCycleTime, args)

    def setCycleWarningTime(*args):
        """setCycleWarningTime(self, unsigned int ms)"""
        return apply(_AriaPy.ArRobot_setCycleWarningTime, args)

    def getCycleWarningTime(*args):
        """
        getCycleWarningTime(self) -> unsigned int
        getCycleWarningTime(self) -> unsigned int
        """
        return apply(_AriaPy.ArRobot_getCycleWarningTime, args)

    def setConnectionCycleMultiplier(*args):
        """setConnectionCycleMultiplier(self, unsigned int multiplier)"""
        return apply(_AriaPy.ArRobot_setConnectionCycleMultiplier, args)

    def getConnectionCycleMultiplier(*args):
        """getConnectionCycleMultiplier(self) -> unsigned int"""
        return apply(_AriaPy.ArRobot_getConnectionCycleMultiplier, args)

    def setCycleChained(*args):
        """setCycleChained(self, bool cycleChained)"""
        return apply(_AriaPy.ArRobot_setCycleChained, args)

    def isCycleChained(*args):
        """isCycleChained(self) -> bool"""
        return apply(_AriaPy.ArRobot_isCycleChained, args)

    def setConnectionTimeoutTime(*args):
        """setConnectionTimeoutTime(self, int mSecs)"""
        return apply(_AriaPy.ArRobot_setConnectionTimeoutTime, args)

    def getConnectionTimeoutTime(*args):
        """getConnectionTimeoutTime(self) -> int"""
        return apply(_AriaPy.ArRobot_getConnectionTimeoutTime, args)

    def getLastPacketTime(*args):
        """getLastPacketTime(self) -> ArTime"""
        return apply(_AriaPy.ArRobot_getLastPacketTime, args)

    def getLastOdometryTime(*args):
        """getLastOdometryTime(self) -> ArTime"""
        return apply(_AriaPy.ArRobot_getLastOdometryTime, args)

    def setPoseInterpNumReadings(*args):
        """setPoseInterpNumReadings(self, size_t numReadings)"""
        return apply(_AriaPy.ArRobot_setPoseInterpNumReadings, args)

    def getPoseInterpNumReadings(*args):
        """getPoseInterpNumReadings(self) -> size_t"""
        return apply(_AriaPy.ArRobot_getPoseInterpNumReadings, args)

    def getPoseInterpPosition(*args):
        """getPoseInterpPosition(self, ArTime timeStamp, ArPose position) -> int"""
        return apply(_AriaPy.ArRobot_getPoseInterpPosition, args)

    def setEncoderPoseInterpNumReadings(*args):
        """setEncoderPoseInterpNumReadings(self, size_t numReadings)"""
        return apply(_AriaPy.ArRobot_setEncoderPoseInterpNumReadings, args)

    def getEncoderPoseInterpNumReadings(*args):
        """getEncoderPoseInterpNumReadings(self) -> size_t"""
        return apply(_AriaPy.ArRobot_getEncoderPoseInterpNumReadings, args)

    def getEncoderPoseInterpPosition(*args):
        """getEncoderPoseInterpPosition(self, ArTime timeStamp, ArPose position) -> int"""
        return apply(_AriaPy.ArRobot_getEncoderPoseInterpPosition, args)

    def getCounter(*args):
        """getCounter(self) -> unsigned int"""
        return apply(_AriaPy.ArRobot_getCounter, args)

    def getRobotParams(*args):
        """getRobotParams(self) -> ArRobotParams"""
        return apply(_AriaPy.ArRobot_getRobotParams, args)

    def getOrigRobotConfig(*args):
        """getOrigRobotConfig(self) -> ArRobotConfigPacketReader"""
        return apply(_AriaPy.ArRobot_getOrigRobotConfig, args)

    def setTransVelMax(*args):
        """setTransVelMax(self, double vel)"""
        return apply(_AriaPy.ArRobot_setTransVelMax, args)

    def setTransAccel(*args):
        """setTransAccel(self, double acc)"""
        return apply(_AriaPy.ArRobot_setTransAccel, args)

    def setTransDecel(*args):
        """setTransDecel(self, double decel)"""
        return apply(_AriaPy.ArRobot_setTransDecel, args)

    def setRotVelMax(*args):
        """setRotVelMax(self, double vel)"""
        return apply(_AriaPy.ArRobot_setRotVelMax, args)

    def setRotAccel(*args):
        """setRotAccel(self, double acc)"""
        return apply(_AriaPy.ArRobot_setRotAccel, args)

    def setRotDecel(*args):
        """setRotDecel(self, double decel)"""
        return apply(_AriaPy.ArRobot_setRotDecel, args)

    def setLatVelMax(*args):
        """setLatVelMax(self, double vel)"""
        return apply(_AriaPy.ArRobot_setLatVelMax, args)

    def setLatAccel(*args):
        """setLatAccel(self, double acc)"""
        return apply(_AriaPy.ArRobot_setLatAccel, args)

    def setLatDecel(*args):
        """setLatDecel(self, double decel)"""
        return apply(_AriaPy.ArRobot_setLatDecel, args)

    def hasSettableVelMaxes(*args):
        """hasSettableVelMaxes(self) -> bool"""
        return apply(_AriaPy.ArRobot_hasSettableVelMaxes, args)

    def getTransVelMax(*args):
        """getTransVelMax(self) -> double"""
        return apply(_AriaPy.ArRobot_getTransVelMax, args)

    def getRotVelMax(*args):
        """getRotVelMax(self) -> double"""
        return apply(_AriaPy.ArRobot_getRotVelMax, args)

    def hasSettableAccsDecs(*args):
        """hasSettableAccsDecs(self) -> bool"""
        return apply(_AriaPy.ArRobot_hasSettableAccsDecs, args)

    def getTransAccel(*args):
        """getTransAccel(self) -> double"""
        return apply(_AriaPy.ArRobot_getTransAccel, args)

    def getTransDecel(*args):
        """getTransDecel(self) -> double"""
        return apply(_AriaPy.ArRobot_getTransDecel, args)

    def getRotAccel(*args):
        """getRotAccel(self) -> double"""
        return apply(_AriaPy.ArRobot_getRotAccel, args)

    def getRotDecel(*args):
        """getRotDecel(self) -> double"""
        return apply(_AriaPy.ArRobot_getRotDecel, args)

    def getLatVelMax(*args):
        """getLatVelMax(self) -> double"""
        return apply(_AriaPy.ArRobot_getLatVelMax, args)

    def getLatAccel(*args):
        """getLatAccel(self) -> double"""
        return apply(_AriaPy.ArRobot_getLatAccel, args)

    def getLatDecel(*args):
        """getLatDecel(self) -> double"""
        return apply(_AriaPy.ArRobot_getLatDecel, args)

    def loadParamFile(*args):
        """loadParamFile(self, char file) -> bool"""
        return apply(_AriaPy.ArRobot_loadParamFile, args)

    def setRobotParams(*args):
        """setRobotParams(self, ArRobotParams params)"""
        return apply(_AriaPy.ArRobot_setRobotParams, args)

    def attachKeyHandler(*args):
        """
        attachKeyHandler(self, ArKeyHandler keyHandler, bool exitOnEscape=True, bool useExitNotShutdown=True)
        attachKeyHandler(self, ArKeyHandler keyHandler, bool exitOnEscape=True)
        attachKeyHandler(self, ArKeyHandler keyHandler)
        """
        return apply(_AriaPy.ArRobot_attachKeyHandler, args)

    def getKeyHandler(*args):
        """getKeyHandler(self) -> ArKeyHandler"""
        return apply(_AriaPy.ArRobot_getKeyHandler, args)

    def lock(*args):
        """lock(self) -> int"""
        return apply(_AriaPy.ArRobot_lock, args)

    def tryLock(*args):
        """tryLock(self) -> int"""
        return apply(_AriaPy.ArRobot_tryLock, args)

    def unlock(*args):
        """unlock(self) -> int"""
        return apply(_AriaPy.ArRobot_unlock, args)

    def setMutexLogging(*args):
        """setMutexLogging(self, bool v)"""
        return apply(_AriaPy.ArRobot_setMutexLogging, args)

    def setMutexLockWarningTime(*args):
        """setMutexLockWarningTime(self, double sec)"""
        return apply(_AriaPy.ArRobot_setMutexLockWarningTime, args)

    def setMutexUnlockWarningTime(*args):
        """setMutexUnlockWarningTime(self, double sec)"""
        return apply(_AriaPy.ArRobot_setMutexUnlockWarningTime, args)

    def isStabilizing(*args):
        """isStabilizing(self) -> bool"""
        return apply(_AriaPy.ArRobot_isStabilizing, args)

    def setStabilizingTime(*args):
        """setStabilizingTime(self, int mSecs)"""
        return apply(_AriaPy.ArRobot_setStabilizingTime, args)

    def getStabilizingTime(*args):
        """getStabilizingTime(self) -> int"""
        return apply(_AriaPy.ArRobot_getStabilizingTime, args)

    def addStabilizingCB(*args):
        """
        addStabilizingCB(self, ArFunctor functor, Pos position=LAST)
        addStabilizingCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArRobot_addStabilizingCB, args)

    def remStabilizingCB(*args):
        """remStabilizingCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArRobot_remStabilizingCB, args)

    def getSyncTaskRoot(*args):
        """getSyncTaskRoot(self) -> ArSyncTask"""
        return apply(_AriaPy.ArRobot_getSyncTaskRoot, args)

    def loopOnce(*args):
        """loopOnce(self)"""
        return apply(_AriaPy.ArRobot_loopOnce, args)

    def setOdometryDelay(*args):
        """setOdometryDelay(self, int msec)"""
        return apply(_AriaPy.ArRobot_setOdometryDelay, args)

    def getOdometryDelay(*args):
        """getOdometryDelay(self) -> int"""
        return apply(_AriaPy.ArRobot_getOdometryDelay, args)

    def getLogMovementSent(*args):
        """getLogMovementSent(self) -> bool"""
        return apply(_AriaPy.ArRobot_getLogMovementSent, args)

    def setLogMovementSent(*args):
        """setLogMovementSent(self, bool logMovementSent)"""
        return apply(_AriaPy.ArRobot_setLogMovementSent, args)

    def getLogMovementReceived(*args):
        """getLogMovementReceived(self) -> bool"""
        return apply(_AriaPy.ArRobot_getLogMovementReceived, args)

    def setLogMovementReceived(*args):
        """setLogMovementReceived(self, bool logMovementReceived)"""
        return apply(_AriaPy.ArRobot_setLogMovementReceived, args)

    def getLogVelocitiesReceived(*args):
        """getLogVelocitiesReceived(self) -> bool"""
        return apply(_AriaPy.ArRobot_getLogVelocitiesReceived, args)

    def setLogVelocitiesReceived(*args):
        """setLogVelocitiesReceived(self, bool logVelocitiesReceived)"""
        return apply(_AriaPy.ArRobot_setLogVelocitiesReceived, args)

    def getPacketsReceivedTracking(*args):
        """getPacketsReceivedTracking(self) -> bool"""
        return apply(_AriaPy.ArRobot_getPacketsReceivedTracking, args)

    def setPacketsReceivedTracking(*args):
        """setPacketsReceivedTracking(self, bool packetsReceivedTracking)"""
        return apply(_AriaPy.ArRobot_setPacketsReceivedTracking, args)

    def getPacketsSentTracking(*args):
        """getPacketsSentTracking(self) -> bool"""
        return apply(_AriaPy.ArRobot_getPacketsSentTracking, args)

    def setPacketsSentTracking(*args):
        """setPacketsSentTracking(self, bool packetsSentTracking)"""
        return apply(_AriaPy.ArRobot_setPacketsSentTracking, args)

    def getLogActions(*args):
        """getLogActions(self) -> bool"""
        return apply(_AriaPy.ArRobot_getLogActions, args)

    def setLogActions(*args):
        """setLogActions(self, bool logActions)"""
        return apply(_AriaPy.ArRobot_setLogActions, args)

    def setDoNotSwitchBaud(*args):
        """setDoNotSwitchBaud(self, bool doNotSwitchBaud)"""
        return apply(_AriaPy.ArRobot_setDoNotSwitchBaud, args)

    def getDoNotSwitchBaud(*args):
        """getDoNotSwitchBaud(self) -> bool"""
        return apply(_AriaPy.ArRobot_getDoNotSwitchBaud, args)

    def incCounter(*args):
        """incCounter(self)"""
        return apply(_AriaPy.ArRobot_incCounter, args)

    def packetHandler(*args):
        """packetHandler(self)"""
        return apply(_AriaPy.ArRobot_packetHandler, args)

    def actionHandler(*args):
        """actionHandler(self)"""
        return apply(_AriaPy.ArRobot_actionHandler, args)

    def stateReflector(*args):
        """stateReflector(self)"""
        return apply(_AriaPy.ArRobot_stateReflector, args)

    def robotLocker(*args):
        """robotLocker(self)"""
        return apply(_AriaPy.ArRobot_robotLocker, args)

    def robotUnlocker(*args):
        """robotUnlocker(self)"""
        return apply(_AriaPy.ArRobot_robotUnlocker, args)

    def keyHandlerExit(*args):
        """keyHandlerExit(self)"""
        return apply(_AriaPy.ArRobot_keyHandlerExit, args)

    def processMotorPacket(*args):
        """processMotorPacket(self, ArRobotPacket packet) -> bool"""
        return apply(_AriaPy.ArRobot_processMotorPacket, args)

    def processNewSonar(*args):
        """processNewSonar(self, char number, int range, ArTime timeReceived)"""
        return apply(_AriaPy.ArRobot_processNewSonar, args)

    def processEncoderPacket(*args):
        """processEncoderPacket(self, ArRobotPacket packet) -> bool"""
        return apply(_AriaPy.ArRobot_processEncoderPacket, args)

    def processIOPacket(*args):
        """processIOPacket(self, ArRobotPacket packet) -> bool"""
        return apply(_AriaPy.ArRobot_processIOPacket, args)

    def init(*args):
        """init(self)"""
        return apply(_AriaPy.ArRobot_init, args)

    def setUpSyncList(*args):
        """setUpSyncList(self)"""
        return apply(_AriaPy.ArRobot_setUpSyncList, args)

    def setUpPacketHandlers(*args):
        """setUpPacketHandlers(self)"""
        return apply(_AriaPy.ArRobot_setUpPacketHandlers, args)

    __swig_setmethods__["myMotorPacketCB"] = _AriaPy.ArRobot_myMotorPacketCB_set
    __swig_getmethods__["myMotorPacketCB"] = _AriaPy.ArRobot_myMotorPacketCB_get
    __swig_setmethods__["myEncoderPacketCB"] = _AriaPy.ArRobot_myEncoderPacketCB_set
    __swig_getmethods__["myEncoderPacketCB"] = _AriaPy.ArRobot_myEncoderPacketCB_get
    __swig_setmethods__["myIOPacketCB"] = _AriaPy.ArRobot_myIOPacketCB_set
    __swig_getmethods__["myIOPacketCB"] = _AriaPy.ArRobot_myIOPacketCB_get
    __swig_setmethods__["myPacketHandlerCB"] = _AriaPy.ArRobot_myPacketHandlerCB_set
    __swig_getmethods__["myPacketHandlerCB"] = _AriaPy.ArRobot_myPacketHandlerCB_get
    __swig_setmethods__["myActionHandlerCB"] = _AriaPy.ArRobot_myActionHandlerCB_set
    __swig_getmethods__["myActionHandlerCB"] = _AriaPy.ArRobot_myActionHandlerCB_get
    __swig_setmethods__["myStateReflectorCB"] = _AriaPy.ArRobot_myStateReflectorCB_set
    __swig_getmethods__["myStateReflectorCB"] = _AriaPy.ArRobot_myStateReflectorCB_get
    __swig_setmethods__["myRobotLockerCB"] = _AriaPy.ArRobot_myRobotLockerCB_set
    __swig_getmethods__["myRobotLockerCB"] = _AriaPy.ArRobot_myRobotLockerCB_get
    __swig_setmethods__["myRobotUnlockerCB"] = _AriaPy.ArRobot_myRobotUnlockerCB_set
    __swig_getmethods__["myRobotUnlockerCB"] = _AriaPy.ArRobot_myRobotUnlockerCB_get
    __swig_setmethods__["myKeyHandlerExitCB"] = _AriaPy.ArRobot_myKeyHandlerExitCB_set
    __swig_getmethods__["myKeyHandlerExitCB"] = _AriaPy.ArRobot_myKeyHandlerExitCB_get
    __swig_setmethods__["myKeyHandlerCB"] = _AriaPy.ArRobot_myKeyHandlerCB_set
    __swig_getmethods__["myKeyHandlerCB"] = _AriaPy.ArRobot_myKeyHandlerCB_get
    def asyncConnectHandler(*args):
        """asyncConnectHandler(self, bool tryHarderToConnect) -> int"""
        return apply(_AriaPy.ArRobot_asyncConnectHandler, args)

    def dropConnection(*args):
        """dropConnection(self)"""
        return apply(_AriaPy.ArRobot_dropConnection, args)

    def failedConnect(*args):
        """failedConnect(self)"""
        return apply(_AriaPy.ArRobot_failedConnect, args)

    def madeConnection(*args):
        """madeConnection(self) -> bool"""
        return apply(_AriaPy.ArRobot_madeConnection, args)

    def startStabilization(*args):
        """startStabilization(self)"""
        return apply(_AriaPy.ArRobot_startStabilization, args)

    def finishedConnection(*args):
        """finishedConnection(self)"""
        return apply(_AriaPy.ArRobot_finishedConnection, args)

    def cancelConnection(*args):
        """cancelConnection(self)"""
        return apply(_AriaPy.ArRobot_cancelConnection, args)

    def handlePacket(*args):
        """handlePacket(self, ArRobotPacket packet) -> bool"""
        return apply(_AriaPy.ArRobot_handlePacket, args)

    def getRunExitListCopy(*args):
        """getRunExitListCopy(self) -> ArFunctorPtrList"""
        return apply(_AriaPy.ArRobot_getRunExitListCopy, args)

    def processParamFile(*args):
        """processParamFile(self)"""
        return apply(_AriaPy.ArRobot_processParamFile, args)

    def getRawEncoderPose(*args):
        """getRawEncoderPose(self) -> ArPose"""
        return apply(_AriaPy.ArRobot_getRawEncoderPose, args)

    def getNoTimeWarningThisCycle(*args):
        """getNoTimeWarningThisCycle(self) -> bool"""
        return apply(_AriaPy.ArRobot_getNoTimeWarningThisCycle, args)

    def setNoTimeWarningThisCycle(*args):
        """setNoTimeWarningThisCycle(self, bool noTimeWarningThisCycle)"""
        return apply(_AriaPy.ArRobot_setNoTimeWarningThisCycle, args)

    __swig_setmethods__["myGetCycleWarningTimeCB"] = _AriaPy.ArRobot_myGetCycleWarningTimeCB_set
    __swig_getmethods__["myGetCycleWarningTimeCB"] = _AriaPy.ArRobot_myGetCycleWarningTimeCB_get
    __swig_setmethods__["myGetNoTimeWarningThisCycleCB"] = _AriaPy.ArRobot_myGetNoTimeWarningThisCycleCB_set
    __swig_getmethods__["myGetNoTimeWarningThisCycleCB"] = _AriaPy.ArRobot_myGetNoTimeWarningThisCycleCB_get
    def ariaExitCallback(*args):
        """ariaExitCallback(self)"""
        return apply(_AriaPy.ArRobot_ariaExitCallback, args)

    def setConnectWithNoParams(*args):
        """setConnectWithNoParams(self, bool connectWithNoParams)"""
        return apply(_AriaPy.ArRobot_setConnectWithNoParams, args)

    def getOSThread(*args):
        """getOSThread(self) -> ThreadType"""
        return apply(_AriaPy.ArRobot_getOSThread, args)

ArRobot_swigregister = _AriaPy.ArRobot_swigregister
ArRobot_swigregister(ArRobot)

class ArRobotConfig:
    """Proxy of C++ ArRobotConfig class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRobotConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArRobotConfig, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot) -> ArRobotConfig"""
        this = apply(_AriaPy.new_ArRobotConfig, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotConfig
    __del__ = lambda self : None;
    def addAnalogGyro(*args):
        """addAnalogGyro(self, ArAnalogGyro gyro)"""
        return apply(_AriaPy.ArRobotConfig_addAnalogGyro, args)

    def processFile(*args):
        """processFile(self) -> bool"""
        return apply(_AriaPy.ArRobotConfig_processFile, args)

    def connectCallback(*args):
        """connectCallback(self)"""
        return apply(_AriaPy.ArRobotConfig_connectCallback, args)

ArRobotConfig_swigregister = _AriaPy.ArRobotConfig_swigregister
ArRobotConfig_swigregister(ArRobotConfig)

class ArRobotConfigPacketReader:
    """Proxy of C++ ArRobotConfigPacketReader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRobotConfigPacketReader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArRobotConfigPacketReader, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArRobot robot, bool onlyOneRequest=False, ArFunctor packetedArrivedCB=None) -> ArRobotConfigPacketReader
        __init__(self, ArRobot robot, bool onlyOneRequest=False) -> ArRobotConfigPacketReader
        __init__(self, ArRobot robot) -> ArRobotConfigPacketReader
        """
        this = apply(_AriaPy.new_ArRobotConfigPacketReader, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotConfigPacketReader
    __del__ = lambda self : None;
    def requestPacket(*args):
        """requestPacket(self) -> bool"""
        return apply(_AriaPy.ArRobotConfigPacketReader_requestPacket, args)

    def hasPacketBeenRequested(*args):
        """hasPacketBeenRequested(self) -> bool"""
        return apply(_AriaPy.ArRobotConfigPacketReader_hasPacketBeenRequested, args)

    def hasPacketArrived(*args):
        """hasPacketArrived(self) -> bool"""
        return apply(_AriaPy.ArRobotConfigPacketReader_hasPacketArrived, args)

    def log(*args):
        """log(self)"""
        return apply(_AriaPy.ArRobotConfigPacketReader_log, args)

    def logMovement(*args):
        """logMovement(self)"""
        return apply(_AriaPy.ArRobotConfigPacketReader_logMovement, args)

    def buildString(*args):
        """buildString(self) -> std::string"""
        return apply(_AriaPy.ArRobotConfigPacketReader_buildString, args)

    def buildStringMovement(*args):
        """buildStringMovement(self) -> std::string"""
        return apply(_AriaPy.ArRobotConfigPacketReader_buildStringMovement, args)

    def getType(*args):
        """getType(self) -> char"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getType, args)

    def getSubType(*args):
        """getSubType(self) -> char"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getSubType, args)

    def getSerialNumber(*args):
        """getSerialNumber(self) -> char"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getSerialNumber, args)

    def getRotVelTop(*args):
        """getRotVelTop(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getRotVelTop, args)

    def getTransVelTop(*args):
        """getTransVelTop(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getTransVelTop, args)

    def getRotAccelTop(*args):
        """getRotAccelTop(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getRotAccelTop, args)

    def getTransAccelTop(*args):
        """getTransAccelTop(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getTransAccelTop, args)

    def getPwmMax(*args):
        """getPwmMax(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getPwmMax, args)

    def getName(*args):
        """getName(self) -> char"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getName, args)

    def getSipCycleTime(*args):
        """getSipCycleTime(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getSipCycleTime, args)

    def getHostBaud(*args):
        """getHostBaud(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getHostBaud, args)

    def getAux1Baud(*args):
        """getAux1Baud(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getAux1Baud, args)

    def getHasGripper(*args):
        """getHasGripper(self) -> bool"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getHasGripper, args)

    def getFrontSonar(*args):
        """getFrontSonar(self) -> bool"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getFrontSonar, args)

    def getRearSonar(*args):
        """getRearSonar(self) -> bool"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getRearSonar, args)

    def getLowBattery(*args):
        """getLowBattery(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getLowBattery, args)

    def getRevCount(*args):
        """getRevCount(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getRevCount, args)

    def getWatchdog(*args):
        """getWatchdog(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getWatchdog, args)

    def getNormalMPacs(*args):
        """getNormalMPacs(self) -> bool"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getNormalMPacs, args)

    def getStallVal(*args):
        """getStallVal(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getStallVal, args)

    def getStallCount(*args):
        """getStallCount(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getStallCount, args)

    def getJoyVel(*args):
        """getJoyVel(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getJoyVel, args)

    def getJoyRotVel(*args):
        """getJoyRotVel(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getJoyRotVel, args)

    def getRotVelMax(*args):
        """getRotVelMax(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getRotVelMax, args)

    def getTransVelMax(*args):
        """getTransVelMax(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getTransVelMax, args)

    def getRotAccel(*args):
        """getRotAccel(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getRotAccel, args)

    def getRotDecel(*args):
        """getRotDecel(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getRotDecel, args)

    def getRotKP(*args):
        """getRotKP(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getRotKP, args)

    def getRotKV(*args):
        """getRotKV(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getRotKV, args)

    def getRotKI(*args):
        """getRotKI(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getRotKI, args)

    def getTransAccel(*args):
        """getTransAccel(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getTransAccel, args)

    def getTransDecel(*args):
        """getTransDecel(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getTransDecel, args)

    def getTransKP(*args):
        """getTransKP(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getTransKP, args)

    def getTransKV(*args):
        """getTransKV(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getTransKV, args)

    def getTransKI(*args):
        """getTransKI(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getTransKI, args)

    def getFrontBumps(*args):
        """getFrontBumps(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getFrontBumps, args)

    def getRearBumps(*args):
        """getRearBumps(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getRearBumps, args)

    def getHasCharger(*args):
        """getHasCharger(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getHasCharger, args)

    def getSonarCycle(*args):
        """getSonarCycle(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getSonarCycle, args)

    def getResetBaud(*args):
        """getResetBaud(self) -> bool"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getResetBaud, args)

    def getHasGyro(*args):
        """getHasGyro(self) -> bool"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getHasGyro, args)

    def getGyroType(*args):
        """getGyroType(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getGyroType, args)

    def getDriftFactor(*args):
        """getDriftFactor(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getDriftFactor, args)

    def getAux2Baud(*args):
        """getAux2Baud(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getAux2Baud, args)

    def getAux3Baud(*args):
        """getAux3Baud(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getAux3Baud, args)

    def getTicksMM(*args):
        """getTicksMM(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getTicksMM, args)

    def getShutdownVoltage(*args):
        """getShutdownVoltage(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getShutdownVoltage, args)

    def getFirmwareVersion(*args):
        """getFirmwareVersion(self) -> char"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getFirmwareVersion, args)

    def getGyroCW(*args):
        """getGyroCW(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getGyroCW, args)

    def getGyroCCW(*args):
        """getGyroCCW(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getGyroCCW, args)

    def getKinematicsDelay(*args):
        """getKinematicsDelay(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getKinematicsDelay, args)

    def getLatVelTop(*args):
        """getLatVelTop(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getLatVelTop, args)

    def getLatAccelTop(*args):
        """getLatAccelTop(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getLatAccelTop, args)

    def getLatVelMax(*args):
        """getLatVelMax(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getLatVelMax, args)

    def getLatAccel(*args):
        """getLatAccel(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getLatAccel, args)

    def getLatDecel(*args):
        """getLatDecel(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getLatDecel, args)

    def getPowerbotChargeThreshold(*args):
        """getPowerbotChargeThreshold(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getPowerbotChargeThreshold, args)

    def getPDBPort(*args):
        """getPDBPort(self) -> unsigned char"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getPDBPort, args)

    def getGyroRateLimit(*args):
        """getGyroRateLimit(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getGyroRateLimit, args)

    def getHighTemperatureShutdown(*args):
        """getHighTemperatureShutdown(self) -> char"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getHighTemperatureShutdown, args)

    def getPowerBits(*args):
        """getPowerBits(self) -> int"""
        return apply(_AriaPy.ArRobotConfigPacketReader_getPowerBits, args)

    def packetHandler(*args):
        """packetHandler(self, ArRobotPacket packet) -> bool"""
        return apply(_AriaPy.ArRobotConfigPacketReader_packetHandler, args)

    def connected(*args):
        """connected(self)"""
        return apply(_AriaPy.ArRobotConfigPacketReader_connected, args)

ArRobotConfigPacketReader_swigregister = _AriaPy.ArRobotConfigPacketReader_swigregister
ArRobotConfigPacketReader_swigregister(ArRobotConfigPacketReader)

class ArRobotConnector:
    """Proxy of C++ ArRobotConnector class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRobotConnector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArRobotConnector, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArArgumentParser parser, ArRobot robot, bool autoParseArgs=True) -> ArRobotConnector
        __init__(self, ArArgumentParser parser, ArRobot robot) -> ArRobotConnector
        """
        this = apply(_AriaPy.new_ArRobotConnector, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotConnector
    __del__ = lambda self : None;
    def setupRobot(*args):
        """
        setupRobot(self) -> bool
        setupRobot(self, ArRobot robot) -> bool
        """
        return apply(_AriaPy.ArRobotConnector_setupRobot, args)

    def connectRobot(*args):
        """
        connectRobot(self) -> bool
        connectRobot(self, ArRobot robot) -> bool
        """
        return apply(_AriaPy.ArRobotConnector_connectRobot, args)

    def parseArgs(*args):
        """
        parseArgs(self) -> bool
        parseArgs(self, ArArgumentParser parser) -> bool
        """
        return apply(_AriaPy.ArRobotConnector_parseArgs, args)

    def logOptions(*args):
        """logOptions(self)"""
        return apply(_AriaPy.ArRobotConnector_logOptions, args)

    def getRemoteHost(*args):
        """getRemoteHost(self) -> char"""
        return apply(_AriaPy.ArRobotConnector_getRemoteHost, args)

    def getRemoteIsSim(*args):
        """getRemoteIsSim(self) -> bool"""
        return apply(_AriaPy.ArRobotConnector_getRemoteIsSim, args)

    def getRobot(*args):
        """getRobot(self) -> ArRobot"""
        return apply(_AriaPy.ArRobotConnector_getRobot, args)

ArRobotConnector_swigregister = _AriaPy.ArRobotConnector_swigregister
ArRobotConnector_swigregister(ArRobotConnector)

class ArRobotJoyHandler:
    """Proxy of C++ ArRobotJoyHandler class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRobotJoyHandler, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArRobotJoyHandler, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot) -> ArRobotJoyHandler"""
        this = apply(_AriaPy.new_ArRobotJoyHandler, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotJoyHandler
    __del__ = lambda self : None;
    def getDoubles(*args):
        """getDoubles(self, double x, double y, double z)"""
        return apply(_AriaPy.ArRobotJoyHandler_getDoubles, args)

    def getButton1(*args):
        """getButton1(self) -> bool"""
        return apply(_AriaPy.ArRobotJoyHandler_getButton1, args)

    def getButton2(*args):
        """getButton2(self) -> bool"""
        return apply(_AriaPy.ArRobotJoyHandler_getButton2, args)

    def getDataReceivedTime(*args):
        """getDataReceivedTime(self) -> ArTime"""
        return apply(_AriaPy.ArRobotJoyHandler_getDataReceivedTime, args)

    def gotData(*args):
        """gotData(self) -> bool"""
        return apply(_AriaPy.ArRobotJoyHandler_gotData, args)

ArRobotJoyHandler_swigregister = _AriaPy.ArRobotJoyHandler_swigregister
ArRobotJoyHandler_swigregister(ArRobotJoyHandler)

class ArRobotPacket(ArBasePacket):
    """Proxy of C++ ArRobotPacket class"""
    __swig_setmethods__ = {}
    for _s in [ArBasePacket]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRobotPacket, name, value)
    __swig_getmethods__ = {}
    for _s in [ArBasePacket]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRobotPacket, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, unsigned char sync1=0xfa, unsigned char sync2=0xfb) -> ArRobotPacket
        __init__(self, unsigned char sync1=0xfa) -> ArRobotPacket
        __init__(self) -> ArRobotPacket
        """
        this = apply(_AriaPy.new_ArRobotPacket, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotPacket
    __del__ = lambda self : None;
    def verifyCheckSum(*args):
        """verifyCheckSum(self) -> bool"""
        return apply(_AriaPy.ArRobotPacket_verifyCheckSum, args)

    def getID(*args):
        """getID(self) -> UByte"""
        return apply(_AriaPy.ArRobotPacket_getID, args)

    def setID(*args):
        """setID(self, UByte id)"""
        return apply(_AriaPy.ArRobotPacket_setID, args)

    def calcCheckSum(*args):
        """calcCheckSum(self) -> Byte2"""
        return apply(_AriaPy.ArRobotPacket_calcCheckSum, args)

    def finalizePacket(*args):
        """finalizePacket(self)"""
        return apply(_AriaPy.ArRobotPacket_finalizePacket, args)

    def getTimeReceived(*args):
        """getTimeReceived(self) -> ArTime"""
        return apply(_AriaPy.ArRobotPacket_getTimeReceived, args)

    def setTimeReceived(*args):
        """setTimeReceived(self, ArTime timeReceived)"""
        return apply(_AriaPy.ArRobotPacket_setTimeReceived, args)

    def log(*args):
        """log(self)"""
        return apply(_AriaPy.ArRobotPacket_log, args)

ArRobotPacket_swigregister = _AriaPy.ArRobotPacket_swigregister
ArRobotPacket_swigregister(ArRobotPacket)

class ArRobotPacketReceiver:
    """Proxy of C++ ArRobotPacketReceiver class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRobotPacketReceiver, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArRobotPacketReceiver, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, bool allocatePackets=False, unsigned char sync1=0xfa, 
            unsigned char sync2=0xfb) -> ArRobotPacketReceiver
        __init__(self, bool allocatePackets=False, unsigned char sync1=0xfa) -> ArRobotPacketReceiver
        __init__(self, bool allocatePackets=False) -> ArRobotPacketReceiver
        __init__(self) -> ArRobotPacketReceiver
        __init__(self, ArDeviceConnection deviceConnection, bool allocatePackets=False, 
            unsigned char sync1=0xfa, unsigned char sync2=0xfb) -> ArRobotPacketReceiver
        __init__(self, ArDeviceConnection deviceConnection, bool allocatePackets=False, 
            unsigned char sync1=0xfa) -> ArRobotPacketReceiver
        __init__(self, ArDeviceConnection deviceConnection, bool allocatePackets=False) -> ArRobotPacketReceiver
        __init__(self, ArDeviceConnection deviceConnection) -> ArRobotPacketReceiver
        """
        this = apply(_AriaPy.new_ArRobotPacketReceiver, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotPacketReceiver
    __del__ = lambda self : None;
    def receivePacket(*args):
        """
        receivePacket(self, unsigned int msWait=0) -> ArRobotPacket
        receivePacket(self) -> ArRobotPacket
        """
        return apply(_AriaPy.ArRobotPacketReceiver_receivePacket, args)

    def setDeviceConnection(*args):
        """setDeviceConnection(self, ArDeviceConnection deviceConnection)"""
        return apply(_AriaPy.ArRobotPacketReceiver_setDeviceConnection, args)

    def getDeviceConnection(*args):
        """getDeviceConnection(self) -> ArDeviceConnection"""
        return apply(_AriaPy.ArRobotPacketReceiver_getDeviceConnection, args)

    def isAllocatingPackets(*args):
        """isAllocatingPackets(self) -> bool"""
        return apply(_AriaPy.ArRobotPacketReceiver_isAllocatingPackets, args)

ArRobotPacketReceiver_swigregister = _AriaPy.ArRobotPacketReceiver_swigregister
ArRobotPacketReceiver_swigregister(ArRobotPacketReceiver)

class ArRobotPacketSender:
    """Proxy of C++ ArRobotPacketSender class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRobotPacketSender, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArRobotPacketSender, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, unsigned char sync1=0xfa, unsigned char sync2=0xfb) -> ArRobotPacketSender
        __init__(self, unsigned char sync1=0xfa) -> ArRobotPacketSender
        __init__(self) -> ArRobotPacketSender
        __init__(self, ArDeviceConnection deviceConnection, unsigned char sync1=0xfa, 
            unsigned char sync2=0xfb) -> ArRobotPacketSender
        __init__(self, ArDeviceConnection deviceConnection, unsigned char sync1=0xfa) -> ArRobotPacketSender
        __init__(self, ArDeviceConnection deviceConnection) -> ArRobotPacketSender
        """
        this = apply(_AriaPy.new_ArRobotPacketSender, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotPacketSender
    __del__ = lambda self : None;
    def com(*args):
        """com(self, unsigned char command) -> bool"""
        return apply(_AriaPy.ArRobotPacketSender_com, args)

    def comInt(*args):
        """comInt(self, unsigned char command, short argument) -> bool"""
        return apply(_AriaPy.ArRobotPacketSender_comInt, args)

    def com2Bytes(*args):
        """com2Bytes(self, unsigned char command, char high, char low) -> bool"""
        return apply(_AriaPy.ArRobotPacketSender_com2Bytes, args)

    def comStr(*args):
        """comStr(self, unsigned char command, char argument) -> bool"""
        return apply(_AriaPy.ArRobotPacketSender_comStr, args)

    def comStrN(*args):
        """comStrN(self, unsigned char command, char str, int size) -> bool"""
        return apply(_AriaPy.ArRobotPacketSender_comStrN, args)

    def comDataN(*args):
        """comDataN(self, unsigned char command, char data, int size) -> bool"""
        return apply(_AriaPy.ArRobotPacketSender_comDataN, args)

    def setDeviceConnection(*args):
        """setDeviceConnection(self, ArDeviceConnection deviceConnection)"""
        return apply(_AriaPy.ArRobotPacketSender_setDeviceConnection, args)

    def getDeviceConnection(*args):
        """getDeviceConnection(self) -> ArDeviceConnection"""
        return apply(_AriaPy.ArRobotPacketSender_getDeviceConnection, args)

ArRobotPacketSender_swigregister = _AriaPy.ArRobotPacketSender_swigregister
ArRobotPacketSender_swigregister(ArRobotPacketSender)

class ArRobotParams(ArConfig):
    """Proxy of C++ ArRobotParams class"""
    __swig_setmethods__ = {}
    for _s in [ArConfig]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRobotParams, name, value)
    __swig_getmethods__ = {}
    for _s in [ArConfig]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRobotParams, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArRobotParams"""
        this = apply(_AriaPy.new_ArRobotParams, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRobotParams
    __del__ = lambda self : None;
    def getClassName(*args):
        """getClassName(self) -> char"""
        return apply(_AriaPy.ArRobotParams_getClassName, args)

    def getSubClassName(*args):
        """getSubClassName(self) -> char"""
        return apply(_AriaPy.ArRobotParams_getSubClassName, args)

    def getRobotRadius(*args):
        """getRobotRadius(self) -> double"""
        return apply(_AriaPy.ArRobotParams_getRobotRadius, args)

    def getRobotDiagonal(*args):
        """getRobotDiagonal(self) -> double"""
        return apply(_AriaPy.ArRobotParams_getRobotDiagonal, args)

    def getRobotWidth(*args):
        """getRobotWidth(self) -> double"""
        return apply(_AriaPy.ArRobotParams_getRobotWidth, args)

    def getRobotLength(*args):
        """getRobotLength(self) -> double"""
        return apply(_AriaPy.ArRobotParams_getRobotLength, args)

    def getRobotLengthFront(*args):
        """getRobotLengthFront(self) -> double"""
        return apply(_AriaPy.ArRobotParams_getRobotLengthFront, args)

    def getRobotLengthRear(*args):
        """getRobotLengthRear(self) -> double"""
        return apply(_AriaPy.ArRobotParams_getRobotLengthRear, args)

    def isHolonomic(*args):
        """isHolonomic(self) -> bool"""
        return apply(_AriaPy.ArRobotParams_isHolonomic, args)

    def hasMoveCommand(*args):
        """hasMoveCommand(self) -> bool"""
        return apply(_AriaPy.ArRobotParams_hasMoveCommand, args)

    def getAbsoluteMaxVelocity(*args):
        """getAbsoluteMaxVelocity(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getAbsoluteMaxVelocity, args)

    def getAbsoluteMaxRotVelocity(*args):
        """getAbsoluteMaxRotVelocity(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getAbsoluteMaxRotVelocity, args)

    def getAbsoluteMaxLatVelocity(*args):
        """getAbsoluteMaxLatVelocity(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getAbsoluteMaxLatVelocity, args)

    def getRequestIOPackets(*args):
        """getRequestIOPackets(self) -> bool"""
        return apply(_AriaPy.ArRobotParams_getRequestIOPackets, args)

    def getRequestEncoderPackets(*args):
        """getRequestEncoderPackets(self) -> bool"""
        return apply(_AriaPy.ArRobotParams_getRequestEncoderPackets, args)

    def getSwitchToBaudRate(*args):
        """getSwitchToBaudRate(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getSwitchToBaudRate, args)

    def getAngleConvFactor(*args):
        """getAngleConvFactor(self) -> double"""
        return apply(_AriaPy.ArRobotParams_getAngleConvFactor, args)

    def getDistConvFactor(*args):
        """getDistConvFactor(self) -> double"""
        return apply(_AriaPy.ArRobotParams_getDistConvFactor, args)

    def getVelConvFactor(*args):
        """getVelConvFactor(self) -> double"""
        return apply(_AriaPy.ArRobotParams_getVelConvFactor, args)

    def getRangeConvFactor(*args):
        """getRangeConvFactor(self) -> double"""
        return apply(_AriaPy.ArRobotParams_getRangeConvFactor, args)

    def getDiffConvFactor(*args):
        """getDiffConvFactor(self) -> double"""
        return apply(_AriaPy.ArRobotParams_getDiffConvFactor, args)

    def getVel2Divisor(*args):
        """getVel2Divisor(self) -> double"""
        return apply(_AriaPy.ArRobotParams_getVel2Divisor, args)

    def getGyroScaler(*args):
        """getGyroScaler(self) -> double"""
        return apply(_AriaPy.ArRobotParams_getGyroScaler, args)

    def haveTableSensingIR(*args):
        """haveTableSensingIR(self) -> bool"""
        return apply(_AriaPy.ArRobotParams_haveTableSensingIR, args)

    def haveNewTableSensingIR(*args):
        """haveNewTableSensingIR(self) -> bool"""
        return apply(_AriaPy.ArRobotParams_haveNewTableSensingIR, args)

    def haveFrontBumpers(*args):
        """haveFrontBumpers(self) -> bool"""
        return apply(_AriaPy.ArRobotParams_haveFrontBumpers, args)

    def numFrontBumpers(*args):
        """numFrontBumpers(self) -> int"""
        return apply(_AriaPy.ArRobotParams_numFrontBumpers, args)

    def haveRearBumpers(*args):
        """haveRearBumpers(self) -> bool"""
        return apply(_AriaPy.ArRobotParams_haveRearBumpers, args)

    def numRearBumpers(*args):
        """numRearBumpers(self) -> int"""
        return apply(_AriaPy.ArRobotParams_numRearBumpers, args)

    def getNumIR(*args):
        """getNumIR(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getNumIR, args)

    def haveIR(*args):
        """haveIR(self, int number) -> bool"""
        return apply(_AriaPy.ArRobotParams_haveIR, args)

    def getIRX(*args):
        """getIRX(self, int number) -> int"""
        return apply(_AriaPy.ArRobotParams_getIRX, args)

    def getIRY(*args):
        """getIRY(self, int number) -> int"""
        return apply(_AriaPy.ArRobotParams_getIRY, args)

    def getIRType(*args):
        """getIRType(self, int number) -> int"""
        return apply(_AriaPy.ArRobotParams_getIRType, args)

    def getIRCycles(*args):
        """getIRCycles(self, int number) -> int"""
        return apply(_AriaPy.ArRobotParams_getIRCycles, args)

    def getNumSonar(*args):
        """getNumSonar(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getNumSonar, args)

    def haveSonar(*args):
        """haveSonar(self, int number) -> bool"""
        return apply(_AriaPy.ArRobotParams_haveSonar, args)

    def getSonarX(*args):
        """getSonarX(self, int number) -> int"""
        return apply(_AriaPy.ArRobotParams_getSonarX, args)

    def getSonarY(*args):
        """getSonarY(self, int number) -> int"""
        return apply(_AriaPy.ArRobotParams_getSonarY, args)

    def getSonarTh(*args):
        """getSonarTh(self, int number) -> int"""
        return apply(_AriaPy.ArRobotParams_getSonarTh, args)

    def getLaserPossessed(*args):
        """getLaserPossessed(self) -> bool"""
        return apply(_AriaPy.ArRobotParams_getLaserPossessed, args)

    def getLaserType(*args):
        """
        getLaserType(self, int laserNumber=1) -> char
        getLaserType(self) -> char
        """
        return apply(_AriaPy.ArRobotParams_getLaserType, args)

    def getLaserPortType(*args):
        """
        getLaserPortType(self, int laserNumber=1) -> char
        getLaserPortType(self) -> char
        """
        return apply(_AriaPy.ArRobotParams_getLaserPortType, args)

    def getLaserPort(*args):
        """
        getLaserPort(self, int laserNumber=1) -> char
        getLaserPort(self) -> char
        """
        return apply(_AriaPy.ArRobotParams_getLaserPort, args)

    def getConnectLaser(*args):
        """
        getConnectLaser(self, int laserNumber=1) -> bool
        getConnectLaser(self) -> bool
        """
        return apply(_AriaPy.ArRobotParams_getConnectLaser, args)

    def getLaserFlipped(*args):
        """
        getLaserFlipped(self, int laserNumber=1) -> bool
        getLaserFlipped(self) -> bool
        """
        return apply(_AriaPy.ArRobotParams_getLaserFlipped, args)

    def getLaserPowerControlled(*args):
        """
        getLaserPowerControlled(self, int laserNumber=1) -> bool
        getLaserPowerControlled(self) -> bool
        """
        return apply(_AriaPy.ArRobotParams_getLaserPowerControlled, args)

    def getLaserMaxRange(*args):
        """
        getLaserMaxRange(self, int laserNumber=1) -> int
        getLaserMaxRange(self) -> int
        """
        return apply(_AriaPy.ArRobotParams_getLaserMaxRange, args)

    def getLaserCumulativeBufferSize(*args):
        """
        getLaserCumulativeBufferSize(self, int laserNumber=1) -> int
        getLaserCumulativeBufferSize(self) -> int
        """
        return apply(_AriaPy.ArRobotParams_getLaserCumulativeBufferSize, args)

    def getLaserX(*args):
        """
        getLaserX(self, int laserNumber=1) -> int
        getLaserX(self) -> int
        """
        return apply(_AriaPy.ArRobotParams_getLaserX, args)

    def getLaserY(*args):
        """
        getLaserY(self, int laserNumber=1) -> int
        getLaserY(self) -> int
        """
        return apply(_AriaPy.ArRobotParams_getLaserY, args)

    def getLaserTh(*args):
        """
        getLaserTh(self, int laserNumber=1) -> double
        getLaserTh(self) -> double
        """
        return apply(_AriaPy.ArRobotParams_getLaserTh, args)

    def getLaserZ(*args):
        """
        getLaserZ(self, int laserNumber=1) -> int
        getLaserZ(self) -> int
        """
        return apply(_AriaPy.ArRobotParams_getLaserZ, args)

    def getLaserIgnore(*args):
        """
        getLaserIgnore(self, int laserNumber=1) -> char
        getLaserIgnore(self) -> char
        """
        return apply(_AriaPy.ArRobotParams_getLaserIgnore, args)

    def getLaserStartDegrees(*args):
        """
        getLaserStartDegrees(self, int laserNumber=1) -> char
        getLaserStartDegrees(self) -> char
        """
        return apply(_AriaPy.ArRobotParams_getLaserStartDegrees, args)

    def getLaserEndDegrees(*args):
        """
        getLaserEndDegrees(self, int laserNumber=1) -> char
        getLaserEndDegrees(self) -> char
        """
        return apply(_AriaPy.ArRobotParams_getLaserEndDegrees, args)

    def getLaserDegreesChoice(*args):
        """
        getLaserDegreesChoice(self, int laserNumber=1) -> char
        getLaserDegreesChoice(self) -> char
        """
        return apply(_AriaPy.ArRobotParams_getLaserDegreesChoice, args)

    def getLaserIncrement(*args):
        """
        getLaserIncrement(self, int laserNumber=1) -> char
        getLaserIncrement(self) -> char
        """
        return apply(_AriaPy.ArRobotParams_getLaserIncrement, args)

    def getLaserIncrementChoice(*args):
        """
        getLaserIncrementChoice(self, int laserNumber=1) -> char
        getLaserIncrementChoice(self) -> char
        """
        return apply(_AriaPy.ArRobotParams_getLaserIncrementChoice, args)

    def getLaserUnitsChoice(*args):
        """
        getLaserUnitsChoice(self, int laserNumber=1) -> char
        getLaserUnitsChoice(self) -> char
        """
        return apply(_AriaPy.ArRobotParams_getLaserUnitsChoice, args)

    def getLaserReflectorBitsChoice(*args):
        """
        getLaserReflectorBitsChoice(self, int laserNumber=1) -> char
        getLaserReflectorBitsChoice(self) -> char
        """
        return apply(_AriaPy.ArRobotParams_getLaserReflectorBitsChoice, args)

    def getLaserStartingBaudChoice(*args):
        """
        getLaserStartingBaudChoice(self, int laserNumber=1) -> char
        getLaserStartingBaudChoice(self) -> char
        """
        return apply(_AriaPy.ArRobotParams_getLaserStartingBaudChoice, args)

    def getLaserAutoBaudChoice(*args):
        """
        getLaserAutoBaudChoice(self, int laserNumber=1) -> char
        getLaserAutoBaudChoice(self) -> char
        """
        return apply(_AriaPy.ArRobotParams_getLaserAutoBaudChoice, args)

    def hasSettableVelMaxes(*args):
        """hasSettableVelMaxes(self) -> bool"""
        return apply(_AriaPy.ArRobotParams_hasSettableVelMaxes, args)

    def getTransVelMax(*args):
        """getTransVelMax(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getTransVelMax, args)

    def getRotVelMax(*args):
        """getRotVelMax(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getRotVelMax, args)

    def hasSettableAccsDecs(*args):
        """hasSettableAccsDecs(self) -> bool"""
        return apply(_AriaPy.ArRobotParams_hasSettableAccsDecs, args)

    def getTransAccel(*args):
        """getTransAccel(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getTransAccel, args)

    def getTransDecel(*args):
        """getTransDecel(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getTransDecel, args)

    def getRotAccel(*args):
        """getRotAccel(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getRotAccel, args)

    def getRotDecel(*args):
        """getRotDecel(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getRotDecel, args)

    def hasLatVel(*args):
        """hasLatVel(self) -> bool"""
        return apply(_AriaPy.ArRobotParams_hasLatVel, args)

    def getLatVelMax(*args):
        """getLatVelMax(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getLatVelMax, args)

    def getLatAccel(*args):
        """getLatAccel(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getLatAccel, args)

    def getLatDecel(*args):
        """getLatDecel(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getLatDecel, args)

    def save(*args):
        """save(self) -> bool"""
        return apply(_AriaPy.ArRobotParams_save, args)

    def getGPSX(*args):
        """getGPSX(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getGPSX, args)

    def getGPSY(*args):
        """getGPSY(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getGPSY, args)

    def getGPSBaud(*args):
        """getGPSBaud(self) -> int"""
        return apply(_AriaPy.ArRobotParams_getGPSBaud, args)

    def getGPSPort(*args):
        """getGPSPort(self) -> char"""
        return apply(_AriaPy.ArRobotParams_getGPSPort, args)

    def getGPSType(*args):
        """getGPSType(self) -> char"""
        return apply(_AriaPy.ArRobotParams_getGPSType, args)

    def getCompassType(*args):
        """getCompassType(self) -> char"""
        return apply(_AriaPy.ArRobotParams_getCompassType, args)

    def getCompassPort(*args):
        """getCompassPort(self) -> char"""
        return apply(_AriaPy.ArRobotParams_getCompassPort, args)

ArRobotParams_swigregister = _AriaPy.ArRobotParams_swigregister
ArRobotParams_swigregister(ArRobotParams)

class ArRVisionPacket(ArBasePacket):
    """Proxy of C++ ArRVisionPacket class"""
    __swig_setmethods__ = {}
    for _s in [ArBasePacket]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRVisionPacket, name, value)
    __swig_getmethods__ = {}
    for _s in [ArBasePacket]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRVisionPacket, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, UByte2 bufferSize=15) -> ArRVisionPacket
        __init__(self) -> ArRVisionPacket
        """
        this = apply(_AriaPy.new_ArRVisionPacket, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRVisionPacket
    __del__ = lambda self : None;
    def uByteToBuf(*args):
        """uByteToBuf(self, UByte val)"""
        return apply(_AriaPy.ArRVisionPacket_uByteToBuf, args)

    def byte2ToBuf(*args):
        """byte2ToBuf(self, Byte2 val)"""
        return apply(_AriaPy.ArRVisionPacket_byte2ToBuf, args)

    def byte2ToBufAtPos(*args):
        """byte2ToBufAtPos(self, Byte2 val, UByte2 pose)"""
        return apply(_AriaPy.ArRVisionPacket_byte2ToBufAtPos, args)

ArRVisionPacket_swigregister = _AriaPy.ArRVisionPacket_swigregister
ArRVisionPacket_swigregister(ArRVisionPacket)

class ArRVisionPTZ(ArPTZ):
    """Proxy of C++ ArRVisionPTZ class"""
    __swig_setmethods__ = {}
    for _s in [ArPTZ]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArRVisionPTZ, name, value)
    __swig_getmethods__ = {}
    for _s in [ArPTZ]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArRVisionPTZ, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot) -> ArRVisionPTZ"""
        this = apply(_AriaPy.new_ArRVisionPTZ, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArRVisionPTZ
    __del__ = lambda self : None;
    def init(*args):
        """init(self) -> bool"""
        return apply(_AriaPy.ArRVisionPTZ_init, args)

    def pan(*args):
        """pan(self, double degrees) -> bool"""
        return apply(_AriaPy.ArRVisionPTZ_pan, args)

    def panRel(*args):
        """panRel(self, double degrees) -> bool"""
        return apply(_AriaPy.ArRVisionPTZ_panRel, args)

    def tilt(*args):
        """tilt(self, double degrees) -> bool"""
        return apply(_AriaPy.ArRVisionPTZ_tilt, args)

    def tiltRel(*args):
        """tiltRel(self, double degrees) -> bool"""
        return apply(_AriaPy.ArRVisionPTZ_tiltRel, args)

    def panTilt(*args):
        """panTilt(self, double degreesPan, double degreesTilt) -> bool"""
        return apply(_AriaPy.ArRVisionPTZ_panTilt, args)

    def panTiltRel(*args):
        """panTiltRel(self, double degreesPan, double degreesTilt) -> bool"""
        return apply(_AriaPy.ArRVisionPTZ_panTiltRel, args)

    def canZoom(*args):
        """canZoom(self) -> bool"""
        return apply(_AriaPy.ArRVisionPTZ_canZoom, args)

    def zoom(*args):
        """zoom(self, int zoomValue) -> bool"""
        return apply(_AriaPy.ArRVisionPTZ_zoom, args)

    def zoomRel(*args):
        """zoomRel(self, int zoomValue) -> bool"""
        return apply(_AriaPy.ArRVisionPTZ_zoomRel, args)

    def getPan(*args):
        """getPan(self) -> double"""
        return apply(_AriaPy.ArRVisionPTZ_getPan, args)

    def getTilt(*args):
        """getTilt(self) -> double"""
        return apply(_AriaPy.ArRVisionPTZ_getTilt, args)

    def getZoom(*args):
        """getZoom(self) -> int"""
        return apply(_AriaPy.ArRVisionPTZ_getZoom, args)

    def getMaxPosPan(*args):
        """getMaxPosPan(self) -> double"""
        return apply(_AriaPy.ArRVisionPTZ_getMaxPosPan, args)

    def getMaxNegPan(*args):
        """getMaxNegPan(self) -> double"""
        return apply(_AriaPy.ArRVisionPTZ_getMaxNegPan, args)

    def getMaxPosTilt(*args):
        """getMaxPosTilt(self) -> double"""
        return apply(_AriaPy.ArRVisionPTZ_getMaxPosTilt, args)

    def getMaxNegTilt(*args):
        """getMaxNegTilt(self) -> double"""
        return apply(_AriaPy.ArRVisionPTZ_getMaxNegTilt, args)

    def getMaxZoom(*args):
        """getMaxZoom(self) -> int"""
        return apply(_AriaPy.ArRVisionPTZ_getMaxZoom, args)

    def getMinZoom(*args):
        """getMinZoom(self) -> int"""
        return apply(_AriaPy.ArRVisionPTZ_getMinZoom, args)

    def canGetRealPanTilt(*args):
        """canGetRealPanTilt(self) -> bool"""
        return apply(_AriaPy.ArRVisionPTZ_canGetRealPanTilt, args)

    def canGetRealZoom(*args):
        """canGetRealZoom(self) -> bool"""
        return apply(_AriaPy.ArRVisionPTZ_canGetRealZoom, args)

    def canGetFOV(*args):
        """canGetFOV(self) -> bool"""
        return apply(_AriaPy.ArRVisionPTZ_canGetFOV, args)

    def getFOVAtMaxZoom(*args):
        """getFOVAtMaxZoom(self) -> double"""
        return apply(_AriaPy.ArRVisionPTZ_getFOVAtMaxZoom, args)

    def getFOVAtMinZoom(*args):
        """getFOVAtMinZoom(self) -> double"""
        return apply(_AriaPy.ArRVisionPTZ_getFOVAtMinZoom, args)

    def readPacket(*args):
        """readPacket(self) -> ArBasePacket"""
        return apply(_AriaPy.ArRVisionPTZ_readPacket, args)

    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:
    """Proxy of C++ ArSensorReading class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSensorReading, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArSensorReading, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, double xPos=0.0, double yPos=0.0, double thPos=0.0) -> ArSensorReading
        __init__(self, double xPos=0.0, double yPos=0.0) -> ArSensorReading
        __init__(self, double xPos=0.0) -> ArSensorReading
        __init__(self) -> ArSensorReading
        __init__(self, ArSensorReading reading) -> ArSensorReading
        """
        this = apply(_AriaPy.new_ArSensorReading, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSensorReading
    __del__ = lambda self : None;
    def getRange(*args):
        """getRange(self) -> unsigned int"""
        return apply(_AriaPy.ArSensorReading_getRange, args)

    def isNew(*args):
        """isNew(self, unsigned int counter) -> bool"""
        return apply(_AriaPy.ArSensorReading_isNew, args)

    def getX(*args):
        """getX(self) -> double"""
        return apply(_AriaPy.ArSensorReading_getX, args)

    def getY(*args):
        """getY(self) -> double"""
        return apply(_AriaPy.ArSensorReading_getY, args)

    def getPose(*args):
        """getPose(self) -> ArPose"""
        return apply(_AriaPy.ArSensorReading_getPose, args)

    def getLocalX(*args):
        """getLocalX(self) -> double"""
        return apply(_AriaPy.ArSensorReading_getLocalX, args)

    def getLocalY(*args):
        """getLocalY(self) -> double"""
        return apply(_AriaPy.ArSensorReading_getLocalY, args)

    def getLocalPose(*args):
        """getLocalPose(self) -> ArPose"""
        return apply(_AriaPy.ArSensorReading_getLocalPose, args)

    def getPoseTaken(*args):
        """getPoseTaken(self) -> ArPose"""
        return apply(_AriaPy.ArSensorReading_getPoseTaken, args)

    def getEncoderPoseTaken(*args):
        """getEncoderPoseTaken(self) -> ArPose"""
        return apply(_AriaPy.ArSensorReading_getEncoderPoseTaken, args)

    def getSensorX(*args):
        """getSensorX(self) -> double"""
        return apply(_AriaPy.ArSensorReading_getSensorX, args)

    def getSensorY(*args):
        """getSensorY(self) -> double"""
        return apply(_AriaPy.ArSensorReading_getSensorY, args)

    def getSensorTh(*args):
        """getSensorTh(self) -> double"""
        return apply(_AriaPy.ArSensorReading_getSensorTh, args)

    def getIgnoreThisReading(*args):
        """getIgnoreThisReading(self) -> bool"""
        return apply(_AriaPy.ArSensorReading_getIgnoreThisReading, args)

    def getExtraInt(*args):
        """getExtraInt(self) -> int"""
        return apply(_AriaPy.ArSensorReading_getExtraInt, args)

    def getSensorPosition(*args):
        """getSensorPosition(self) -> ArPose"""
        return apply(_AriaPy.ArSensorReading_getSensorPosition, args)

    def getSensorDX(*args):
        """getSensorDX(self) -> double"""
        return apply(_AriaPy.ArSensorReading_getSensorDX, args)

    def getSensorDY(*args):
        """getSensorDY(self) -> double"""
        return apply(_AriaPy.ArSensorReading_getSensorDY, args)

    def getXTaken(*args):
        """getXTaken(self) -> double"""
        return apply(_AriaPy.ArSensorReading_getXTaken, args)

    def getYTaken(*args):
        """getYTaken(self) -> double"""
        return apply(_AriaPy.ArSensorReading_getYTaken, args)

    def getThTaken(*args):
        """getThTaken(self) -> double"""
        return apply(_AriaPy.ArSensorReading_getThTaken, args)

    def getCounterTaken(*args):
        """getCounterTaken(self) -> unsigned int"""
        return apply(_AriaPy.ArSensorReading_getCounterTaken, args)

    def getTimeTaken(*args):
        """getTimeTaken(self) -> ArTime"""
        return apply(_AriaPy.ArSensorReading_getTimeTaken, args)

    def newData(*args):
        """
        newData(self, int range, ArPose robotPose, ArPose encoderPose, ArTransform trans, 
            unsigned int counter, ArTime timeTaken, 
            bool ignoreThisReading=False, int extraInt=0)
        newData(self, int range, ArPose robotPose, ArPose encoderPose, ArTransform trans, 
            unsigned int counter, ArTime timeTaken, 
            bool ignoreThisReading=False)
        newData(self, int range, ArPose robotPose, ArPose encoderPose, ArTransform trans, 
            unsigned int counter, ArTime timeTaken)
        newData(self, int sx, int sy, ArPose robotPose, ArPose encoderPose, 
            ArTransform trans, unsigned int counter, ArTime timeTaken, 
            bool ignoreThisReading=False, 
            int extraInt=0)
        newData(self, int sx, int sy, ArPose robotPose, ArPose encoderPose, 
            ArTransform trans, unsigned int counter, ArTime timeTaken, 
            bool ignoreThisReading=False)
        newData(self, int sx, int sy, ArPose robotPose, ArPose encoderPose, 
            ArTransform trans, unsigned int counter, ArTime timeTaken)
        """
        return apply(_AriaPy.ArSensorReading_newData, args)

    def resetSensorPosition(*args):
        """
        resetSensorPosition(self, double xPos, double yPos, double thPos, bool forceComputation=False)
        resetSensorPosition(self, double xPos, double yPos, double thPos)
        """
        return apply(_AriaPy.ArSensorReading_resetSensorPosition, args)

    def setIgnoreThisReading(*args):
        """setIgnoreThisReading(self, bool ignoreThisReading)"""
        return apply(_AriaPy.ArSensorReading_setIgnoreThisReading, args)

    def setExtraInt(*args):
        """setExtraInt(self, int extraInt)"""
        return apply(_AriaPy.ArSensorReading_setExtraInt, args)

    def applyTransform(*args):
        """applyTransform(self, ArTransform trans)"""
        return apply(_AriaPy.ArSensorReading_applyTransform, args)

    def applyEncoderTransform(*args):
        """applyEncoderTransform(self, ArTransform trans)"""
        return apply(_AriaPy.ArSensorReading_applyEncoderTransform, args)

    def getAdjusted(*args):
        """getAdjusted(self) -> bool"""
        return apply(_AriaPy.ArSensorReading_getAdjusted, args)

    def setAdjusted(*args):
        """setAdjusted(self, bool adjusted)"""
        return apply(_AriaPy.ArSensorReading_setAdjusted, args)

ArSensorReading_swigregister = _AriaPy.ArSensorReading_swigregister
ArSensorReading_swigregister(ArSensorReading)

TIOGETTIMESTAMP = _AriaPy.TIOGETTIMESTAMP
TIOSTARTTIMESTAMP = _AriaPy.TIOSTARTTIMESTAMP
class ArSerialConnection(ArDeviceConnection):
    """Proxy of C++ ArSerialConnection class"""
    __swig_setmethods__ = {}
    for _s in [ArDeviceConnection]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSerialConnection, name, value)
    __swig_getmethods__ = {}
    for _s in [ArDeviceConnection]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArSerialConnection, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArSerialConnection"""
        this = apply(_AriaPy.new_ArSerialConnection, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSerialConnection
    __del__ = lambda self : None;
    def open(*args):
        """
        open(self, char port=None) -> int
        open(self) -> int
        """
        return apply(_AriaPy.ArSerialConnection_open, args)

    def setPort(*args):
        """
        setPort(self, char port=None)
        setPort(self)
        """
        return apply(_AriaPy.ArSerialConnection_setPort, args)

    def getPort(*args):
        """getPort(self) -> char"""
        return apply(_AriaPy.ArSerialConnection_getPort, args)

    def openSimple(*args):
        """openSimple(self) -> bool"""
        return apply(_AriaPy.ArSerialConnection_openSimple, args)

    def getStatus(*args):
        """getStatus(self) -> int"""
        return apply(_AriaPy.ArSerialConnection_getStatus, args)

    def close(*args):
        """close(self) -> bool"""
        return apply(_AriaPy.ArSerialConnection_close, args)

    def read(*args):
        """
        read(self, char data, unsigned int size, unsigned int msWait=0) -> int
        read(self, char data, unsigned int size) -> int
        """
        return apply(_AriaPy.ArSerialConnection_read, args)

    def write(*args):
        """write(self, char data, unsigned int size) -> int"""
        return apply(_AriaPy.ArSerialConnection_write, args)

    def getOpenMessage(*args):
        """getOpenMessage(self, int messageNumber) -> char"""
        return apply(_AriaPy.ArSerialConnection_getOpenMessage, args)

    def setBaud(*args):
        """setBaud(self, int baud) -> bool"""
        return apply(_AriaPy.ArSerialConnection_setBaud, args)

    def getBaud(*args):
        """getBaud(self) -> int"""
        return apply(_AriaPy.ArSerialConnection_getBaud, args)

    def setHardwareControl(*args):
        """setHardwareControl(self, bool hardwareControl) -> bool"""
        return apply(_AriaPy.ArSerialConnection_setHardwareControl, args)

    def getHardwareControl(*args):
        """getHardwareControl(self) -> bool"""
        return apply(_AriaPy.ArSerialConnection_getHardwareControl, args)

    def getCTS(*args):
        """getCTS(self) -> bool"""
        return apply(_AriaPy.ArSerialConnection_getCTS, args)

    def getDSR(*args):
        """getDSR(self) -> bool"""
        return apply(_AriaPy.ArSerialConnection_getDSR, args)

    def getDCD(*args):
        """getDCD(self) -> bool"""
        return apply(_AriaPy.ArSerialConnection_getDCD, args)

    def getRing(*args):
        """getRing(self) -> bool"""
        return apply(_AriaPy.ArSerialConnection_getRing, args)

    def internalOpen(*args):
        """internalOpen(self) -> int"""
        return apply(_AriaPy.ArSerialConnection_internalOpen, args)

    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(*args):
        """getTimeRead(self, int index) -> ArTime"""
        return apply(_AriaPy.ArSerialConnection_getTimeRead, args)

    def isTimeStamping(*args):
        """isTimeStamping(self) -> bool"""
        return apply(_AriaPy.ArSerialConnection_isTimeStamping, args)

ArSerialConnection_swigregister = _AriaPy.ArSerialConnection_swigregister
ArSerialConnection_swigregister(ArSerialConnection)

class ArSick(ArLMS2xx):
    """Proxy of C++ ArSick class"""
    __swig_setmethods__ = {}
    for _s in [ArLMS2xx]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSick, name, value)
    __swig_getmethods__ = {}
    for _s in [ArLMS2xx]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArSick, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, size_t currentBufferSize=361, size_t cumulativeBufferSize=0, 
            char name="laser", bool addAriaExitCB=True, 
            bool isSecondLaser=False) -> ArSick
        __init__(self, size_t currentBufferSize=361, size_t cumulativeBufferSize=0, 
            char name="laser", bool addAriaExitCB=True) -> ArSick
        __init__(self, size_t currentBufferSize=361, size_t cumulativeBufferSize=0, 
            char name="laser") -> ArSick
        __init__(self, size_t currentBufferSize=361, size_t cumulativeBufferSize=0) -> ArSick
        __init__(self, size_t currentBufferSize=361) -> ArSick
        __init__(self) -> ArSick
        """
        this = apply(_AriaPy.new_ArSick, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSick
    __del__ = lambda self : None;
    BAUD9600 = _AriaPy.ArSick_BAUD9600
    BAUD19200 = _AriaPy.ArSick_BAUD19200
    BAUD38400 = _AriaPy.ArSick_BAUD38400
    BAUD_INVALID = _AriaPy.ArSick_BAUD_INVALID
    DEGREES180 = _AriaPy.ArSick_DEGREES180
    DEGREES100 = _AriaPy.ArSick_DEGREES100
    DEGREES_INVALID = _AriaPy.ArSick_DEGREES_INVALID
    INCREMENT_ONE = _AriaPy.ArSick_INCREMENT_ONE
    INCREMENT_HALF = _AriaPy.ArSick_INCREMENT_HALF
    INCREMENT_INVALID = _AriaPy.ArSick_INCREMENT_INVALID
    UNITS_1MM = _AriaPy.ArSick_UNITS_1MM
    UNITS_1CM = _AriaPy.ArSick_UNITS_1CM
    UNITS_10CM = _AriaPy.ArSick_UNITS_10CM
    UNITS_INVALID = _AriaPy.ArSick_UNITS_INVALID
    BITS_1REFLECTOR = _AriaPy.ArSick_BITS_1REFLECTOR
    BITS_2REFLECTOR = _AriaPy.ArSick_BITS_2REFLECTOR
    BITS_3REFLECTOR = _AriaPy.ArSick_BITS_3REFLECTOR
    BITS_INVALID = _AriaPy.ArSick_BITS_INVALID
    def tryingToConnect(*args):
        """tryingToConnect(self) -> bool"""
        return apply(_AriaPy.ArSick_tryingToConnect, args)

    def runOnRobot(*args):
        """runOnRobot(self) -> bool"""
        return apply(_AriaPy.ArSick_runOnRobot, args)

    def configure(*args):
        """
        configure(self, bool useSim=False, bool powerControl=True, bool laserFlipped=False, 
            BaudRate baud=BAUD38400, Degrees deg=DEGREES180, 
            Increment incr=INCREMENT_ONE)
        configure(self, bool useSim=False, bool powerControl=True, bool laserFlipped=False, 
            BaudRate baud=BAUD38400, Degrees deg=DEGREES180)
        configure(self, bool useSim=False, bool powerControl=True, bool laserFlipped=False, 
            BaudRate baud=BAUD38400)
        configure(self, bool useSim=False, bool powerControl=True, bool laserFlipped=False)
        configure(self, bool useSim=False, bool powerControl=True)
        configure(self, bool useSim=False)
        configure(self)
        """
        return apply(_AriaPy.ArSick_configure, args)

    def configureShort(*args):
        """
        configureShort(self, bool useSim=False, BaudRate baud=BAUD38400, Degrees deg=DEGREES180, 
            Increment incr=INCREMENT_ONE)
        configureShort(self, bool useSim=False, BaudRate baud=BAUD38400, Degrees deg=DEGREES180)
        configureShort(self, bool useSim=False, BaudRate baud=BAUD38400)
        configureShort(self, bool useSim=False)
        configureShort(self)
        """
        return apply(_AriaPy.ArSick_configureShort, args)

    def setRangeInformation(*args):
        """
        setRangeInformation(self, Bits bits=BITS_1REFLECTOR, Units units=UNITS_1MM)
        setRangeInformation(self, Bits bits=BITS_1REFLECTOR)
        setRangeInformation(self)
        """
        return apply(_AriaPy.ArSick_setRangeInformation, args)

    def isUsingSim(*args):
        """isUsingSim(self) -> bool"""
        return apply(_AriaPy.ArSick_isUsingSim, args)

    def isControllingPower(*args):
        """isControllingPower(self) -> bool"""
        return apply(_AriaPy.ArSick_isControllingPower, args)

    def isLaserFlipped(*args):
        """isLaserFlipped(self) -> bool"""
        return apply(_AriaPy.ArSick_isLaserFlipped, args)

    def getDegrees(*args):
        """getDegrees(self) -> int"""
        return apply(_AriaPy.ArSick_getDegrees, args)

    def getBits(*args):
        """getBits(self) -> int"""
        return apply(_AriaPy.ArSick_getBits, args)

    def getUnits(*args):
        """getUnits(self) -> int"""
        return apply(_AriaPy.ArSick_getUnits, args)

    def setIsUsingSim(*args):
        """setIsUsingSim(self, bool usingSim)"""
        return apply(_AriaPy.ArSick_setIsUsingSim, args)

    def setIsControllingPower(*args):
        """setIsControllingPower(self, bool controlPower)"""
        return apply(_AriaPy.ArSick_setIsControllingPower, args)

    def setIsLaserFlipped(*args):
        """setIsLaserFlipped(self, bool laserFlipped)"""
        return apply(_AriaPy.ArSick_setIsLaserFlipped, args)

    def setFilterCumulativeCleanDist(*args):
        """setFilterCumulativeCleanDist(self, double dist)"""
        return apply(_AriaPy.ArSick_setFilterCumulativeCleanDist, args)

    def getFilterCumulativeCleanDist(*args):
        """getFilterCumulativeCleanDist(self) -> double"""
        return apply(_AriaPy.ArSick_getFilterCumulativeCleanDist, args)

    def setFilterCleanCumulativeInterval(*args):
        """setFilterCleanCumulativeInterval(self, int milliSeconds)"""
        return apply(_AriaPy.ArSick_setFilterCleanCumulativeInterval, args)

    def getFilterCleanCumulativeInterval(*args):
        """getFilterCleanCumulativeInterval(self) -> int"""
        return apply(_AriaPy.ArSick_getFilterCleanCumulativeInterval, args)

    def setFilterCumulativeNearDist(*args):
        """setFilterCumulativeNearDist(self, double dist)"""
        return apply(_AriaPy.ArSick_setFilterCumulativeNearDist, args)

    def getFilterCumulativeNearDist(*args):
        """getFilterCumulativeNearDist(self) -> double"""
        return apply(_AriaPy.ArSick_getFilterCumulativeNearDist, args)

    def setFilterNearDist(*args):
        """setFilterNearDist(self, double dist)"""
        return apply(_AriaPy.ArSick_setFilterNearDist, args)

    def getFilterNearDist(*args):
        """getFilterNearDist(self) -> double"""
        return apply(_AriaPy.ArSick_getFilterNearDist, args)

    def setFilterCumulativeInsertMaxDist(*args):
        """setFilterCumulativeInsertMaxDist(self, double dist)"""
        return apply(_AriaPy.ArSick_setFilterCumulativeInsertMaxDist, args)

    def getFilterCumulativeInsertMaxDist(*args):
        """getFilterCumulativeInsertMaxDist(self) -> double"""
        return apply(_AriaPy.ArSick_getFilterCumulativeInsertMaxDist, args)

    def getMinRange(*args):
        """getMinRange(self) -> unsigned int"""
        return apply(_AriaPy.ArSick_getMinRange, args)

    def setMinRange(*args):
        """setMinRange(self, unsigned int minRange)"""
        return apply(_AriaPy.ArSick_setMinRange, args)

    def setFilterCumulativeMaxDist(*args):
        """setFilterCumulativeMaxDist(self, double dist)"""
        return apply(_AriaPy.ArSick_setFilterCumulativeMaxDist, args)

    def getFilterCumulativeMaxDist(*args):
        """getFilterCumulativeMaxDist(self) -> double"""
        return apply(_AriaPy.ArSick_getFilterCumulativeMaxDist, args)

    def setFilterCumulativeMaxAge(*args):
        """setFilterCumulativeMaxAge(self, int seconds)"""
        return apply(_AriaPy.ArSick_setFilterCumulativeMaxAge, args)

    def getFilterCumulativeMaxAge(*args):
        """getFilterCumulativeMaxAge(self) -> int"""
        return apply(_AriaPy.ArSick_getFilterCumulativeMaxAge, args)

    def getSickPacCount(*args):
        """getSickPacCount(self) -> int"""
        return apply(_AriaPy.ArSick_getSickPacCount, args)

    def addConnectCB(*args):
        """
        addConnectCB(self, ArFunctor functor, Pos position=LAST)
        addConnectCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArSick_addConnectCB, args)

    def remConnectCB(*args):
        """remConnectCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArSick_remConnectCB, args)

    def addFailedConnectCB(*args):
        """
        addFailedConnectCB(self, ArFunctor functor, Pos position=LAST)
        addFailedConnectCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArSick_addFailedConnectCB, args)

    def remFailedConnectCB(*args):
        """remFailedConnectCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArSick_remFailedConnectCB, args)

    def addDisconnectNormallyCB(*args):
        """
        addDisconnectNormallyCB(self, ArFunctor functor, Pos position=LAST)
        addDisconnectNormallyCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArSick_addDisconnectNormallyCB, args)

    def remDisconnectNormallyCB(*args):
        """remDisconnectNormallyCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArSick_remDisconnectNormallyCB, args)

    def addDisconnectOnErrorCB(*args):
        """
        addDisconnectOnErrorCB(self, ArFunctor functor, Pos position=LAST)
        addDisconnectOnErrorCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArSick_addDisconnectOnErrorCB, args)

    def remDisconnectOnErrorCB(*args):
        """remDisconnectOnErrorCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArSick_remDisconnectOnErrorCB, args)

    def addDataCB(*args):
        """
        addDataCB(self, ArFunctor functor, Pos position=LAST)
        addDataCB(self, ArFunctor functor)
        """
        return apply(_AriaPy.ArSick_addDataCB, args)

    def remDataCB(*args):
        """remDataCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArSick_remDataCB, args)

    def setConnectionTimeoutTime(*args):
        """setConnectionTimeoutTime(self, int secs)"""
        return apply(_AriaPy.ArSick_setConnectionTimeoutTime, args)

    def getConnectionTimeoutTime(*args):
        """getConnectionTimeoutTime(self) -> int"""
        return apply(_AriaPy.ArSick_getConnectionTimeoutTime, args)

ArSick_swigregister = _AriaPy.ArSick_swigregister
ArSick_swigregister(ArSick)

class ArSignalHandler(ArASyncTask):
    """Proxy of C++ ArSignalHandler class"""
    __swig_setmethods__ = {}
    for _s in [ArASyncTask]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSignalHandler, name, value)
    __swig_getmethods__ = {}
    for _s in [ArASyncTask]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArSignalHandler, name)
    def __init__(self): 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
    __swig_getmethods__["createHandlerNonThreaded"] = lambda x: _AriaPy.ArSignalHandler_createHandlerNonThreaded
    __swig_getmethods__["createHandlerThreaded"] = lambda x: _AriaPy.ArSignalHandler_createHandlerThreaded
    __swig_getmethods__["blockCommon"] = lambda x: _AriaPy.ArSignalHandler_blockCommon
    __swig_getmethods__["unblockAll"] = lambda x: _AriaPy.ArSignalHandler_unblockAll
    __swig_getmethods__["block"] = lambda x: _AriaPy.ArSignalHandler_block
    __swig_getmethods__["unblock"] = lambda x: _AriaPy.ArSignalHandler_unblock
    __swig_getmethods__["handle"] = lambda x: _AriaPy.ArSignalHandler_handle
    __swig_getmethods__["unhandle"] = lambda x: _AriaPy.ArSignalHandler_unhandle
    __swig_getmethods__["addHandlerCB"] = lambda x: _AriaPy.ArSignalHandler_addHandlerCB
    __swig_getmethods__["delHandlerCB"] = lambda x: _AriaPy.ArSignalHandler_delHandlerCB
    __swig_getmethods__["delAllHandlerCBs"] = lambda x: _AriaPy.ArSignalHandler_delAllHandlerCBs
    __swig_getmethods__["getHandler"] = lambda x: _AriaPy.ArSignalHandler_getHandler
    __swig_getmethods__["nameSignal"] = lambda x: _AriaPy.ArSignalHandler_nameSignal
    __swig_getmethods__["blockCommonThisThread"] = lambda x: _AriaPy.ArSignalHandler_blockCommonThisThread
    __swig_getmethods__["blockAllThisThread"] = lambda x: _AriaPy.ArSignalHandler_blockAllThisThread
    __swig_destroy__ = _AriaPy.delete_ArSignalHandler
    __del__ = lambda self : None;
    def runThread(*args):
        """runThread(self, void arg) -> void"""
        return apply(_AriaPy.ArSignalHandler_runThread, args)

    __swig_getmethods__["signalCB"] = lambda x: _AriaPy.ArSignalHandler_signalCB
    __swig_getmethods__["logThread"] = lambda x: _AriaPy.ArSignalHandler_logThread
ArSignalHandler_swigregister = _AriaPy.ArSignalHandler_swigregister
ArSignalHandler_swigregister(ArSignalHandler)

def ArSignalHandler_createHandlerNonThreaded(*args):
  """ArSignalHandler_createHandlerNonThreaded()"""
  return apply(_AriaPy.ArSignalHandler_createHandlerNonThreaded, args)

def ArSignalHandler_createHandlerThreaded(*args):
  """ArSignalHandler_createHandlerThreaded()"""
  return apply(_AriaPy.ArSignalHandler_createHandlerThreaded, args)

def ArSignalHandler_blockCommon(*args):
  """ArSignalHandler_blockCommon()"""
  return apply(_AriaPy.ArSignalHandler_blockCommon, args)

def ArSignalHandler_unblockAll(*args):
  """ArSignalHandler_unblockAll()"""
  return apply(_AriaPy.ArSignalHandler_unblockAll, args)

def ArSignalHandler_block(*args):
  """ArSignalHandler_block(Signal sig)"""
  return apply(_AriaPy.ArSignalHandler_block, args)

def ArSignalHandler_unblock(*args):
  """ArSignalHandler_unblock(Signal sig)"""
  return apply(_AriaPy.ArSignalHandler_unblock, args)

def ArSignalHandler_handle(*args):
  """ArSignalHandler_handle(Signal sig)"""
  return apply(_AriaPy.ArSignalHandler_handle, args)

def ArSignalHandler_unhandle(*args):
  """ArSignalHandler_unhandle(Signal sig)"""
  return apply(_AriaPy.ArSignalHandler_unhandle, args)

def ArSignalHandler_addHandlerCB(*args):
  """ArSignalHandler_addHandlerCB(ArFunctor1_Int func, Pos position)"""
  return apply(_AriaPy.ArSignalHandler_addHandlerCB, args)

def ArSignalHandler_delHandlerCB(*args):
  """ArSignalHandler_delHandlerCB(ArFunctor1_Int func)"""
  return apply(_AriaPy.ArSignalHandler_delHandlerCB, args)

def ArSignalHandler_delAllHandlerCBs(*args):
  """ArSignalHandler_delAllHandlerCBs()"""
  return apply(_AriaPy.ArSignalHandler_delAllHandlerCBs, args)

def ArSignalHandler_getHandler(*args):
  """ArSignalHandler_getHandler() -> ArSignalHandler"""
  return apply(_AriaPy.ArSignalHandler_getHandler, args)

def ArSignalHandler_nameSignal(*args):
  """ArSignalHandler_nameSignal(int sig) -> char"""
  return apply(_AriaPy.ArSignalHandler_nameSignal, args)

def ArSignalHandler_blockCommonThisThread(*args):
  """ArSignalHandler_blockCommonThisThread()"""
  return apply(_AriaPy.ArSignalHandler_blockCommonThisThread, args)

def ArSignalHandler_blockAllThisThread(*args):
  """ArSignalHandler_blockAllThisThread()"""
  return apply(_AriaPy.ArSignalHandler_blockAllThisThread, args)

def ArSignalHandler_signalCB(*args):
  """ArSignalHandler_signalCB(int sig)"""
  return apply(_AriaPy.ArSignalHandler_signalCB, args)

def ArSignalHandler_logThread(*args):
  """ArSignalHandler_logThread()"""
  return apply(_AriaPy.ArSignalHandler_logThread, args)

class ArSimpleConnector:
    """Proxy of C++ ArSimpleConnector class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSimpleConnector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArSimpleConnector, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, int argc) -> ArSimpleConnector
        __init__(self, ArArgumentBuilder arguments) -> ArSimpleConnector
        __init__(self, ArArgumentParser parser) -> ArSimpleConnector
        """
        this = apply(_AriaPy.new_ArSimpleConnector, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSimpleConnector
    __del__ = lambda self : None;
    def setupRobot(*args):
        """setupRobot(self, ArRobot robot) -> bool"""
        return apply(_AriaPy.ArSimpleConnector_setupRobot, args)

    def connectRobot(*args):
        """connectRobot(self, ArRobot robot) -> bool"""
        return apply(_AriaPy.ArSimpleConnector_connectRobot, args)

    def setupLaser(*args):
        """setupLaser(self, ArSick laser) -> bool"""
        return apply(_AriaPy.ArSimpleConnector_setupLaser, args)

    def setupSecondLaser(*args):
        """setupSecondLaser(self, ArSick laser) -> bool"""
        return apply(_AriaPy.ArSimpleConnector_setupSecondLaser, args)

    def setupLaserArbitrary(*args):
        """setupLaserArbitrary(self, ArSick laser, int laserNumber) -> bool"""
        return apply(_AriaPy.ArSimpleConnector_setupLaserArbitrary, args)

    def connectLaser(*args):
        """connectLaser(self, ArSick laser) -> bool"""
        return apply(_AriaPy.ArSimpleConnector_connectLaser, args)

    def connectSecondLaser(*args):
        """connectSecondLaser(self, ArSick laser) -> bool"""
        return apply(_AriaPy.ArSimpleConnector_connectSecondLaser, args)

    def connectLaserArbitrary(*args):
        """connectLaserArbitrary(self, ArSick laser, int laserNumber) -> bool"""
        return apply(_AriaPy.ArSimpleConnector_connectLaserArbitrary, args)

    def parseArgs(*args):
        """
        parseArgs(self) -> bool
        parseArgs(self, ArArgumentParser parser) -> bool
        """
        return apply(_AriaPy.ArSimpleConnector_parseArgs, args)

    def logOptions(*args):
        """logOptions(self)"""
        return apply(_AriaPy.ArSimpleConnector_logOptions, args)

    def setMaxNumLasers(*args):
        """
        setMaxNumLasers(self, int maxNumLasers=1)
        setMaxNumLasers(self)
        """
        return apply(_AriaPy.ArSimpleConnector_setMaxNumLasers, args)

ArSimpleConnector_swigregister = _AriaPy.ArSimpleConnector_swigregister
ArSimpleConnector_swigregister(ArSimpleConnector)

class ArSimulatedLaser(ArLaser):
    """Proxy of C++ ArSimulatedLaser class"""
    __swig_setmethods__ = {}
    for _s in [ArLaser]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSimulatedLaser, name, value)
    __swig_getmethods__ = {}
    for _s in [ArLaser]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArSimulatedLaser, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArLaser laser) -> ArSimulatedLaser"""
        this = apply(_AriaPy.new_ArSimulatedLaser, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSimulatedLaser
    __del__ = lambda self : None;
    def blockingConnect(*args):
        """blockingConnect(self) -> bool"""
        return apply(_AriaPy.ArSimulatedLaser_blockingConnect, args)

    def asyncConnect(*args):
        """asyncConnect(self) -> bool"""
        return apply(_AriaPy.ArSimulatedLaser_asyncConnect, args)

    def disconnect(*args):
        """disconnect(self) -> bool"""
        return apply(_AriaPy.ArSimulatedLaser_disconnect, args)

    def isConnected(*args):
        """isConnected(self) -> bool"""
        return apply(_AriaPy.ArSimulatedLaser_isConnected, args)

    def isTryingToConnect(*args):
        """isTryingToConnect(self) -> bool"""
        return apply(_AriaPy.ArSimulatedLaser_isTryingToConnect, args)

ArSimulatedLaser_swigregister = _AriaPy.ArSimulatedLaser_swigregister
ArSimulatedLaser_swigregister(ArSimulatedLaser)

class ArSocket:
    """Proxy of C++ ArSocket class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSocket, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArSocket, name)
    __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__(self) -> ArSocket
        __init__(self, char host, int port, Type type) -> ArSocket
        __init__(self, int port, bool doClose, Type type) -> ArSocket
        """
        this = apply(_AriaPy.new_ArSocket, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSocket
    __del__ = lambda self : None;
    __swig_getmethods__["init"] = lambda x: _AriaPy.ArSocket_init
    __swig_getmethods__["shutdown"] = lambda x: _AriaPy.ArSocket_shutdown
    __swig_setmethods__["ourInitialized"] = _AriaPy.ArSocket_ourInitialized_set
    __swig_getmethods__["ourInitialized"] = _AriaPy.ArSocket_ourInitialized_get
    def copy(*args):
        """
        copy(self, int fd, bool doclose) -> bool
        copy(self, ArSocket s)
        """
        return apply(_AriaPy.ArSocket_copy, args)

    def transfer(*args):
        """transfer(self, ArSocket s)"""
        return apply(_AriaPy.ArSocket_transfer, args)

    def connect(*args):
        """
        connect(self, char host, int port, Type type=TCP, char openOnIP=None) -> bool
        connect(self, char host, int port, Type type=TCP) -> bool
        connect(self, char host, int port) -> bool
        """
        return apply(_AriaPy.ArSocket_connect, args)

    def open(*args):
        """
        open(self, int port, Type type, char openOnIP=None) -> bool
        open(self, int port, Type type) -> bool
        """
        return apply(_AriaPy.ArSocket_open, args)

    def create(*args):
        """create(self, Type type) -> bool"""
        return apply(_AriaPy.ArSocket_create, args)

    def findValidPort(*args):
        """
        findValidPort(self, int startPort, char openOnIP=None) -> bool
        findValidPort(self, int startPort) -> bool
        """
        return apply(_AriaPy.ArSocket_findValidPort, args)

    def connectTo(*args):
        """
        connectTo(self, char host, int port) -> bool
        connectTo(self, sockaddr_in sin) -> bool
        """
        return apply(_AriaPy.ArSocket_connectTo, args)

    def accept(*args):
        """accept(self, ArSocket sock) -> bool"""
        return apply(_AriaPy.ArSocket_accept, args)

    def close(*args):
        """close(self) -> bool"""
        return apply(_AriaPy.ArSocket_close, args)

    def write(*args):
        """write(self, void buff, size_t len) -> int"""
        return apply(_AriaPy.ArSocket_write, args)

    def read(*args):
        """
        read(self, void buff, size_t len, unsigned int msWait=0) -> int
        read(self, void buff, size_t len) -> int
        """
        return apply(_AriaPy.ArSocket_read, args)

    def sendTo(*args):
        """
        sendTo(self, void msg, int len) -> int
        sendTo(self, void msg, int len, sockaddr_in sin) -> int
        """
        return apply(_AriaPy.ArSocket_sendTo, args)

    def recvFrom(*args):
        """recvFrom(self, void msg, int len, sockaddr_in sin) -> int"""
        return apply(_AriaPy.ArSocket_recvFrom, args)

    __swig_getmethods__["hostAddr"] = lambda x: _AriaPy.ArSocket_hostAddr
    __swig_getmethods__["addrHost"] = lambda x: _AriaPy.ArSocket_addrHost
    __swig_getmethods__["getHostName"] = lambda x: _AriaPy.ArSocket_getHostName
    def getSockName(*args):
        """getSockName(self) -> bool"""
        return apply(_AriaPy.ArSocket_getSockName, args)

    def sockAddrIn(*args):
        """sockAddrIn(self) -> sockaddr_in"""
        return apply(_AriaPy.ArSocket_sockAddrIn, args)

    def inAddr(*args):
        """inAddr(self) -> in_addr"""
        return apply(_AriaPy.ArSocket_inAddr, args)

    def inPort(*args):
        """inPort(self) -> unsigned short"""
        return apply(_AriaPy.ArSocket_inPort, args)

    __swig_getmethods__["inToA"] = lambda x: _AriaPy.ArSocket_inToA
    __swig_getmethods__["sockAddrLen"] = lambda x: _AriaPy.ArSocket_sockAddrLen
    __swig_getmethods__["maxHostNameLen"] = lambda x: _AriaPy.ArSocket_maxHostNameLen
    __swig_getmethods__["hostToNetOrder"] = lambda x: _AriaPy.ArSocket_hostToNetOrder
    __swig_getmethods__["netToHostOrder"] = lambda x: _AriaPy.ArSocket_netToHostOrder
    def setLinger(*args):
        """setLinger(self, int time) -> bool"""
        return apply(_AriaPy.ArSocket_setLinger, args)

    def setBroadcast(*args):
        """setBroadcast(self) -> bool"""
        return apply(_AriaPy.ArSocket_setBroadcast, args)

    def setReuseAddress(*args):
        """setReuseAddress(self) -> bool"""
        return apply(_AriaPy.ArSocket_setReuseAddress, args)

    def setNonBlock(*args):
        """setNonBlock(self) -> bool"""
        return apply(_AriaPy.ArSocket_setNonBlock, args)

    def setDoClose(*args):
        """setDoClose(self, bool yesno)"""
        return apply(_AriaPy.ArSocket_setDoClose, args)

    def getFD(*args):
        """getFD(self) -> int"""
        return apply(_AriaPy.ArSocket_getFD, args)

    def getType(*args):
        """getType(self) -> int"""
        return apply(_AriaPy.ArSocket_getType, args)

    def getErrorStr(*args):
        """getErrorStr(self) -> std::string"""
        return apply(_AriaPy.ArSocket_getErrorStr, args)

    def getError(*args):
        """getError(self) -> int"""
        return apply(_AriaPy.ArSocket_getError, args)

    def setErrorTracking(*args):
        """setErrorTracking(self, bool errorTracking)"""
        return apply(_AriaPy.ArSocket_setErrorTracking, args)

    def getErrorTracking(*args):
        """getErrorTracking(self) -> bool"""
        return apply(_AriaPy.ArSocket_getErrorTracking, args)

    def getBadWrite(*args):
        """getBadWrite(self) -> bool"""
        return apply(_AriaPy.ArSocket_getBadWrite, args)

    def getBadRead(*args):
        """getBadRead(self) -> bool"""
        return apply(_AriaPy.ArSocket_getBadRead, args)

    def writeStringPlain(*args):
        """writeStringPlain(self, char str) -> int"""
        return apply(_AriaPy.ArSocket_writeStringPlain, args)

    def readString(*args):
        """
        readString(self, unsigned int msWait=0) -> char
        readString(self) -> char
        """
        return apply(_AriaPy.ArSocket_readString, args)

    def setReadStringIgnoreReturn(*args):
        """setReadStringIgnoreReturn(self, bool ignore)"""
        return apply(_AriaPy.ArSocket_setReadStringIgnoreReturn, args)

    def clearPartialReadString(*args):
        """clearPartialReadString(self)"""
        return apply(_AriaPy.ArSocket_clearPartialReadString, args)

    def comparePartialReadString(*args):
        """comparePartialReadString(self, char partialString) -> int"""
        return apply(_AriaPy.ArSocket_comparePartialReadString, args)

    def getLastStringReadTime(*args):
        """getLastStringReadTime(self) -> ArTime"""
        return apply(_AriaPy.ArSocket_getLastStringReadTime, args)

    def setEcho(*args):
        """setEcho(self, bool echo)"""
        return apply(_AriaPy.ArSocket_setEcho, args)

    def getEcho(*args):
        """getEcho(self) -> bool"""
        return apply(_AriaPy.ArSocket_getEcho, args)

    def setLogWriteStrings(*args):
        """setLogWriteStrings(self, bool logWriteStrings)"""
        return apply(_AriaPy.ArSocket_setLogWriteStrings, args)

    def getLogWriteStrings(*args):
        """getLogWriteStrings(self) -> bool"""
        return apply(_AriaPy.ArSocket_getLogWriteStrings, args)

    def setStringUseWrongEndChars(*args):
        """setStringUseWrongEndChars(self, bool useWrongEndChars)"""
        return apply(_AriaPy.ArSocket_setStringUseWrongEndChars, args)

    def getStringUseWrongEndChars(*args):
        """getStringUseWrongEndChars(self) -> bool"""
        return apply(_AriaPy.ArSocket_getStringUseWrongEndChars, args)

    def getRawIPString(*args):
        """getRawIPString(self) -> char"""
        return apply(_AriaPy.ArSocket_getRawIPString, args)

    def getIPString(*args):
        """getIPString(self) -> char"""
        return apply(_AriaPy.ArSocket_getIPString, args)

    def setIPString(*args):
        """setIPString(self, char ipString)"""
        return apply(_AriaPy.ArSocket_setIPString, args)

    def setCloseCallback(*args):
        """setCloseCallback(self, ArFunctor functor)"""
        return apply(_AriaPy.ArSocket_setCloseCallback, args)

    def getCloseCallback(*args):
        """getCloseCallback(self) -> ArFunctor"""
        return apply(_AriaPy.ArSocket_getCloseCallback, args)

    def getSends(*args):
        """getSends(self) -> long"""
        return apply(_AriaPy.ArSocket_getSends, args)

    def getBytesSent(*args):
        """getBytesSent(self) -> long"""
        return apply(_AriaPy.ArSocket_getBytesSent, args)

    def getRecvs(*args):
        """getRecvs(self) -> long"""
        return apply(_AriaPy.ArSocket_getRecvs, args)

    def getBytesRecvd(*args):
        """getBytesRecvd(self) -> long"""
        return apply(_AriaPy.ArSocket_getBytesRecvd, args)

    def resetTracking(*args):
        """resetTracking(self)"""
        return apply(_AriaPy.ArSocket_resetTracking, args)

    def setNoDelay(*args):
        """setNoDelay(self, bool flag) -> bool"""
        return apply(_AriaPy.ArSocket_setNoDelay, args)

ArSocket_swigregister = _AriaPy.ArSocket_swigregister
ArSocket_swigregister(ArSocket)

def ArSocket_init(*args):
  """ArSocket_init() -> bool"""
  return apply(_AriaPy.ArSocket_init, args)

def ArSocket_shutdown(*args):
  """ArSocket_shutdown()"""
  return apply(_AriaPy.ArSocket_shutdown, args)

def ArSocket_hostAddr(*args):
  """ArSocket_hostAddr(char host, in_addr addr) -> bool"""
  return apply(_AriaPy.ArSocket_hostAddr, args)

def ArSocket_addrHost(*args):
  """ArSocket_addrHost(in_addr addr, char host) -> bool"""
  return apply(_AriaPy.ArSocket_addrHost, args)

def ArSocket_getHostName(*args):
  """ArSocket_getHostName() -> std::string"""
  return apply(_AriaPy.ArSocket_getHostName, args)

def ArSocket_inToA(*args):
  """ArSocket_inToA(in_addr addr, char buff)"""
  return apply(_AriaPy.ArSocket_inToA, args)

def ArSocket_sockAddrLen(*args):
  """ArSocket_sockAddrLen() -> size_t"""
  return apply(_AriaPy.ArSocket_sockAddrLen, args)

def ArSocket_maxHostNameLen(*args):
  """ArSocket_maxHostNameLen() -> size_t"""
  return apply(_AriaPy.ArSocket_maxHostNameLen, args)

def ArSocket_hostToNetOrder(*args):
  """ArSocket_hostToNetOrder(int i) -> unsigned int"""
  return apply(_AriaPy.ArSocket_hostToNetOrder, args)

def ArSocket_netToHostOrder(*args):
  """ArSocket_netToHostOrder(int i) -> unsigned int"""
  return apply(_AriaPy.ArSocket_netToHostOrder, args)

class ArSonarAutoDisabler:
    """Proxy of C++ ArSonarAutoDisabler class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSonarAutoDisabler, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArSonarAutoDisabler, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot) -> ArSonarAutoDisabler"""
        this = apply(_AriaPy.new_ArSonarAutoDisabler, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSonarAutoDisabler
    __del__ = lambda self : None;
ArSonarAutoDisabler_swigregister = _AriaPy.ArSonarAutoDisabler_swigregister
ArSonarAutoDisabler_swigregister(ArSonarAutoDisabler)

class ArSonarDevice(ArRangeDevice):
    """Proxy of C++ ArSonarDevice class"""
    __swig_setmethods__ = {}
    for _s in [ArRangeDevice]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSonarDevice, name, value)
    __swig_getmethods__ = {}
    for _s in [ArRangeDevice]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArSonarDevice, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, size_t currentBufferSize=24, size_t cumulativeBufferSize=64, 
            char name="sonar") -> ArSonarDevice
        __init__(self, size_t currentBufferSize=24, size_t cumulativeBufferSize=64) -> ArSonarDevice
        __init__(self, size_t currentBufferSize=24) -> ArSonarDevice
        __init__(self) -> ArSonarDevice
        """
        this = apply(_AriaPy.new_ArSonarDevice, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSonarDevice
    __del__ = lambda self : None;
    def processReadings(*args):
        """processReadings(self)"""
        return apply(_AriaPy.ArSonarDevice_processReadings, args)

    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArSonarDevice_setRobot, args)

    def addReading(*args):
        """addReading(self, double x, double y)"""
        return apply(_AriaPy.ArSonarDevice_addReading, args)

    def setCumulativeMaxRange(*args):
        """setCumulativeMaxRange(self, double range)"""
        return apply(_AriaPy.ArSonarDevice_setCumulativeMaxRange, args)

ArSonarDevice_swigregister = _AriaPy.ArSonarDevice_swigregister
ArSonarDevice_swigregister(ArSonarDevice)

class ArSonyPacket(ArBasePacket):
    """Proxy of C++ ArSonyPacket class"""
    __swig_setmethods__ = {}
    for _s in [ArBasePacket]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSonyPacket, name, value)
    __swig_getmethods__ = {}
    for _s in [ArBasePacket]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArSonyPacket, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, UByte2 bufferSize=15) -> ArSonyPacket
        __init__(self) -> ArSonyPacket
        """
        this = apply(_AriaPy.new_ArSonyPacket, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSonyPacket
    __del__ = lambda self : None;
    def uByteToBuf(*args):
        """uByteToBuf(self, UByte val)"""
        return apply(_AriaPy.ArSonyPacket_uByteToBuf, args)

    def byte2ToBuf(*args):
        """byte2ToBuf(self, Byte2 val)"""
        return apply(_AriaPy.ArSonyPacket_byte2ToBuf, args)

    def byte2ToBufAtPos(*args):
        """byte2ToBufAtPos(self, Byte2 val, UByte2 pose)"""
        return apply(_AriaPy.ArSonyPacket_byte2ToBufAtPos, args)

ArSonyPacket_swigregister = _AriaPy.ArSonyPacket_swigregister
ArSonyPacket_swigregister(ArSonyPacket)

class ArSonyPTZ(ArPTZ):
    """Proxy of C++ ArSonyPTZ class"""
    __swig_setmethods__ = {}
    for _s in [ArPTZ]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSonyPTZ, name, value)
    __swig_getmethods__ = {}
    for _s in [ArPTZ]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArSonyPTZ, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot) -> ArSonyPTZ"""
        this = apply(_AriaPy.new_ArSonyPTZ, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSonyPTZ
    __del__ = lambda self : None;
    def init(*args):
        """init(self) -> bool"""
        return apply(_AriaPy.ArSonyPTZ_init, args)

    def pan(*args):
        """pan(self, double degrees) -> bool"""
        return apply(_AriaPy.ArSonyPTZ_pan, args)

    def panRel(*args):
        """panRel(self, double degrees) -> bool"""
        return apply(_AriaPy.ArSonyPTZ_panRel, args)

    def tilt(*args):
        """tilt(self, double degrees) -> bool"""
        return apply(_AriaPy.ArSonyPTZ_tilt, args)

    def tiltRel(*args):
        """tiltRel(self, double degrees) -> bool"""
        return apply(_AriaPy.ArSonyPTZ_tiltRel, args)

    def panTilt(*args):
        """panTilt(self, double degreesPan, double degreesTilt) -> bool"""
        return apply(_AriaPy.ArSonyPTZ_panTilt, args)

    def panTiltRel(*args):
        """panTiltRel(self, double degreesPan, double degreesTilt) -> bool"""
        return apply(_AriaPy.ArSonyPTZ_panTiltRel, args)

    def canZoom(*args):
        """canZoom(self) -> bool"""
        return apply(_AriaPy.ArSonyPTZ_canZoom, args)

    def zoom(*args):
        """zoom(self, int zoomValue) -> bool"""
        return apply(_AriaPy.ArSonyPTZ_zoom, args)

    def zoomRel(*args):
        """zoomRel(self, int zoomValue) -> bool"""
        return apply(_AriaPy.ArSonyPTZ_zoomRel, args)

    def getPan(*args):
        """getPan(self) -> double"""
        return apply(_AriaPy.ArSonyPTZ_getPan, args)

    def getTilt(*args):
        """getTilt(self) -> double"""
        return apply(_AriaPy.ArSonyPTZ_getTilt, args)

    def getZoom(*args):
        """getZoom(self) -> int"""
        return apply(_AriaPy.ArSonyPTZ_getZoom, args)

    def getMaxPosPan(*args):
        """getMaxPosPan(self) -> double"""
        return apply(_AriaPy.ArSonyPTZ_getMaxPosPan, args)

    def getMaxNegPan(*args):
        """getMaxNegPan(self) -> double"""
        return apply(_AriaPy.ArSonyPTZ_getMaxNegPan, args)

    def getMaxPosTilt(*args):
        """getMaxPosTilt(self) -> double"""
        return apply(_AriaPy.ArSonyPTZ_getMaxPosTilt, args)

    def getMaxNegTilt(*args):
        """getMaxNegTilt(self) -> double"""
        return apply(_AriaPy.ArSonyPTZ_getMaxNegTilt, args)

    def getMaxZoom(*args):
        """getMaxZoom(self) -> int"""
        return apply(_AriaPy.ArSonyPTZ_getMaxZoom, args)

    def getMinZoom(*args):
        """getMinZoom(self) -> int"""
        return apply(_AriaPy.ArSonyPTZ_getMinZoom, args)

    def canGetFOV(*args):
        """canGetFOV(self) -> bool"""
        return apply(_AriaPy.ArSonyPTZ_canGetFOV, args)

    def getFOVAtMaxZoom(*args):
        """getFOVAtMaxZoom(self) -> double"""
        return apply(_AriaPy.ArSonyPTZ_getFOVAtMaxZoom, args)

    def getFOVAtMinZoom(*args):
        """getFOVAtMinZoom(self) -> double"""
        return apply(_AriaPy.ArSonyPTZ_getFOVAtMinZoom, args)

    def backLightingOn(*args):
        """backLightingOn(self) -> bool"""
        return apply(_AriaPy.ArSonyPTZ_backLightingOn, args)

    def backLightingOff(*args):
        """backLightingOff(self) -> bool"""
        return apply(_AriaPy.ArSonyPTZ_backLightingOff, args)

    MAX_PAN = _AriaPy.ArSonyPTZ_MAX_PAN
    MAX_TILT = _AriaPy.ArSonyPTZ_MAX_TILT
    MIN_ZOOM = _AriaPy.ArSonyPTZ_MIN_ZOOM
    MAX_ZOOM = _AriaPy.ArSonyPTZ_MAX_ZOOM
ArSonyPTZ_swigregister = _AriaPy.ArSonyPTZ_swigregister
ArSonyPTZ_swigregister(ArSonyPTZ)

class ArSoundPlayer:
    """Proxy of C++ ArSoundPlayer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSoundPlayer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArSoundPlayer, name)
    __repr__ = _swig_repr
    __swig_getmethods__["playWavFile"] = lambda x: _AriaPy.ArSoundPlayer_playWavFile
    __swig_getmethods__["playNativeFile"] = lambda x: _AriaPy.ArSoundPlayer_playNativeFile
    __swig_getmethods__["stopPlaying"] = lambda x: _AriaPy.ArSoundPlayer_stopPlaying
    __swig_getmethods__["getPlayWavFileCallback"] = lambda x: _AriaPy.ArSoundPlayer_getPlayWavFileCallback
    __swig_getmethods__["getStopPlayingCallback"] = lambda x: _AriaPy.ArSoundPlayer_getStopPlayingCallback
    __swig_getmethods__["playSoundPCM16"] = lambda x: _AriaPy.ArSoundPlayer_playSoundPCM16
    def __init__(self, *args): 
        """__init__(self) -> ArSoundPlayer"""
        this = apply(_AriaPy.new_ArSoundPlayer, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSoundPlayer
    __del__ = lambda self : None;
ArSoundPlayer_swigregister = _AriaPy.ArSoundPlayer_swigregister
ArSoundPlayer_swigregister(ArSoundPlayer)

def ArSoundPlayer_playWavFile(*args):
  """ArSoundPlayer_playWavFile(char filename, char params) -> bool"""
  return apply(_AriaPy.ArSoundPlayer_playWavFile, args)

def ArSoundPlayer_playNativeFile(*args):
  """ArSoundPlayer_playNativeFile(char filename, char params) -> bool"""
  return apply(_AriaPy.ArSoundPlayer_playNativeFile, args)

def ArSoundPlayer_stopPlaying(*args):
  """ArSoundPlayer_stopPlaying()"""
  return apply(_AriaPy.ArSoundPlayer_stopPlaying, args)

def ArSoundPlayer_getPlayWavFileCallback(*args):
  """ArSoundPlayer_getPlayWavFileCallback() -> ArRetFunctor2<(bool,p.q(const).char,p.q(const).char)>"""
  return apply(_AriaPy.ArSoundPlayer_getPlayWavFileCallback, args)

def ArSoundPlayer_getStopPlayingCallback(*args):
  """ArSoundPlayer_getStopPlayingCallback() -> ArFunctor"""
  return apply(_AriaPy.ArSoundPlayer_getStopPlayingCallback, args)

def ArSoundPlayer_playSoundPCM16(*args):
  """ArSoundPlayer_playSoundPCM16(char data, int numSamples) -> bool"""
  return apply(_AriaPy.ArSoundPlayer_playSoundPCM16, args)

class ArSoundsQueue(ArASyncTask):
    """Proxy of C++ ArSoundsQueue class"""
    __swig_setmethods__ = {}
    for _s in [ArASyncTask]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSoundsQueue, name, value)
    __swig_getmethods__ = {}
    for _s in [ArASyncTask]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArSoundsQueue, name)
    __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__(self) -> ArSoundsQueue
        __init__(self, ArRetFunctor_Bool speakInitCB, PlayItemFunctor speakCB=0, 
            InterruptItemFunctor interruptSpeechCB=0, 
            ArRetFunctor_Bool playInitCB=0, PlayItemFunctor playFileCB=0, 
            InterruptItemFunctor interruptFileCB=0) -> ArSoundsQueue
        __init__(self, ArRetFunctor_Bool speakInitCB, PlayItemFunctor speakCB=0, 
            InterruptItemFunctor interruptSpeechCB=0, 
            ArRetFunctor_Bool playInitCB=0, PlayItemFunctor playFileCB=0) -> ArSoundsQueue
        __init__(self, ArRetFunctor_Bool speakInitCB, PlayItemFunctor speakCB=0, 
            InterruptItemFunctor interruptSpeechCB=0, 
            ArRetFunctor_Bool playInitCB=0) -> ArSoundsQueue
        __init__(self, ArRetFunctor_Bool speakInitCB, PlayItemFunctor speakCB=0, 
            InterruptItemFunctor interruptSpeechCB=0) -> ArSoundsQueue
        __init__(self, ArRetFunctor_Bool speakInitCB, PlayItemFunctor speakCB=0) -> ArSoundsQueue
        __init__(self, ArRetFunctor_Bool speakInitCB) -> ArSoundsQueue
        __init__(self, ArSpeechSynth speechSynthesizer, ArRetFunctor_Bool playInitCB=0, 
            PlayItemFunctor playFileCB=0, InterruptItemFunctor interruptFileCB=0) -> ArSoundsQueue
        __init__(self, ArSpeechSynth speechSynthesizer, ArRetFunctor_Bool playInitCB=0, 
            PlayItemFunctor playFileCB=0) -> ArSoundsQueue
        __init__(self, ArSpeechSynth speechSynthesizer, ArRetFunctor_Bool playInitCB=0) -> ArSoundsQueue
        __init__(self, ArSpeechSynth speechSynthesizer) -> ArSoundsQueue
        """
        this = apply(_AriaPy.new_ArSoundsQueue, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSoundsQueue
    __del__ = lambda self : None;
    def addInitCallback(*args):
        """addInitCallback(self, ArRetFunctor_Bool cb)"""
        return apply(_AriaPy.ArSoundsQueue_addInitCallback, args)

    def setSpeakInitCallback(*args):
        """setSpeakInitCallback(self, ArRetFunctor_Bool cb)"""
        return apply(_AriaPy.ArSoundsQueue_setSpeakInitCallback, args)

    def addItem(*args):
        """
        addItem(self, ArSoundsQueue::Item item)
        addItem(self, ItemType type, char data, std::list<(p.ArSoundsQueue::PlayItemFunctor,std::allocator<(p.ArSoundsQueue::PlayItemFunctor)>)> callbacks, 
            int priority=0, 
            char params=0)
        addItem(self, ItemType type, char data, std::list<(p.ArSoundsQueue::PlayItemFunctor,std::allocator<(p.ArSoundsQueue::PlayItemFunctor)>)> callbacks, 
            int priority=0)
        addItem(self, ItemType type, char data, std::list<(p.ArSoundsQueue::PlayItemFunctor,std::allocator<(p.ArSoundsQueue::PlayItemFunctor)>)> callbacks)
        """
        return apply(_AriaPy.ArSoundsQueue_addItem, args)

    def isInitialized(*args):
        """isInitialized(self) -> bool"""
        return apply(_AriaPy.ArSoundsQueue_isInitialized, args)

    def isSpeakingOrPlaying(*args):
        """isSpeakingOrPlaying(self) -> bool"""
        return apply(_AriaPy.ArSoundsQueue_isSpeakingOrPlaying, args)

    def isPlaying(*args):
        """isPlaying(self) -> bool"""
        return apply(_AriaPy.ArSoundsQueue_isPlaying, args)

    def isSpeaking(*args):
        """isSpeaking(self) -> bool"""
        return apply(_AriaPy.ArSoundsQueue_isSpeaking, args)

    def run(*args):
        """run(self)"""
        return apply(_AriaPy.ArSoundsQueue_run, args)

    def runAsync(*args):
        """runAsync(self)"""
        return apply(_AriaPy.ArSoundsQueue_runAsync, args)

    def pause(*args):
        """pause(self)"""
        return apply(_AriaPy.ArSoundsQueue_pause, args)

    def resume(*args):
        """resume(self)"""
        return apply(_AriaPy.ArSoundsQueue_resume, args)

    def isPaused(*args):
        """isPaused(self) -> bool"""
        return apply(_AriaPy.ArSoundsQueue_isPaused, args)

    def interrupt(*args):
        """interrupt(self)"""
        return apply(_AriaPy.ArSoundsQueue_interrupt, args)

    def clearQueue(*args):
        """clearQueue(self)"""
        return apply(_AriaPy.ArSoundsQueue_clearQueue, args)

    def stop(*args):
        """stop(self)"""
        return apply(_AriaPy.ArSoundsQueue_stop, args)

    def getPauseCallback(*args):
        """getPauseCallback(self) -> ArFunctor"""
        return apply(_AriaPy.ArSoundsQueue_getPauseCallback, args)

    def getResumeCallback(*args):
        """getResumeCallback(self) -> ArFunctor"""
        return apply(_AriaPy.ArSoundsQueue_getResumeCallback, args)

    def getCurrentQueueSize(*args):
        """getCurrentQueueSize(self) -> size_t"""
        return apply(_AriaPy.ArSoundsQueue_getCurrentQueueSize, args)

    def addSoundStartedCallback(*args):
        """addSoundStartedCallback(self, ArFunctor f)"""
        return apply(_AriaPy.ArSoundsQueue_addSoundStartedCallback, args)

    def remSoundStartedCallback(*args):
        """remSoundStartedCallback(self, ArFunctor f)"""
        return apply(_AriaPy.ArSoundsQueue_remSoundStartedCallback, args)

    def addSoundFinishedCallback(*args):
        """addSoundFinishedCallback(self, ArFunctor f)"""
        return apply(_AriaPy.ArSoundsQueue_addSoundFinishedCallback, args)

    def remSoundFinishedCallback(*args):
        """remSoundFinishedCallback(self, ArFunctor f)"""
        return apply(_AriaPy.ArSoundsQueue_remSoundFinishedCallback, args)

    def addQueueNonemptyCallback(*args):
        """addQueueNonemptyCallback(self, ArFunctor f)"""
        return apply(_AriaPy.ArSoundsQueue_addQueueNonemptyCallback, args)

    def remQueueNonemptyCallback(*args):
        """remQueueNonemptyCallback(self, ArFunctor f)"""
        return apply(_AriaPy.ArSoundsQueue_remQueueNonemptyCallback, args)

    def addQueueEmptyCallback(*args):
        """addQueueEmptyCallback(self, ArFunctor f)"""
        return apply(_AriaPy.ArSoundsQueue_addQueueEmptyCallback, args)

    def remQueueEmptyCallback(*args):
        """remQueueEmptyCallback(self, ArFunctor f)"""
        return apply(_AriaPy.ArSoundsQueue_remQueueEmptyCallback, args)

    def findPendingItems(*args):
        """findPendingItems(self, char item) -> IntSet"""
        return apply(_AriaPy.ArSoundsQueue_findPendingItems, args)

    def removePendingItems(*args):
        """
        removePendingItems(self, char item, ItemType type)
        removePendingItems(self, char data)
        """
        return apply(_AriaPy.ArSoundsQueue_removePendingItems, args)

    def removePendingItemsByPriority(*args):
        """removePendingItemsByPriority(self, int priority)"""
        return apply(_AriaPy.ArSoundsQueue_removePendingItemsByPriority, args)

    def removePendingItemsByPriorityWithType(*args):
        """removePendingItemsByPriorityWithType(self, int priority, ItemType type)"""
        return apply(_AriaPy.ArSoundsQueue_removePendingItemsByPriorityWithType, args)

    def removePendingItemsByType(*args):
        """removePendingItemsByType(self, ItemType type)"""
        return apply(_AriaPy.ArSoundsQueue_removePendingItemsByType, args)

    def nextItemByType(*args):
        """nextItemByType(self, ItemType type) -> std::string"""
        return apply(_AriaPy.ArSoundsQueue_nextItemByType, args)

    def nextItemByPriority(*args):
        """nextItemByPriority(self, int priority) -> std::string"""
        return apply(_AriaPy.ArSoundsQueue_nextItemByPriority, args)

    def nextItemByTypeAndPriority(*args):
        """nextItemByTypeAndPriority(self, ItemType type, int priority) -> std::string"""
        return apply(_AriaPy.ArSoundsQueue_nextItemByTypeAndPriority, args)

    def setSpeakCallback(*args):
        """setSpeakCallback(self, PlayItemFunctor cb)"""
        return apply(_AriaPy.ArSoundsQueue_setSpeakCallback, args)

    def setInterruptSpeechCallback(*args):
        """setInterruptSpeechCallback(self, InterruptItemFunctor cb)"""
        return apply(_AriaPy.ArSoundsQueue_setInterruptSpeechCallback, args)

    def setPlayFileCallback(*args):
        """setPlayFileCallback(self, PlayItemFunctor cb)"""
        return apply(_AriaPy.ArSoundsQueue_setPlayFileCallback, args)

    def setPlayWavFileCallback(*args):
        """setPlayWavFileCallback(self, PlayItemFunctor cb)"""
        return apply(_AriaPy.ArSoundsQueue_setPlayWavFileCallback, args)

    def setInterruptFileCallback(*args):
        """setInterruptFileCallback(self, InterruptItemFunctor cb)"""
        return apply(_AriaPy.ArSoundsQueue_setInterruptFileCallback, args)

    def setInterruptWavFileCallback(*args):
        """setInterruptWavFileCallback(self, InterruptItemFunctor cb)"""
        return apply(_AriaPy.ArSoundsQueue_setInterruptWavFileCallback, args)

    def speak(*args):
        """speak(self, char str)"""
        return apply(_AriaPy.ArSoundsQueue_speak, args)

    def play(*args):
        """play(self, char filename)"""
        return apply(_AriaPy.ArSoundsQueue_play, args)

    def createDefaultSpeechItem(*args):
        """
        createDefaultSpeechItem(self, char speech=0) -> ArSoundsQueue::Item
        createDefaultSpeechItem(self) -> ArSoundsQueue::Item
        """
        return apply(_AriaPy.ArSoundsQueue_createDefaultSpeechItem, args)

    def createDefaultFileItem(*args):
        """
        createDefaultFileItem(self, char filename=0) -> ArSoundsQueue::Item
        createDefaultFileItem(self) -> ArSoundsQueue::Item
        """
        return apply(_AriaPy.ArSoundsQueue_createDefaultFileItem, args)

    def setDefaultPlayConditionCB(*args):
        """setDefaultPlayConditionCB(self, PlaybackConditionFunctor f)"""
        return apply(_AriaPy.ArSoundsQueue_setDefaultPlayConditionCB, args)

    def runThread(*args):
        """runThread(self, void arg) -> void"""
        return apply(_AriaPy.ArSoundsQueue_runThread, args)

ArSoundsQueue_swigregister = _AriaPy.ArSoundsQueue_swigregister
ArSoundsQueue_swigregister(ArSoundsQueue)

class ArSpeechSynth:
    """Proxy of C++ ArSpeechSynth class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSpeechSynth, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArSpeechSynth, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArSpeechSynth
    __del__ = lambda self : None;
    def init(*args):
        """init(self) -> bool"""
        return apply(_AriaPy.ArSpeechSynth_init, args)

    def addToConfig(*args):
        """addToConfig(self, ArConfig config)"""
        return apply(_AriaPy.ArSpeechSynth_addToConfig, args)

    def speak(*args):
        """
        speak(self, char str, char voiceParams, ArRetFunctor2<(bool,p.ArTypes::Byte2,int)> audioOutputCB, 
            unsigned short sampleRate=0) -> bool
        speak(self, char str, char voiceParams, ArRetFunctor2<(bool,p.ArTypes::Byte2,int)> audioOutputCB) -> bool
        speak(self, char str, char voiceParams=None) -> bool
        speak(self, char str) -> bool
        """
        return apply(_AriaPy.ArSpeechSynth_speak, args)

    def speakf(*args):
        """speakf(self, char fmt, v(...) ?) -> bool"""
        return apply(_AriaPy.ArSpeechSynth_speakf, args)

    def interrupt(*args):
        """interrupt(self)"""
        return apply(_AriaPy.ArSpeechSynth_interrupt, args)

    def getInitCallback(*args):
        """getInitCallback(self) -> ArRetFunctorC<(bool,ArSpeechSynth)>"""
        return apply(_AriaPy.ArSpeechSynth_getInitCallback, args)

    def getSpeakCallback(*args):
        """getSpeakCallback(self) -> ArRetFunctor2C<(bool,ArSpeechSynth,p.q(const).char,p.q(const).char)>"""
        return apply(_AriaPy.ArSpeechSynth_getSpeakCallback, args)

    def getInterruptCallback(*args):
        """getInterruptCallback(self) -> ArFunctorC<(ArSpeechSynth)>"""
        return apply(_AriaPy.ArSpeechSynth_getInterruptCallback, args)

    def setAudioCallback(*args):
        """setAudioCallback(self, ArRetFunctor2<(bool,p.ArTypes::Byte2,int)> cb)"""
        return apply(_AriaPy.ArSpeechSynth_setAudioCallback, args)

    def setAudioSampleRate(*args):
        """setAudioSampleRate(self, int rate)"""
        return apply(_AriaPy.ArSpeechSynth_setAudioSampleRate, args)

    def getAudioSampleRate(*args):
        """getAudioSampleRate(self) -> int"""
        return apply(_AriaPy.ArSpeechSynth_getAudioSampleRate, args)

    def lock(*args):
        """lock(self)"""
        return apply(_AriaPy.ArSpeechSynth_lock, args)

    def unlock(*args):
        """unlock(self)"""
        return apply(_AriaPy.ArSpeechSynth_unlock, args)

    def setVoice(*args):
        """setVoice(self, char name) -> bool"""
        return apply(_AriaPy.ArSpeechSynth_setVoice, args)

    def getCurrentVoiceName(*args):
        """getCurrentVoiceName(self) -> char"""
        return apply(_AriaPy.ArSpeechSynth_getCurrentVoiceName, args)

    def getVoiceNames(*args):
        """getVoiceNames(self) -> std::list<(std::string,std::allocator<(std::string)>)>"""
        return apply(_AriaPy.ArSpeechSynth_getVoiceNames, args)

ArSpeechSynth_swigregister = _AriaPy.ArSpeechSynth_swigregister
ArSpeechSynth_swigregister(ArSpeechSynth)

class ArStringInfoGroup:
    """Proxy of C++ ArStringInfoGroup class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArStringInfoGroup, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArStringInfoGroup, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArStringInfoGroup"""
        this = apply(_AriaPy.new_ArStringInfoGroup, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArStringInfoGroup
    __del__ = lambda self : None;
    def addString(*args):
        """addString(self, char name, UByte2 maxLen, ArFunctor2<(p.char,ArTypes::UByte2)> functor) -> bool"""
        return apply(_AriaPy.ArStringInfoGroup_addString, args)

    def addStringInt(*args):
        """
        addStringInt(self, char name, UByte2 maxLen, ArRetFunctor_Int functor, 
            char format="%d") -> bool
        addStringInt(self, char name, UByte2 maxLen, ArRetFunctor_Int functor) -> bool
        """
        return apply(_AriaPy.ArStringInfoGroup_addStringInt, args)

    def addStringDouble(*args):
        """
        addStringDouble(self, char name, UByte2 maxLen, ArRetFunctor_Double functor, 
            char format="%g") -> bool
        addStringDouble(self, char name, UByte2 maxLen, ArRetFunctor_Double functor) -> bool
        """
        return apply(_AriaPy.ArStringInfoGroup_addStringDouble, args)

    def addStringBool(*args):
        """
        addStringBool(self, char name, UByte2 maxLen, ArRetFunctor_Bool functor, 
            char format="%s") -> bool
        addStringBool(self, char name, UByte2 maxLen, ArRetFunctor_Bool functor) -> bool
        """
        return apply(_AriaPy.ArStringInfoGroup_addStringBool, args)

    def addStringString(*args):
        """
        addStringString(self, char name, UByte2 maxLen, ArRetFunctor<(p.q(const).char)> functor, 
            char format="%s") -> bool
        addStringString(self, char name, UByte2 maxLen, ArRetFunctor<(p.q(const).char)> functor) -> bool
        """
        return apply(_AriaPy.ArStringInfoGroup_addStringString, args)

    def addAddStringCallback(*args):
        """
        addAddStringCallback(self, ArFunctor3<(p.q(const).char,ArTypes::UByte2,p.ArFunctor2<(p.char,ArTypes::UByte2)>)> functor, 
            Pos position=LAST)
        addAddStringCallback(self, ArFunctor3<(p.q(const).char,ArTypes::UByte2,p.ArFunctor2<(p.char,ArTypes::UByte2)>)> functor)
        """
        return apply(_AriaPy.ArStringInfoGroup_addAddStringCallback, args)

ArStringInfoGroup_swigregister = _AriaPy.ArStringInfoGroup_swigregister
ArStringInfoGroup_swigregister(ArStringInfoGroup)

class ArSyncLoop(ArASyncTask):
    """Proxy of C++ ArSyncLoop class"""
    __swig_setmethods__ = {}
    for _s in [ArASyncTask]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSyncLoop, name, value)
    __swig_getmethods__ = {}
    for _s in [ArASyncTask]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArSyncLoop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArSyncLoop"""
        this = apply(_AriaPy.new_ArSyncLoop, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSyncLoop
    __del__ = lambda self : None;
    def setRobot(*args):
        """setRobot(self, ArRobot robot)"""
        return apply(_AriaPy.ArSyncLoop_setRobot, args)

    def stopRunIfNotConnected(*args):
        """stopRunIfNotConnected(self, bool stopRun)"""
        return apply(_AriaPy.ArSyncLoop_stopRunIfNotConnected, args)

    def runThread(*args):
        """runThread(self, void arg) -> void"""
        return apply(_AriaPy.ArSyncLoop_runThread, args)

    def getThreadActivity(*args):
        """getThreadActivity(self) -> char"""
        return apply(_AriaPy.ArSyncLoop_getThreadActivity, args)

ArSyncLoop_swigregister = _AriaPy.ArSyncLoop_swigregister
ArSyncLoop_swigregister(ArSyncLoop)

class ArSyncTask:
    """Proxy of C++ ArSyncTask class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSyncTask, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArSyncTask, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name, ArFunctor functor=None, State state=None, 
            ArSyncTask parent=None) -> ArSyncTask
        __init__(self, char name, ArFunctor functor=None, State state=None) -> ArSyncTask
        __init__(self, char name, ArFunctor functor=None) -> ArSyncTask
        __init__(self, char name) -> ArSyncTask
        """
        this = apply(_AriaPy.new_ArSyncTask, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArSyncTask
    __del__ = lambda self : None;
    def run(*args):
        """run(self)"""
        return apply(_AriaPy.ArSyncTask_run, args)

    def log(*args):
        """
        log(self, int depth=0)
        log(self)
        """
        return apply(_AriaPy.ArSyncTask_log, args)

    def getState(*args):
        """getState(self) -> int"""
        return apply(_AriaPy.ArSyncTask_getState, args)

    def setState(*args):
        """setState(self, State state)"""
        return apply(_AriaPy.ArSyncTask_setState, args)

    def findNonRecursive(*args):
        """
        findNonRecursive(self, char name) -> ArSyncTask
        findNonRecursive(self, ArFunctor functor) -> ArSyncTask
        """
        return apply(_AriaPy.ArSyncTask_findNonRecursive, args)

    def find(*args):
        """
        find(self, char name) -> ArSyncTask
        find(self, ArFunctor functor) -> ArSyncTask
        """
        return apply(_AriaPy.ArSyncTask_find, args)

    def getRunning(*args):
        """getRunning(self) -> ArSyncTask"""
        return apply(_AriaPy.ArSyncTask_getRunning, args)

    def addNewBranch(*args):
        """
        addNewBranch(self, char nameOfNew, int position, State state=None)
        addNewBranch(self, char nameOfNew, int position)
        """
        return apply(_AriaPy.ArSyncTask_addNewBranch, args)

    def addNewLeaf(*args):
        """
        addNewLeaf(self, char nameOfNew, int position, ArFunctor functor, State state=None)
        addNewLeaf(self, char nameOfNew, int position, ArFunctor functor)
        """
        return apply(_AriaPy.ArSyncTask_addNewLeaf, args)

    def getName(*args):
        """getName(self) -> std::string"""
        return apply(_AriaPy.ArSyncTask_getName, args)

    def getFunctor(*args):
        """getFunctor(self) -> ArFunctor"""
        return apply(_AriaPy.ArSyncTask_getFunctor, args)

    def setWarningTimeCB(*args):
        """setWarningTimeCB(self, ArRetFunctor_UnsignedInt functor)"""
        return apply(_AriaPy.ArSyncTask_setWarningTimeCB, args)

    def getWarningTimeCB(*args):
        """getWarningTimeCB(self) -> ArRetFunctor_UnsignedInt"""
        return apply(_AriaPy.ArSyncTask_getWarningTimeCB, args)

    def setNoTimeWarningCB(*args):
        """setNoTimeWarningCB(self, ArRetFunctor_Bool functor)"""
        return apply(_AriaPy.ArSyncTask_setNoTimeWarningCB, args)

    def getNoTimeWarningCB(*args):
        """getNoTimeWarningCB(self) -> ArRetFunctor_Bool"""
        return apply(_AriaPy.ArSyncTask_getNoTimeWarningCB, args)

    def remove(*args):
        """remove(self, ArSyncTask proc)"""
        return apply(_AriaPy.ArSyncTask_remove, args)

    def isDeleting(*args):
        """isDeleting(self) -> bool"""
        return apply(_AriaPy.ArSyncTask_isDeleting, args)

ArSyncTask_swigregister = _AriaPy.ArSyncTask_swigregister
ArSyncTask_swigregister(ArSyncTask)

class ArSystemStatus:
    """Proxy of C++ ArSystemStatus class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArSystemStatus, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArSystemStatus, name)
    __repr__ = _swig_repr
    __swig_getmethods__["startPeriodicUpdate"] = lambda x: _AriaPy.ArSystemStatus_startPeriodicUpdate
    __swig_getmethods__["stopPeriodicUpdate"] = lambda x: _AriaPy.ArSystemStatus_stopPeriodicUpdate
    __swig_getmethods__["runRefreshThread"] = lambda x: _AriaPy.ArSystemStatus_runRefreshThread
    __swig_getmethods__["getCPU"] = lambda x: _AriaPy.ArSystemStatus_getCPU
    __swig_getmethods__["getCPUPercent"] = lambda x: _AriaPy.ArSystemStatus_getCPUPercent
    __swig_getmethods__["getCPUPercentAsString"] = lambda x: _AriaPy.ArSystemStatus_getCPUPercentAsString
    __swig_getmethods__["getUptime"] = lambda x: _AriaPy.ArSystemStatus_getUptime
    __swig_getmethods__["getUptimeHours"] = lambda x: _AriaPy.ArSystemStatus_getUptimeHours
    __swig_getmethods__["getUptimeHoursAsString"] = lambda x: _AriaPy.ArSystemStatus_getUptimeHoursAsString
    __swig_getmethods__["getCPUPercentFunctor"] = lambda x: _AriaPy.ArSystemStatus_getCPUPercentFunctor
    __swig_getmethods__["getUptimeHoursFunctor"] = lambda x: _AriaPy.ArSystemStatus_getUptimeHoursFunctor
    __swig_getmethods__["getWirelessLinkQuality"] = lambda x: _AriaPy.ArSystemStatus_getWirelessLinkQuality
    __swig_getmethods__["getWirelessLinkSignal"] = lambda x: _AriaPy.ArSystemStatus_getWirelessLinkSignal
    __swig_getmethods__["getWirelessLinkNoise"] = lambda x: _AriaPy.ArSystemStatus_getWirelessLinkNoise
    __swig_getmethods__["getWirelessDiscardedPackets"] = lambda x: _AriaPy.ArSystemStatus_getWirelessDiscardedPackets
    __swig_getmethods__["getWirelessDiscardedPacketsBecauseNetConflict"] = lambda x: _AriaPy.ArSystemStatus_getWirelessDiscardedPacketsBecauseNetConflict
    __swig_getmethods__["getWirelessLinkQualityFunctor"] = lambda x: _AriaPy.ArSystemStatus_getWirelessLinkQualityFunctor
    __swig_getmethods__["getWirelessLinkNoiseFunctor"] = lambda x: _AriaPy.ArSystemStatus_getWirelessLinkNoiseFunctor
    __swig_getmethods__["getWirelessLinkSignalFunctor"] = lambda x: _AriaPy.ArSystemStatus_getWirelessLinkSignalFunctor
    __swig_getmethods__["invalidate"] = lambda x: _AriaPy.ArSystemStatus_invalidate
    __swig_getmethods__["refresh"] = lambda x: _AriaPy.ArSystemStatus_refresh
    def __init__(self, *args): 
        """__init__(self) -> ArSystemStatus"""
        this = apply(_AriaPy.new_ArSystemStatus, args)
        try: self.this.append(this)
        except: 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)
    ArSystemStatus_startPeriodicUpdate()
    """
  return apply(_AriaPy.ArSystemStatus_startPeriodicUpdate, args)

def ArSystemStatus_stopPeriodicUpdate(*args):
  """ArSystemStatus_stopPeriodicUpdate()"""
  return apply(_AriaPy.ArSystemStatus_stopPeriodicUpdate, args)

def ArSystemStatus_runRefreshThread(*args):
  """
    runRefreshThread(int refreshFrequency=5000)
    ArSystemStatus_runRefreshThread()
    """
  return apply(_AriaPy.ArSystemStatus_runRefreshThread, args)

def ArSystemStatus_getCPU(*args):
  """ArSystemStatus_getCPU() -> double"""
  return apply(_AriaPy.ArSystemStatus_getCPU, args)

def ArSystemStatus_getCPUPercent(*args):
  """ArSystemStatus_getCPUPercent() -> double"""
  return apply(_AriaPy.ArSystemStatus_getCPUPercent, args)

def ArSystemStatus_getCPUPercentAsString(*args):
  """ArSystemStatus_getCPUPercentAsString() -> std::string"""
  return apply(_AriaPy.ArSystemStatus_getCPUPercentAsString, args)

def ArSystemStatus_getUptime(*args):
  """ArSystemStatus_getUptime() -> unsigned long"""
  return apply(_AriaPy.ArSystemStatus_getUptime, args)

def ArSystemStatus_getUptimeHours(*args):
  """ArSystemStatus_getUptimeHours() -> double"""
  return apply(_AriaPy.ArSystemStatus_getUptimeHours, args)

def ArSystemStatus_getUptimeHoursAsString(*args):
  """ArSystemStatus_getUptimeHoursAsString() -> std::string"""
  return apply(_AriaPy.ArSystemStatus_getUptimeHoursAsString, args)

def ArSystemStatus_getCPUPercentFunctor(*args):
  """ArSystemStatus_getCPUPercentFunctor() -> ArRetFunctor_Double"""
  return apply(_AriaPy.ArSystemStatus_getCPUPercentFunctor, args)

def ArSystemStatus_getUptimeHoursFunctor(*args):
  """ArSystemStatus_getUptimeHoursFunctor() -> ArRetFunctor_Double"""
  return apply(_AriaPy.ArSystemStatus_getUptimeHoursFunctor, args)

def ArSystemStatus_getWirelessLinkQuality(*args):
  """ArSystemStatus_getWirelessLinkQuality() -> int"""
  return apply(_AriaPy.ArSystemStatus_getWirelessLinkQuality, args)

def ArSystemStatus_getWirelessLinkSignal(*args):
  """ArSystemStatus_getWirelessLinkSignal() -> int"""
  return apply(_AriaPy.ArSystemStatus_getWirelessLinkSignal, args)

def ArSystemStatus_getWirelessLinkNoise(*args):
  """ArSystemStatus_getWirelessLinkNoise() -> int"""
  return apply(_AriaPy.ArSystemStatus_getWirelessLinkNoise, args)

def ArSystemStatus_getWirelessDiscardedPackets(*args):
  """ArSystemStatus_getWirelessDiscardedPackets() -> int"""
  return apply(_AriaPy.ArSystemStatus_getWirelessDiscardedPackets, args)

def ArSystemStatus_getWirelessDiscardedPacketsBecauseNetConflict(*args):
  """ArSystemStatus_getWirelessDiscardedPacketsBecauseNetConflict() -> int"""
  return apply(_AriaPy.ArSystemStatus_getWirelessDiscardedPacketsBecauseNetConflict, args)

def ArSystemStatus_getWirelessLinkQualityFunctor(*args):
  """ArSystemStatus_getWirelessLinkQualityFunctor() -> ArRetFunctor_Int"""
  return apply(_AriaPy.ArSystemStatus_getWirelessLinkQualityFunctor, args)

def ArSystemStatus_getWirelessLinkNoiseFunctor(*args):
  """ArSystemStatus_getWirelessLinkNoiseFunctor() -> ArRetFunctor_Int"""
  return apply(_AriaPy.ArSystemStatus_getWirelessLinkNoiseFunctor, args)

def ArSystemStatus_getWirelessLinkSignalFunctor(*args):
  """ArSystemStatus_getWirelessLinkSignalFunctor() -> ArRetFunctor_Int"""
  return apply(_AriaPy.ArSystemStatus_getWirelessLinkSignalFunctor, args)

def ArSystemStatus_invalidate(*args):
  """ArSystemStatus_invalidate()"""
  return apply(_AriaPy.ArSystemStatus_invalidate, args)

def ArSystemStatus_refresh(*args):
  """ArSystemStatus_refresh()"""
  return apply(_AriaPy.ArSystemStatus_refresh, args)

ARTCM2_DEFAULT_SERIAL_PORT = _AriaPy.ARTCM2_DEFAULT_SERIAL_PORT
class ArTCM2:
    """Proxy of C++ ArTCM2 class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArTCM2, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArTCM2, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _AriaPy.delete_ArTCM2
    __del__ = lambda self : None;
    def connect(*args):
        """connect(self) -> bool"""
        return apply(_AriaPy.ArTCM2_connect, args)

    def blockingConnect(*args):
        """
        blockingConnect(self, unsigned long connectTimeout=5000) -> bool
        blockingConnect(self) -> bool
        """
        return apply(_AriaPy.ArTCM2_blockingConnect, args)

    def getHeading(*args):
        """getHeading(self) -> double"""
        return apply(_AriaPy.ArTCM2_getHeading, args)

    def haveHeading(*args):
        """haveHeading(self) -> bool"""
        return apply(_AriaPy.ArTCM2_haveHeading, args)

    def getCompass(*args):
        """getCompass(self) -> double"""
        return apply(_AriaPy.ArTCM2_getCompass, args)

    def getPitch(*args):
        """getPitch(self) -> double"""
        return apply(_AriaPy.ArTCM2_getPitch, args)

    def havePitch(*args):
        """havePitch(self) -> bool"""
        return apply(_AriaPy.ArTCM2_havePitch, args)

    def getRoll(*args):
        """getRoll(self) -> double"""
        return apply(_AriaPy.ArTCM2_getRoll, args)

    def haveRoll(*args):
        """haveRoll(self) -> bool"""
        return apply(_AriaPy.ArTCM2_haveRoll, args)

    def getXMagnetic(*args):
        """getXMagnetic(self) -> double"""
        return apply(_AriaPy.ArTCM2_getXMagnetic, args)

    def haveXMagnetic(*args):
        """haveXMagnetic(self) -> bool"""
        return apply(_AriaPy.ArTCM2_haveXMagnetic, args)

    def getYMagnetic(*args):
        """getYMagnetic(self) -> double"""
        return apply(_AriaPy.ArTCM2_getYMagnetic, args)

    def haveYMagnetic(*args):
        """haveYMagnetic(self) -> bool"""
        return apply(_AriaPy.ArTCM2_haveYMagnetic, args)

    def getZMagnetic(*args):
        """getZMagnetic(self) -> double"""
        return apply(_AriaPy.ArTCM2_getZMagnetic, args)

    def haveZMagnetic(*args):
        """haveZMagnetic(self) -> bool"""
        return apply(_AriaPy.ArTCM2_haveZMagnetic, args)

    def getTemperature(*args):
        """getTemperature(self) -> double"""
        return apply(_AriaPy.ArTCM2_getTemperature, args)

    def haveTemperature(*args):
        """haveTemperature(self) -> bool"""
        return apply(_AriaPy.ArTCM2_haveTemperature, args)

    def getError(*args):
        """getError(self) -> int"""
        return apply(_AriaPy.ArTCM2_getError, args)

    def getCalibrationH(*args):
        """getCalibrationH(self) -> double"""
        return apply(_AriaPy.ArTCM2_getCalibrationH, args)

    def haveCalibrationH(*args):
        """haveCalibrationH(self) -> bool"""
        return apply(_AriaPy.ArTCM2_haveCalibrationH, args)

    def getCalibrationV(*args):
        """getCalibrationV(self) -> double"""
        return apply(_AriaPy.ArTCM2_getCalibrationV, args)

    def haveCalibrationV(*args):
        """haveCalibrationV(self) -> bool"""
        return apply(_AriaPy.ArTCM2_haveCalibrationV, args)

    def getCalibrationM(*args):
        """getCalibrationM(self) -> double"""
        return apply(_AriaPy.ArTCM2_getCalibrationM, args)

    def haveCalibrationM(*args):
        """haveCalibrationM(self) -> bool"""
        return apply(_AriaPy.ArTCM2_haveCalibrationM, args)

    def commandOff(*args):
        """commandOff(self)"""
        return apply(_AriaPy.ArTCM2_commandOff, args)

    def commandOnePacket(*args):
        """commandOnePacket(self)"""
        return apply(_AriaPy.ArTCM2_commandOnePacket, args)

    def commandContinuousPackets(*args):
        """commandContinuousPackets(self)"""
        return apply(_AriaPy.ArTCM2_commandContinuousPackets, args)

    def commandUserCalibration(*args):
        """commandUserCalibration(self)"""
        return apply(_AriaPy.ArTCM2_commandUserCalibration, args)

    def commandAutoCalibration(*args):
        """commandAutoCalibration(self)"""
        return apply(_AriaPy.ArTCM2_commandAutoCalibration, args)

    def commandStopCalibration(*args):
        """commandStopCalibration(self)"""
        return apply(_AriaPy.ArTCM2_commandStopCalibration, args)

    def commandSoftReset(*args):
        """commandSoftReset(self)"""
        return apply(_AriaPy.ArTCM2_commandSoftReset, args)

    def commandJustCompass(*args):
        """commandJustCompass(self)"""
        return apply(_AriaPy.ArTCM2_commandJustCompass, args)

    def getPacCount(*args):
        """getPacCount(self) -> int"""
        return apply(_AriaPy.ArTCM2_getPacCount, args)

    def addHeadingDataCallback(*args):
        """addHeadingDataCallback(self, ArFunctor1<(double)> f)"""
        return apply(_AriaPy.ArTCM2_addHeadingDataCallback, args)

ArTCM2_swigregister = _AriaPy.ArTCM2_swigregister
ArTCM2_swigregister(ArTCM2)

class ArCompassConnector:
    """Proxy of C++ ArCompassConnector class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArCompassConnector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArCompassConnector, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArArgumentParser argParser) -> ArCompassConnector"""
        this = apply(_AriaPy.new_ArCompassConnector, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArCompassConnector
    __del__ = lambda self : None;
    def create(*args):
        """create(self, ArRobot robot) -> ArTCM2"""
        return apply(_AriaPy.ArCompassConnector_create, args)

    def connect(*args):
        """connect(self, ArTCM2 ?) -> bool"""
        return apply(_AriaPy.ArCompassConnector_connect, args)

ArCompassConnector_swigregister = _AriaPy.ArCompassConnector_swigregister
ArCompassConnector_swigregister(ArCompassConnector)

class ArTCMCompassDirect(ArTCM2):
    """Proxy of C++ ArTCMCompassDirect class"""
    __swig_setmethods__ = {}
    for _s in [ArTCM2]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArTCMCompassDirect, name, value)
    __swig_getmethods__ = {}
    for _s in [ArTCM2]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArTCMCompassDirect, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArDeviceConnection devCon) -> ArTCMCompassDirect
        __init__(self, char serialPortName="/dev/ttyS3") -> ArTCMCompassDirect
        __init__(self) -> ArTCMCompassDirect
        """
        this = apply(_AriaPy.new_ArTCMCompassDirect, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArTCMCompassDirect
    __del__ = lambda self : None;
    def connect(*args):
        """connect(self) -> bool"""
        return apply(_AriaPy.ArTCMCompassDirect_connect, args)

    def blockingConnect(*args):
        """
        blockingConnect(self, unsigned long connectTimeout=5000) -> bool
        blockingConnect(self) -> bool
        """
        return apply(_AriaPy.ArTCMCompassDirect_blockingConnect, args)

    def commandAutoCalibration(*args):
        """commandAutoCalibration(self)"""
        return apply(_AriaPy.ArTCMCompassDirect_commandAutoCalibration, args)

    def commandUserCalibration(*args):
        """commandUserCalibration(self)"""
        return apply(_AriaPy.ArTCMCompassDirect_commandUserCalibration, args)

    def commandStopCalibration(*args):
        """commandStopCalibration(self)"""
        return apply(_AriaPy.ArTCMCompassDirect_commandStopCalibration, args)

    def commandContinuousPackets(*args):
        """commandContinuousPackets(self)"""
        return apply(_AriaPy.ArTCMCompassDirect_commandContinuousPackets, args)

    def commandOnePacket(*args):
        """commandOnePacket(self)"""
        return apply(_AriaPy.ArTCMCompassDirect_commandOnePacket, args)

    def commandOff(*args):
        """commandOff(self)"""
        return apply(_AriaPy.ArTCMCompassDirect_commandOff, args)

    def commandSoftReset(*args):
        """commandSoftReset(self)"""
        return apply(_AriaPy.ArTCMCompassDirect_commandSoftReset, args)

    def commandJustCompass(*args):
        """commandJustCompass(self)"""
        return apply(_AriaPy.ArTCMCompassDirect_commandJustCompass, args)

    def read(*args):
        """
        read(self, unsigned int msWait=1) -> int
        read(self) -> int
        """
        return apply(_AriaPy.ArTCMCompassDirect_read, args)

    def setDeviceConnection(*args):
        """setDeviceConnection(self, ArDeviceConnection devCon)"""
        return apply(_AriaPy.ArTCMCompassDirect_setDeviceConnection, args)

    def getDeviceConnetion(*args):
        """getDeviceConnetion(self) -> ArDeviceConnection"""
        return apply(_AriaPy.ArTCMCompassDirect_getDeviceConnetion, args)

ArTCMCompassDirect_swigregister = _AriaPy.ArTCMCompassDirect_swigregister
ArTCMCompassDirect_swigregister(ArTCMCompassDirect)

class ArTCMCompassRobot(ArTCM2):
    """Proxy of C++ ArTCMCompassRobot class"""
    __swig_setmethods__ = {}
    for _s in [ArTCM2]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArTCMCompassRobot, name, value)
    __swig_getmethods__ = {}
    for _s in [ArTCM2]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArTCMCompassRobot, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArRobot robot) -> ArTCMCompassRobot"""
        this = apply(_AriaPy.new_ArTCMCompassRobot, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArTCMCompassRobot
    __del__ = lambda self : None;
    def commandOff(*args):
        """commandOff(self)"""
        return apply(_AriaPy.ArTCMCompassRobot_commandOff, args)

    def commandJustCompass(*args):
        """commandJustCompass(self)"""
        return apply(_AriaPy.ArTCMCompassRobot_commandJustCompass, args)

    def commandOnePacket(*args):
        """commandOnePacket(self)"""
        return apply(_AriaPy.ArTCMCompassRobot_commandOnePacket, args)

    def commandContinuousPackets(*args):
        """commandContinuousPackets(self)"""
        return apply(_AriaPy.ArTCMCompassRobot_commandContinuousPackets, args)

    def commandUserCalibration(*args):
        """commandUserCalibration(self)"""
        return apply(_AriaPy.ArTCMCompassRobot_commandUserCalibration, args)

    def commandAutoCalibration(*args):
        """commandAutoCalibration(self)"""
        return apply(_AriaPy.ArTCMCompassRobot_commandAutoCalibration, args)

    def commandStopCalibration(*args):
        """commandStopCalibration(self)"""
        return apply(_AriaPy.ArTCMCompassRobot_commandStopCalibration, args)

    def commandSoftReset(*args):
        """commandSoftReset(self)"""
        return apply(_AriaPy.ArTCMCompassRobot_commandSoftReset, args)

ArTCMCompassRobot_swigregister = _AriaPy.ArTCMCompassRobot_swigregister
ArTCMCompassRobot_swigregister(ArTCMCompassRobot)

class ArTaskState:
    """Proxy of C++ ArTaskState class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArTaskState, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArTaskState, name)
    __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, *args): 
        """__init__(self) -> ArTaskState"""
        this = apply(_AriaPy.new_ArTaskState, args)
        try: self.this.append(this)
        except: 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"""
    __swig_setmethods__ = {}
    for _s in [ArDeviceConnection]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArTcpConnection, name, value)
    __swig_getmethods__ = {}
    for _s in [ArDeviceConnection]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArTcpConnection, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArTcpConnection"""
        this = apply(_AriaPy.new_ArTcpConnection, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArTcpConnection
    __del__ = lambda self : None;
    def open(*args):
        """
        open(self, char host=None, int port=8101) -> int
        open(self, char host=None) -> int
        open(self) -> int
        """
        return apply(_AriaPy.ArTcpConnection_open, args)

    def setPort(*args):
        """
        setPort(self, char host=None, int port=8101)
        setPort(self, char host=None)
        setPort(self)
        """
        return apply(_AriaPy.ArTcpConnection_setPort, args)

    def openSimple(*args):
        """openSimple(self) -> bool"""
        return apply(_AriaPy.ArTcpConnection_openSimple, args)

    def getStatus(*args):
        """getStatus(self) -> int"""
        return apply(_AriaPy.ArTcpConnection_getStatus, args)

    def close(*args):
        """close(self) -> bool"""
        return apply(_AriaPy.ArTcpConnection_close, args)

    def read(*args):
        """
        read(self, char data, unsigned int size, unsigned int msWait=0) -> int
        read(self, char data, unsigned int size) -> int
        """
        return apply(_AriaPy.ArTcpConnection_read, args)

    def write(*args):
        """write(self, char data, unsigned int size) -> int"""
        return apply(_AriaPy.ArTcpConnection_write, args)

    def getOpenMessage(*args):
        """getOpenMessage(self, int messageNumber) -> char"""
        return apply(_AriaPy.ArTcpConnection_getOpenMessage, args)

    def getTimeRead(*args):
        """getTimeRead(self, int index) -> ArTime"""
        return apply(_AriaPy.ArTcpConnection_getTimeRead, args)

    def isTimeStamping(*args):
        """isTimeStamping(self) -> bool"""
        return apply(_AriaPy.ArTcpConnection_isTimeStamping, args)

    def getHost(*args):
        """getHost(self) -> std::string"""
        return apply(_AriaPy.ArTcpConnection_getHost, args)

    def getPort(*args):
        """getPort(self) -> int"""
        return apply(_AriaPy.ArTcpConnection_getPort, args)

    def internalOpen(*args):
        """internalOpen(self) -> int"""
        return apply(_AriaPy.ArTcpConnection_internalOpen, args)

    def setSocket(*args):
        """setSocket(self, ArSocket socket)"""
        return apply(_AriaPy.ArTcpConnection_setSocket, args)

    def getSocket(*args):
        """getSocket(self) -> ArSocket"""
        return apply(_AriaPy.ArTcpConnection_getSocket, args)

    def setStatus(*args):
        """setStatus(self, int status)"""
        return apply(_AriaPy.ArTcpConnection_setStatus, args)

    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:
    """Proxy of C++ ArTransform class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArTransform, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArTransform, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> ArTransform
        __init__(self, ArPose pose) -> ArTransform
        __init__(self, ArPose pose1, ArPose pose2) -> ArTransform
        """
        this = apply(_AriaPy.new_ArTransform, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArTransform
    __del__ = lambda self : None;
    def doInvTransform(*args):
        """
        doInvTransform(self, ArPose source) -> ArPose
        doInvTransform(self, ArPoseWithTime source) -> ArPoseWithTime
        """
        return apply(_AriaPy.ArTransform_doInvTransform, args)

    def doTransform(*args):
        """
        doTransform(self, ArPose source) -> ArPose
        doTransform(self, ArPoseWithTime source) -> ArPoseWithTime
        doTransform(self, ArPosePtrList poseList)
        doTransform(self, ArPoseWithTimePtrList poseList)
        """
        return apply(_AriaPy.ArTransform_doTransform, args)

    def setTransform(*args):
        """
        setTransform(self, ArPose pose)
        setTransform(self, ArPose pose1, ArPose pose2)
        """
        return apply(_AriaPy.ArTransform_setTransform, args)

    def getTh(*args):
        """getTh(self) -> double"""
        return apply(_AriaPy.ArTransform_getTh, args)

ArTransform_swigregister = _AriaPy.ArTransform_swigregister
ArTransform_swigregister(ArTransform)

class ArTrimbleGPS(ArGPS):
    """Proxy of C++ ArTrimbleGPS class"""
    __swig_setmethods__ = {}
    for _s in [ArGPS]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArTrimbleGPS, name, value)
    __swig_getmethods__ = {}
    for _s in [ArGPS]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArTrimbleGPS, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArTrimbleGPS"""
        this = apply(_AriaPy.new_ArTrimbleGPS, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArTrimbleGPS
    __del__ = lambda self : None;
    def sendTSIPCommand(*args):
        """sendTSIPCommand(self, char command, char data, size_t dataLen) -> bool"""
        return apply(_AriaPy.ArTrimbleGPS_sendTSIPCommand, args)

ArTrimbleGPS_swigregister = _AriaPy.ArTrimbleGPS_swigregister
ArTrimbleGPS_swigregister(ArTrimbleGPS)

class ArUrg(ArLaser):
    """Proxy of C++ ArUrg class"""
    __swig_setmethods__ = {}
    for _s in [ArLaser]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArUrg, name, value)
    __swig_getmethods__ = {}
    for _s in [ArLaser]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArUrg, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, int laserNumber, char name="urg") -> ArUrg
        __init__(self, int laserNumber) -> ArUrg
        """
        this = apply(_AriaPy.new_ArUrg, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArUrg
    __del__ = lambda self : None;
    def blockingConnect(*args):
        """blockingConnect(self) -> bool"""
        return apply(_AriaPy.ArUrg_blockingConnect, args)

    def asyncConnect(*args):
        """asyncConnect(self) -> bool"""
        return apply(_AriaPy.ArUrg_asyncConnect, args)

    def disconnect(*args):
        """disconnect(self) -> bool"""
        return apply(_AriaPy.ArUrg_disconnect, args)

    def isConnected(*args):
        """isConnected(self) -> bool"""
        return apply(_AriaPy.ArUrg_isConnected, args)

    def isTryingToConnect(*args):
        """isTryingToConnect(self) -> bool"""
        return apply(_AriaPy.ArUrg_isTryingToConnect, args)

    def log(*args):
        """log(self)"""
        return apply(_AriaPy.ArUrg_log, args)

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:
    """Proxy of C++ ArVCC4Commands class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArVCC4Commands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArVCC4Commands, name)
    __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, *args): 
        """__init__(self) -> ArVCC4Commands"""
        this = apply(_AriaPy.new_ArVCC4Commands, args)
        try: self.this.append(this)
        except: 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"""
    __swig_setmethods__ = {}
    for _s in [ArBasePacket]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArVCC4Packet, name, value)
    __swig_getmethods__ = {}
    for _s in [ArBasePacket]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArVCC4Packet, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, UByte2 bufferSize=30) -> ArVCC4Packet
        __init__(self) -> ArVCC4Packet
        """
        this = apply(_AriaPy.new_ArVCC4Packet, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArVCC4Packet
    __del__ = lambda self : None;
    def byte2ToBuf(*args):
        """byte2ToBuf(self, Byte4 val)"""
        return apply(_AriaPy.ArVCC4Packet_byte2ToBuf, args)

    def finalizePacket(*args):
        """finalizePacket(self)"""
        return apply(_AriaPy.ArVCC4Packet_finalizePacket, args)

ArVCC4Packet_swigregister = _AriaPy.ArVCC4Packet_swigregister
ArVCC4Packet_swigregister(ArVCC4Packet)

class ArVCC4(ArPTZ):
    """Proxy of C++ ArVCC4 class"""
    __swig_setmethods__ = {}
    for _s in [ArPTZ]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArVCC4, name, value)
    __swig_getmethods__ = {}
    for _s in [ArPTZ]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArVCC4, name)
    __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__(self, ArRobot robot, bool inverted=False, CommState commDirection=COMM_UNKNOWN, 
            bool autoUpdate=True, 
            bool disableLED=False, CameraType cameraType=CAMERA_VCC4) -> ArVCC4
        __init__(self, ArRobot robot, bool inverted=False, CommState commDirection=COMM_UNKNOWN, 
            bool autoUpdate=True, 
            bool disableLED=False) -> ArVCC4
        __init__(self, ArRobot robot, bool inverted=False, CommState commDirection=COMM_UNKNOWN, 
            bool autoUpdate=True) -> ArVCC4
        __init__(self, ArRobot robot, bool inverted=False, CommState commDirection=COMM_UNKNOWN) -> ArVCC4
        __init__(self, ArRobot robot, bool inverted=False) -> ArVCC4
        __init__(self, ArRobot robot) -> ArVCC4
        """
        this = apply(_AriaPy.new_ArVCC4, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArVCC4
    __del__ = lambda self : None;
    def power(*args):
        """power(self, bool state) -> bool"""
        return apply(_AriaPy.ArVCC4_power, args)

    def getPower(*args):
        """getPower(self) -> bool"""
        return apply(_AriaPy.ArVCC4_getPower, args)

    def init(*args):
        """init(self) -> bool"""
        return apply(_AriaPy.ArVCC4_init, args)

    def reset(*args):
        """reset(self)"""
        return apply(_AriaPy.ArVCC4_reset, args)

    def isInitted(*args):
        """isInitted(self) -> bool"""
        return apply(_AriaPy.ArVCC4_isInitted, args)

    def connectHandler(*args):
        """connectHandler(self)"""
        return apply(_AriaPy.ArVCC4_connectHandler, args)

    def packetHandler(*args):
        """packetHandler(self, ArBasePacket packet) -> bool"""
        return apply(_AriaPy.ArVCC4_packetHandler, args)

    def pan(*args):
        """pan(self, double deg) -> bool"""
        return apply(_AriaPy.ArVCC4_pan, args)

    def panRel(*args):
        """panRel(self, double deg) -> bool"""
        return apply(_AriaPy.ArVCC4_panRel, args)

    def tilt(*args):
        """tilt(self, double deg) -> bool"""
        return apply(_AriaPy.ArVCC4_tilt, args)

    def tiltRel(*args):
        """tiltRel(self, double deg) -> bool"""
        return apply(_AriaPy.ArVCC4_tiltRel, args)

    def panTiltRel(*args):
        """panTiltRel(self, double pdeg, double tdeg) -> bool"""
        return apply(_AriaPy.ArVCC4_panTiltRel, args)

    def getMaxPosPan(*args):
        """getMaxPosPan(self) -> double"""
        return apply(_AriaPy.ArVCC4_getMaxPosPan, args)

    def getMaxNegPan(*args):
        """getMaxNegPan(self) -> double"""
        return apply(_AriaPy.ArVCC4_getMaxNegPan, args)

    def getMaxPosTilt(*args):
        """getMaxPosTilt(self) -> double"""
        return apply(_AriaPy.ArVCC4_getMaxPosTilt, args)

    def getMaxNegTilt(*args):
        """getMaxNegTilt(self) -> double"""
        return apply(_AriaPy.ArVCC4_getMaxNegTilt, args)

    def getRealPanTilt(*args):
        """getRealPanTilt(self)"""
        return apply(_AriaPy.ArVCC4_getRealPanTilt, args)

    def getRealZoomPos(*args):
        """getRealZoomPos(self)"""
        return apply(_AriaPy.ArVCC4_getRealZoomPos, args)

    def canZoom(*args):
        """canZoom(self) -> bool"""
        return apply(_AriaPy.ArVCC4_canZoom, args)

    def panTilt(*args):
        """panTilt(self, double pdeg, double tdeg) -> bool"""
        return apply(_AriaPy.ArVCC4_panTilt, args)

    def zoom(*args):
        """zoom(self, int deg) -> bool"""
        return apply(_AriaPy.ArVCC4_zoom, args)

    def digitalZoom(*args):
        """digitalZoom(self, int deg) -> bool"""
        return apply(_AriaPy.ArVCC4_digitalZoom, args)

    def addErrorCB(*args):
        """addErrorCB(self, ArFunctor functor, Pos position)"""
        return apply(_AriaPy.ArVCC4_addErrorCB, args)

    def remErrorCB(*args):
        """remErrorCB(self, ArFunctor functor)"""
        return apply(_AriaPy.ArVCC4_remErrorCB, args)

    def haltPanTilt(*args):
        """haltPanTilt(self) -> bool"""
        return apply(_AriaPy.ArVCC4_haltPanTilt, args)

    def haltZoom(*args):
        """haltZoom(self) -> bool"""
        return apply(_AriaPy.ArVCC4_haltZoom, args)

    def panSlew(*args):
        """panSlew(self, double deg) -> bool"""
        return apply(_AriaPy.ArVCC4_panSlew, args)

    def tiltSlew(*args):
        """tiltSlew(self, double deg) -> bool"""
        return apply(_AriaPy.ArVCC4_tiltSlew, args)

    def preparePacket(*args):
        """preparePacket(self, ArVCC4Packet packet)"""
        return apply(_AriaPy.ArVCC4_preparePacket, args)

    def getPan(*args):
        """getPan(self) -> double"""
        return apply(_AriaPy.ArVCC4_getPan, args)

    def getTilt(*args):
        """getTilt(self) -> double"""
        return apply(_AriaPy.ArVCC4_getTilt, args)

    def getZoom(*args):
        """getZoom(self) -> int"""
        return apply(_AriaPy.ArVCC4_getZoom, args)

    def getDigitalZoom(*args):
        """getDigitalZoom(self) -> double"""
        return apply(_AriaPy.ArVCC4_getDigitalZoom, args)

    def canGetRealPanTilt(*args):
        """canGetRealPanTilt(self) -> bool"""
        return apply(_AriaPy.ArVCC4_canGetRealPanTilt, args)

    def canGetRealZoom(*args):
        """canGetRealZoom(self) -> bool"""
        return apply(_AriaPy.ArVCC4_canGetRealZoom, args)

    def canSetFocus(*args):
        """canSetFocus(self) -> bool"""
        return apply(_AriaPy.ArVCC4_canSetFocus, args)

    def autoFocus(*args):
        """autoFocus(self) -> bool"""
        return apply(_AriaPy.ArVCC4_autoFocus, args)

    def focusNear(*args):
        """focusNear(self) -> bool"""
        return apply(_AriaPy.ArVCC4_focusNear, args)

    def focusFar(*args):
        """focusFar(self) -> bool"""
        return apply(_AriaPy.ArVCC4_focusFar, args)

    def getPanSlew(*args):
        """getPanSlew(self) -> double"""
        return apply(_AriaPy.ArVCC4_getPanSlew, args)

    def getMaxPanSlew(*args):
        """getMaxPanSlew(self) -> double"""
        return apply(_AriaPy.ArVCC4_getMaxPanSlew, args)

    def getMinPanSlew(*args):
        """getMinPanSlew(self) -> double"""
        return apply(_AriaPy.ArVCC4_getMinPanSlew, args)

    def getTiltSlew(*args):
        """getTiltSlew(self) -> double"""
        return apply(_AriaPy.ArVCC4_getTiltSlew, args)

    def getMaxTiltSlew(*args):
        """getMaxTiltSlew(self) -> double"""
        return apply(_AriaPy.ArVCC4_getMaxTiltSlew, args)

    def getMinTiltSlew(*args):
        """getMinTiltSlew(self) -> double"""
        return apply(_AriaPy.ArVCC4_getMinTiltSlew, args)

    def getMaxZoom(*args):
        """getMaxZoom(self) -> int"""
        return apply(_AriaPy.ArVCC4_getMaxZoom, args)

    def getMinZoom(*args):
        """getMinZoom(self) -> int"""
        return apply(_AriaPy.ArVCC4_getMinZoom, args)

    def canGetFOV(*args):
        """canGetFOV(self) -> bool"""
        return apply(_AriaPy.ArVCC4_canGetFOV, args)

    def getFOVAtMaxZoom(*args):
        """getFOVAtMaxZoom(self) -> double"""
        return apply(_AriaPy.ArVCC4_getFOVAtMaxZoom, args)

    def getFOVAtMinZoom(*args):
        """getFOVAtMinZoom(self) -> double"""
        return apply(_AriaPy.ArVCC4_getFOVAtMinZoom, args)

    def wasError(*args):
        """wasError(self) -> bool"""
        return apply(_AriaPy.ArVCC4_wasError, args)

    def enableAutoUpdate(*args):
        """enableAutoUpdate(self)"""
        return apply(_AriaPy.ArVCC4_enableAutoUpdate, args)

    def disableAutoUpdate(*args):
        """disableAutoUpdate(self)"""
        return apply(_AriaPy.ArVCC4_disableAutoUpdate, args)

    def getAutoUpdate(*args):
        """getAutoUpdate(self) -> bool"""
        return apply(_AriaPy.ArVCC4_getAutoUpdate, args)

    def setLEDControlMode(*args):
        """setLEDControlMode(self, int controlMode)"""
        return apply(_AriaPy.ArVCC4_setLEDControlMode, args)

    def enableIRLEDs(*args):
        """enableIRLEDs(self)"""
        return apply(_AriaPy.ArVCC4_enableIRLEDs, args)

    def disableIRLEDs(*args):
        """disableIRLEDs(self)"""
        return apply(_AriaPy.ArVCC4_disableIRLEDs, args)

    def getIRLEDsEnabled(*args):
        """getIRLEDsEnabled(self) -> bool"""
        return apply(_AriaPy.ArVCC4_getIRLEDsEnabled, args)

    def enableIRFilterMode(*args):
        """enableIRFilterMode(self)"""
        return apply(_AriaPy.ArVCC4_enableIRFilterMode, args)

    def disableIRFilterMode(*args):
        """disableIRFilterMode(self)"""
        return apply(_AriaPy.ArVCC4_disableIRFilterMode, args)

    def getIRFilterModeEnabled(*args):
        """getIRFilterModeEnabled(self) -> bool"""
        return apply(_AriaPy.ArVCC4_getIRFilterModeEnabled, args)

ArVCC4_swigregister = _AriaPy.ArVCC4_swigregister
ArVCC4_swigregister(ArVCC4)

class ArVersalogicIO:
    """Proxy of C++ ArVersalogicIO class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArVersalogicIO, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArVersalogicIO, name)
    __repr__ = _swig_repr
    DIGITAL_INPUT = _AriaPy.ArVersalogicIO_DIGITAL_INPUT
    DIGITAL_OUTPUT = _AriaPy.ArVersalogicIO_DIGITAL_OUTPUT
    def __init__(self, *args): 
        """
        __init__(self, char dev="/dev/amrio") -> ArVersalogicIO
        __init__(self) -> ArVersalogicIO
        """
        this = apply(_AriaPy.new_ArVersalogicIO, args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _AriaPy.delete_ArVersalogicIO
    __del__ = lambda self : None;
    def closeIO(*args):
        """closeIO(self) -> bool"""
        return apply(_AriaPy.ArVersalogicIO_closeIO, args)

    def isEnabled(*args):
        """isEnabled(self) -> bool"""
        return apply(_AriaPy.ArVersalogicIO_isEnabled, args)

    def isAnalogSupported(*args):
        """isAnalogSupported(self) -> bool"""
        return apply(_AriaPy.ArVersalogicIO_isAnalogSupported, args)

    def getAnalogValue(*args):
        """getAnalogValue(self, int port, double val) -> bool"""
        return apply(_AriaPy.ArVersalogicIO_getAnalogValue, args)

    def getAnalogValueRaw(*args):
        """getAnalogValueRaw(self, int port, int val) -> bool"""
        return apply(_AriaPy.ArVersalogicIO_getAnalogValueRaw, args)

    def getDigitalBankDirection(*args):
        """getDigitalBankDirection(self, int bank) -> int"""
        return apply(_AriaPy.ArVersalogicIO_getDigitalBankDirection, args)

    def setDigitalBankDirection(*args):
        """setDigitalBankDirection(self, int bank, Direction dir) -> bool"""
        return apply(_AriaPy.ArVersalogicIO_setDigitalBankDirection, args)

    def getDigitalBankInputs(*args):
        """getDigitalBankInputs(self, int bank, unsigned char val) -> bool"""
        return apply(_AriaPy.ArVersalogicIO_getDigitalBankInputs, args)

    def getDigitalBankOutputs(*args):
        """getDigitalBankOutputs(self, int bank, unsigned char val) -> bool"""
        return apply(_AriaPy.ArVersalogicIO_getDigitalBankOutputs, args)

    def setDigitalBankOutputs(*args):
        """setDigitalBankOutputs(self, int bank, unsigned char val) -> bool"""
        return apply(_AriaPy.ArVersalogicIO_setDigitalBankOutputs, args)

    def getSpecialControlRegister(*args):
        """getSpecialControlRegister(self, unsigned char val) -> bool"""
        return apply(_AriaPy.ArVersalogicIO_getSpecialControlRegister, args)

    def lock(*args):
        """lock(self) -> int"""
        return apply(_AriaPy.ArVersalogicIO_lock, args)

    def unlock(*args):
        """unlock(self) -> int"""
        return apply(_AriaPy.ArVersalogicIO_unlock, args)

    def tryLock(*args):
        """tryLock(self) -> int"""
        return apply(_AriaPy.ArVersalogicIO_tryLock, args)

ArVersalogicIO_swigregister = _AriaPy.ArVersalogicIO_swigregister
ArVersalogicIO_swigregister(ArVersalogicIO)

class Aria:
    """Proxy of C++ Aria class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Aria, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Aria, name)
    __repr__ = _swig_repr
    SIGHANDLE_SINGLE = _AriaPy.Aria_SIGHANDLE_SINGLE
    SIGHANDLE_THREAD = _AriaPy.Aria_SIGHANDLE_THREAD
    SIGHANDLE_NONE = _AriaPy.Aria_SIGHANDLE_NONE
    __swig_getmethods__["init"] = lambda x: _AriaPy.Aria_init
    __swig_getmethods__["uninit"] = lambda x: _AriaPy.Aria_uninit
    __swig_getmethods__["addInitCallBack"] = lambda x: _AriaPy.Aria_addInitCallBack
    __swig_getmethods__["addUninitCallBack"] = lambda x: _AriaPy.Aria_addUninitCallBack
    __swig_getmethods__["shutdown"] = lambda x: _AriaPy.Aria_shutdown
    __swig_getmethods__["exit"] = lambda x: _AriaPy.Aria_exit
    __swig_getmethods__["getRunning"] = lambda x: _AriaPy.Aria_getRunning
    __swig_getmethods__["setDirectory"] = lambda x: _AriaPy.Aria_setDirectory
    __swig_getmethods__["getDirectory"] = lambda x: _AriaPy.Aria_getDirectory
    __swig_getmethods__["parseArgs"] = lambda x: _AriaPy.Aria_parseArgs
    __swig_getmethods__["logOptions"] = lambda x: _AriaPy.Aria_logOptions
    __swig_getmethods__["setKeyHandler"] = lambda x: _AriaPy.Aria_setKeyHandler
    __swig_getmethods__["getKeyHandler"] = lambda x: _AriaPy.Aria_getKeyHandler
    __swig_getmethods__["setJoyHandler"] = lambda x: _AriaPy.Aria_setJoyHandler
    __swig_getmethods__["getJoyHandler"] = lambda x: _AriaPy.Aria_getJoyHandler
    __swig_getmethods__["addExitCallback"] = lambda x: _AriaPy.Aria_addExitCallback
    __swig_getmethods__["remExitCallback"] = lambda x: _AriaPy.Aria_remExitCallback
    __swig_getmethods__["setExitCallbacksLogLevel"] = lambda x: _AriaPy.Aria_setExitCallbacksLogLevel
    __swig_getmethods__["exitOld"] = lambda x: _AriaPy.Aria_exitOld
    __swig_getmethods__["signalHandlerCB"] = lambda x: _AriaPy.Aria_signalHandlerCB
    __swig_getmethods__["callExitCallbacks"] = lambda x: _AriaPy.Aria_callExitCallbacks
    __swig_getmethods__["addParseArgsCB"] = lambda x: _AriaPy.Aria_addParseArgsCB
    __swig_getmethods__["setParseArgLogLevel"] = lambda x: _AriaPy.Aria_setParseArgLogLevel
    __swig_getmethods__["addLogOptionsCB"] = lambda x: _AriaPy.Aria_addLogOptionsCB
    __swig_getmethods__["deviceConnectionAddCreator"] = lambda x: _AriaPy.Aria_deviceConnectionAddCreator
    __swig_getmethods__["deviceConnectionGetTypes"] = lambda x: _AriaPy.Aria_deviceConnectionGetTypes
    __swig_getmethods__["deviceConnectionCreate"] = lambda x: _AriaPy.Aria_deviceConnectionCreate
    __swig_getmethods__["setRobotJoyHandler"] = lambda x: _AriaPy.Aria_setRobotJoyHandler
    __swig_getmethods__["getRobotJoyHandler"] = lambda x: _AriaPy.Aria_getRobotJoyHandler
    __swig_getmethods__["getConfig"] = lambda x: _AriaPy.Aria_getConfig
    __swig_getmethods__["getInfoGroup"] = lambda x: _AriaPy.Aria_getInfoGroup
    __swig_getmethods__["addRobot"] = lambda x: _AriaPy.Aria_addRobot
    __swig_getmethods__["delRobot"] = lambda x: _AriaPy.Aria_delRobot
    __swig_getmethods__["findRobot"] = lambda x: _AriaPy.Aria_findRobot
    __swig_getmethods__["getRobotList"] = lambda x: _AriaPy.Aria_getRobotList
    __swig_getmethods__["getMaxNumLasers"] = lambda x: _AriaPy.Aria_getMaxNumLasers
    __swig_getmethods__["setMaxNumLasers"] = lambda x: _AriaPy.Aria_setMaxNumLasers
    __swig_getmethods__["laserAddCreator"] = lambda x: _AriaPy.Aria_laserAddCreator
    __swig_getmethods__["laserGetTypes"] = lambda x: _AriaPy.Aria_laserGetTypes
    __swig_getmethods__["laserCreate"] = lambda x: _AriaPy.Aria_laserCreate
    def __init__(self, *args): 
        """__init__(self) -> Aria"""
        this = apply(_AriaPy.new_Aria, args)
        try: self.this.append(this)
        except: 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(SigHandleMethod method=SIGHANDLE_THREAD, bool initSockets=True, 
        bool sigHandleExitNotShutdown=True)
    init(SigHandleMethod method=SIGHANDLE_THREAD, bool initSockets=True)
    init(SigHandleMethod method=SIGHANDLE_THREAD)
    Aria_init()
    """
  return apply(_AriaPy.Aria_init, args)

def Aria_uninit(*args):
  """Aria_uninit()"""
  return apply(_AriaPy.Aria_uninit, args)

def Aria_addInitCallBack(*args):
  """Aria_addInitCallBack(ArFunctor cb, Pos position)"""
  return apply(_AriaPy.Aria_addInitCallBack, args)

def Aria_addUninitCallBack(*args):
  """Aria_addUninitCallBack(ArFunctor cb, Pos position)"""
  return apply(_AriaPy.Aria_addUninitCallBack, args)

def Aria_shutdown(*args):
  """Aria_shutdown()"""
  return apply(_AriaPy.Aria_shutdown, args)

def Aria_exit(*args):
  """
    exit(int exitCode=0)
    Aria_exit()
    """
  return apply(_AriaPy.Aria_exit, args)

def Aria_getRunning(*args):
  """Aria_getRunning() -> bool"""
  return apply(_AriaPy.Aria_getRunning, args)

def Aria_setDirectory(*args):
  """Aria_setDirectory(char directory)"""
  return apply(_AriaPy.Aria_setDirectory, args)

def Aria_getDirectory(*args):
  """Aria_getDirectory() -> char"""
  return apply(_AriaPy.Aria_getDirectory, args)

def Aria_parseArgs(*args):
  """Aria_parseArgs() -> bool"""
  return apply(_AriaPy.Aria_parseArgs, args)

def Aria_logOptions(*args):
  """Aria_logOptions()"""
  return apply(_AriaPy.Aria_logOptions, args)

def Aria_setKeyHandler(*args):
  """Aria_setKeyHandler(ArKeyHandler keyHandler)"""
  return apply(_AriaPy.Aria_setKeyHandler, args)

def Aria_getKeyHandler(*args):
  """Aria_getKeyHandler() -> ArKeyHandler"""
  return apply(_AriaPy.Aria_getKeyHandler, args)

def Aria_setJoyHandler(*args):
  """Aria_setJoyHandler(ArJoyHandler joyHandler)"""
  return apply(_AriaPy.Aria_setJoyHandler, args)

def Aria_getJoyHandler(*args):
  """Aria_getJoyHandler() -> ArJoyHandler"""
  return apply(_AriaPy.Aria_getJoyHandler, args)

def Aria_addExitCallback(*args):
  """
    addExitCallback(ArFunctor functor, int position=50)
    Aria_addExitCallback(ArFunctor functor)
    """
  return apply(_AriaPy.Aria_addExitCallback, args)

def Aria_remExitCallback(*args):
  """Aria_remExitCallback(ArFunctor functor)"""
  return apply(_AriaPy.Aria_remExitCallback, args)

def Aria_setExitCallbacksLogLevel(*args):
  """Aria_setExitCallbacksLogLevel(LogLevel level)"""
  return apply(_AriaPy.Aria_setExitCallbacksLogLevel, args)

def Aria_exitOld(*args):
  """
    exitOld(int exitCode=0)
    Aria_exitOld()
    """
  return apply(_AriaPy.Aria_exitOld, args)

def Aria_signalHandlerCB(*args):
  """Aria_signalHandlerCB(int sig)"""
  return apply(_AriaPy.Aria_signalHandlerCB, args)

def Aria_callExitCallbacks(*args):
  """Aria_callExitCallbacks()"""
  return apply(_AriaPy.Aria_callExitCallbacks, args)

def Aria_addParseArgsCB(*args):
  """
    addParseArgsCB(ArRetFunctor_Bool functor, int position=50)
    Aria_addParseArgsCB(ArRetFunctor_Bool functor)
    """
  return apply(_AriaPy.Aria_addParseArgsCB, args)

def Aria_setParseArgLogLevel(*args):
  """Aria_setParseArgLogLevel(LogLevel level)"""
  return apply(_AriaPy.Aria_setParseArgLogLevel, args)

def Aria_addLogOptionsCB(*args):
  """
    addLogOptionsCB(ArFunctor functor, int position=50)
    Aria_addLogOptionsCB(ArFunctor functor)
    """
  return apply(_AriaPy.Aria_addLogOptionsCB, args)

def Aria_deviceConnectionAddCreator(*args):
  """Aria_deviceConnectionAddCreator(char deviceConnectionType, ArRetFunctor3<(p.ArDeviceConnection,p.q(const).char,p.q(const).char,p.q(const).char)> creator) -> bool"""
  return apply(_AriaPy.Aria_deviceConnectionAddCreator, args)

def Aria_deviceConnectionGetTypes(*args):
  """Aria_deviceConnectionGetTypes() -> char"""
  return apply(_AriaPy.Aria_deviceConnectionGetTypes, args)

def Aria_deviceConnectionCreate(*args):
  """
    deviceConnectionCreate(char deviceConnectionType, char port, char defaultInfo, 
        char prefix="Aria::deviceConnectionCreate") -> ArDeviceConnection
    Aria_deviceConnectionCreate(char deviceConnectionType, char port, char defaultInfo) -> ArDeviceConnection
    """
  return apply(_AriaPy.Aria_deviceConnectionCreate, args)

def Aria_setRobotJoyHandler(*args):
  """Aria_setRobotJoyHandler(ArRobotJoyHandler robotJoyHandler)"""
  return apply(_AriaPy.Aria_setRobotJoyHandler, args)

def Aria_getRobotJoyHandler(*args):
  """Aria_getRobotJoyHandler() -> ArRobotJoyHandler"""
  return apply(_AriaPy.Aria_getRobotJoyHandler, args)

def Aria_getConfig(*args):
  """Aria_getConfig() -> ArConfig"""
  return apply(_AriaPy.Aria_getConfig, args)

def Aria_getInfoGroup(*args):
  """Aria_getInfoGroup() -> ArStringInfoGroup"""
  return apply(_AriaPy.Aria_getInfoGroup, args)

def Aria_addRobot(*args):
  """Aria_addRobot(ArRobot robot)"""
  return apply(_AriaPy.Aria_addRobot, args)

def Aria_delRobot(*args):
  """Aria_delRobot(ArRobot robot)"""
  return apply(_AriaPy.Aria_delRobot, args)

def Aria_findRobot(*args):
  """Aria_findRobot(char name) -> ArRobot"""
  return apply(_AriaPy.Aria_findRobot, args)

def Aria_getRobotList(*args):
  """Aria_getRobotList() -> std::list<(p.ArRobot,std::allocator<(p.ArRobot)>)>"""
  return apply(_AriaPy.Aria_getRobotList, args)

def Aria_getMaxNumLasers(*args):
  """Aria_getMaxNumLasers() -> int"""
  return apply(_AriaPy.Aria_getMaxNumLasers, args)

def Aria_setMaxNumLasers(*args):
  """Aria_setMaxNumLasers(int maxNumLasers)"""
  return apply(_AriaPy.Aria_setMaxNumLasers, args)

def Aria_laserAddCreator(*args):
  """Aria_laserAddCreator(char laserType, ArRetFunctor2<(p.ArLaser,int,p.q(const).char)> creator) -> bool"""
  return apply(_AriaPy.Aria_laserAddCreator, args)

def Aria_laserGetTypes(*args):
  """Aria_laserGetTypes() -> char"""
  return apply(_AriaPy.Aria_laserGetTypes, args)

def Aria_laserCreate(*args):
  """
    laserCreate(char laserType, int laserNumber, char prefix="Aria::laserCreate") -> ArLaser
    Aria_laserCreate(char laserType, int laserNumber) -> ArLaser
    """
  return apply(_AriaPy.Aria_laserCreate, args)

class ArPyFunctor(ArFunctor):
    """Proxy of C++ ArPyFunctor class"""
    __swig_setmethods__ = {}
    for _s in [ArFunctor]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPyFunctor, name, value)
    __swig_getmethods__ = {}
    for _s in [ArFunctor]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArPyFunctor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, PyObject _m) -> ArPyFunctor"""
        this = apply(_AriaPy.new_ArPyFunctor, args)
        try: self.this.append(this)
        except: self.this = this
    def invoke(*args):
        """invoke(self)"""
        return apply(_AriaPy.ArPyFunctor_invoke, args)

    __swig_destroy__ = _AriaPy.delete_ArPyFunctor
    __del__ = lambda self : None;
    def getName(*args):
        """getName(self) -> char"""
        return apply(_AriaPy.ArPyFunctor_getName, args)

ArPyFunctor_swigregister = _AriaPy.ArPyFunctor_swigregister
ArPyFunctor_swigregister(ArPyFunctor)

class ArPyRetFunctor_Bool(ArRetFunctor_Bool,ArPyFunctor):
    """Proxy of C++ ArPyRetFunctor_Bool class"""
    __swig_setmethods__ = {}
    for _s in [ArRetFunctor_Bool,ArPyFunctor]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArPyRetFunctor_Bool, name, value)
    __swig_getmethods__ = {}
    for _s in [ArRetFunctor_Bool,ArPyFunctor]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArPyRetFunctor_Bool, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, PyObject _m) -> ArPyRetFunctor_Bool"""
        this = apply(_AriaPy.new_ArPyRetFunctor_Bool, args)
        try: self.this.append(this)
        except: self.this = this
    def invokeR(*args):
        """invokeR(self) -> bool"""
        return apply(_AriaPy.ArPyRetFunctor_Bool_invokeR, args)

    def getName(*args):
        """getName(self) -> char"""
        return apply(_AriaPy.ArPyRetFunctor_Bool_getName, args)

    __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"""
    __swig_setmethods__ = {}
    for _s in [ArConfigArg]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArConfigArg_Bool, name, value)
    __swig_getmethods__ = {}
    for _s in [ArConfigArg]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArConfigArg_Bool, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name, bool b, char desc="") -> ArConfigArg_Bool
        __init__(self, char name, bool b) -> ArConfigArg_Bool
        """
        this = apply(_AriaPy.new_ArConfigArg_Bool, args)
        try: self.this.append(this)
        except: 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"""
    __swig_setmethods__ = {}
    for _s in [ArConfigArg]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArConfigArg_Int, name, value)
    __swig_getmethods__ = {}
    for _s in [ArConfigArg]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArConfigArg_Int, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name, int i, char desc="", int min=INT_MIN, int max=INT_MAX) -> ArConfigArg_Int
        __init__(self, char name, int i, char desc="", int min=INT_MIN) -> ArConfigArg_Int
        __init__(self, char name, int i, char desc="") -> ArConfigArg_Int
        __init__(self, char name, int i) -> ArConfigArg_Int
        """
        this = apply(_AriaPy.new_ArConfigArg_Int, args)
        try: self.this.append(this)
        except: 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"""
    __swig_setmethods__ = {}
    for _s in [ArConfigArg]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArConfigArg_Double, name, value)
    __swig_getmethods__ = {}
    for _s in [ArConfigArg]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArConfigArg_Double, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name, double d, char desc="", double min=-HUGE_VAL, 
            double max=HUGE_VAL) -> ArConfigArg_Double
        __init__(self, char name, double d, char desc="", double min=-HUGE_VAL) -> ArConfigArg_Double
        __init__(self, char name, double d, char desc="") -> ArConfigArg_Double
        __init__(self, char name, double d) -> ArConfigArg_Double
        """
        this = apply(_AriaPy.new_ArConfigArg_Double, args)
        try: self.this.append(this)
        except: 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"""
    __swig_setmethods__ = {}
    for _s in [ArConfigArg]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArConfigArg_String, name, value)
    __swig_getmethods__ = {}
    for _s in [ArConfigArg]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArConfigArg_String, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, char name, char str, char desc) -> ArConfigArg_String"""
        this = apply(_AriaPy.new_ArConfigArg_String, args)
        try: self.this.append(this)
        except: 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)