"""
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 ArNetworking
"""

import _ArNetworkingPy
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,)

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


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


import AriaPy
SWIG_IMPORTED_ARIA = _ArNetworkingPy.SWIG_IMPORTED_ARIA
class ArNetPacket(AriaPy.ArBasePacket):
    """Proxy of C++ ArNetPacket class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArBasePacket]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNetPacket, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArBasePacket]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArNetPacket, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, UByte2 bufferSize=ArNetPacket::MAX_LENGTH+5) -> ArNetPacket
        __init__(self) -> ArNetPacket
        __init__(self, ArNetPacket other) -> ArNetPacket
        """
        this = _ArNetworkingPy.new_ArNetPacket(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArNetPacket
    __del__ = lambda self : None;
    def setCommand(*args):
        """setCommand(self, UByte2 command)"""
        return _ArNetworkingPy.ArNetPacket_setCommand(*args)

    def getCommand(*args):
        """getCommand(self) -> UByte2"""
        return _ArNetworkingPy.ArNetPacket_getCommand(*args)

    SIZE_OF_LENGTH = _ArNetworkingPy.ArNetPacket_SIZE_OF_LENGTH
    MAX_LENGTH = _ArNetworkingPy.ArNetPacket_MAX_LENGTH
    HEADER_LENGTH = _ArNetworkingPy.ArNetPacket_HEADER_LENGTH
    FOOTER_LENGTH = _ArNetworkingPy.ArNetPacket_FOOTER_LENGTH
    MAX_DATA_LENGTH = _ArNetworkingPy.ArNetPacket_MAX_DATA_LENGTH
    def doubleToBuf(*args):
        """doubleToBuf(self, double val)"""
        return _ArNetworkingPy.ArNetPacket_doubleToBuf(*args)

    def bufToDouble(*args):
        """bufToDouble(self) -> double"""
        return _ArNetworkingPy.ArNetPacket_bufToDouble(*args)

    def empty(*args):
        """empty(self)"""
        return _ArNetworkingPy.ArNetPacket_empty(*args)

    def finalizePacket(*args):
        """finalizePacket(self)"""
        return _ArNetworkingPy.ArNetPacket_finalizePacket(*args)

    def resetRead(*args):
        """resetRead(self)"""
        return _ArNetworkingPy.ArNetPacket_resetRead(*args)

    def duplicatePacket(*args):
        """duplicatePacket(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArNetPacket_duplicatePacket(*args)

    def verifyCheckSum(*args):
        """verifyCheckSum(self) -> bool"""
        return _ArNetworkingPy.ArNetPacket_verifyCheckSum(*args)

    def calcCheckSum(*args):
        """calcCheckSum(self) -> Byte2"""
        return _ArNetworkingPy.ArNetPacket_calcCheckSum(*args)

    def getAddedFooter(*args):
        """getAddedFooter(self) -> bool"""
        return _ArNetworkingPy.ArNetPacket_getAddedFooter(*args)

    def setAddedFooter(*args):
        """setAddedFooter(self, bool addedFooter)"""
        return _ArNetworkingPy.ArNetPacket_setAddedFooter(*args)

    TCP = _ArNetworkingPy.ArNetPacket_TCP
    UDP = _ArNetworkingPy.ArNetPacket_UDP
    def getPacketSource(*args):
        """getPacketSource(self) -> int"""
        return _ArNetworkingPy.ArNetPacket_getPacketSource(*args)

    def setPacketSource(*args):
        """setPacketSource(self, PacketSource source)"""
        return _ArNetworkingPy.ArNetPacket_setPacketSource(*args)

    def setArbitraryString(*args):
        """setArbitraryString(self, char string)"""
        return _ArNetworkingPy.ArNetPacket_setArbitraryString(*args)

    def getArbitraryString(*args):
        """getArbitraryString(self) -> char"""
        return _ArNetworkingPy.ArNetPacket_getArbitraryString(*args)

ArNetPacket_swigregister = _ArNetworkingPy.ArNetPacket_swigregister
ArNetPacket_swigregister(ArNetPacket)

class ArServerBase(AriaPy.ArASyncTask):
    """Proxy of C++ ArServerBase class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArASyncTask]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerBase, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArASyncTask]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerBase, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, bool addAriaExitCB=True, char serverName="", bool addBackupTimeoutToConfig=True, 
            char backupTimeoutName="RobotToClientTimeoutInMins", 
            char backupTimeoutDesc="The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won\'t happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)", 
            bool masterServer=False, 
            bool slaveServer=False, 
            bool logPasswordFailureVerbosely=False, 
            bool allowSlowPackets=True, 
            bool allowIdlePackets=True) -> ArServerBase
        __init__(self, bool addAriaExitCB=True, char serverName="", bool addBackupTimeoutToConfig=True, 
            char backupTimeoutName="RobotToClientTimeoutInMins", 
            char backupTimeoutDesc="The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won\'t happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)", 
            bool masterServer=False, 
            bool slaveServer=False, 
            bool logPasswordFailureVerbosely=False, 
            bool allowSlowPackets=True) -> ArServerBase
        __init__(self, bool addAriaExitCB=True, char serverName="", bool addBackupTimeoutToConfig=True, 
            char backupTimeoutName="RobotToClientTimeoutInMins", 
            char backupTimeoutDesc="The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won\'t happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)", 
            bool masterServer=False, 
            bool slaveServer=False, 
            bool logPasswordFailureVerbosely=False) -> ArServerBase
        __init__(self, bool addAriaExitCB=True, char serverName="", bool addBackupTimeoutToConfig=True, 
            char backupTimeoutName="RobotToClientTimeoutInMins", 
            char backupTimeoutDesc="The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won\'t happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)", 
            bool masterServer=False, 
            bool slaveServer=False) -> ArServerBase
        __init__(self, bool addAriaExitCB=True, char serverName="", bool addBackupTimeoutToConfig=True, 
            char backupTimeoutName="RobotToClientTimeoutInMins", 
            char backupTimeoutDesc="The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won\'t happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)", 
            bool masterServer=False) -> ArServerBase
        __init__(self, bool addAriaExitCB=True, char serverName="", bool addBackupTimeoutToConfig=True, 
            char backupTimeoutName="RobotToClientTimeoutInMins", 
            char backupTimeoutDesc="The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won\'t happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)") -> ArServerBase
        __init__(self, bool addAriaExitCB=True, char serverName="", bool addBackupTimeoutToConfig=True, 
            char backupTimeoutName="RobotToClientTimeoutInMins") -> ArServerBase
        __init__(self, bool addAriaExitCB=True, char serverName="", bool addBackupTimeoutToConfig=True) -> ArServerBase
        __init__(self, bool addAriaExitCB=True, char serverName="") -> ArServerBase
        __init__(self, bool addAriaExitCB=True) -> ArServerBase
        __init__(self) -> ArServerBase
        """
        this = _ArNetworkingPy.new_ArServerBase(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerBase
    __del__ = lambda self : None;
    def open(*args):
        """
        open(self, unsigned int port, char openOnIP=None, bool tcpOnly=False) -> bool
        open(self, unsigned int port, char openOnIP=None) -> bool
        open(self, unsigned int port) -> bool
        """
        return _ArNetworkingPy.ArServerBase_open(*args)

    def close(*args):
        """close(self)"""
        return _ArNetworkingPy.ArServerBase_close(*args)

    def loopOnce(*args):
        """loopOnce(self)"""
        return _ArNetworkingPy.ArServerBase_loopOnce(*args)

    def addData(*args):
        """
        addData(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup=None, 
            char dataFlags=None) -> bool
        addData(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup=None) -> bool
        addData(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription) -> bool
        """
        return _ArNetworkingPy.ArServerBase_addData(*args)

    def loadUserInfo(*args):
        """
        loadUserInfo(self, char fileName, char baseDirectory="") -> bool
        loadUserInfo(self, char fileName) -> bool
        """
        return _ArNetworkingPy.ArServerBase_loadUserInfo(*args)

    def logUserInfo(*args):
        """logUserInfo(self)"""
        return _ArNetworkingPy.ArServerBase_logUserInfo(*args)

    def logCommandGroups(*args):
        """logCommandGroups(self)"""
        return _ArNetworkingPy.ArServerBase_logCommandGroups(*args)

    def logCommandGroupsToFile(*args):
        """logCommandGroupsToFile(self, char fileName)"""
        return _ArNetworkingPy.ArServerBase_logCommandGroupsToFile(*args)

    def setGroupDescription(*args):
        """setGroupDescription(self, char GrpName, char GrpDesc)"""
        return _ArNetworkingPy.ArServerBase_setGroupDescription(*args)

    def logGroupDescriptions(*args):
        """logGroupDescriptions(self)"""
        return _ArNetworkingPy.ArServerBase_logGroupDescriptions(*args)

    def logGroupDescriptionsToFile(*args):
        """logGroupDescriptionsToFile(self, char fileName)"""
        return _ArNetworkingPy.ArServerBase_logGroupDescriptionsToFile(*args)

    def setServerKey(*args):
        """setServerKey(self, char serverKey)"""
        return _ArNetworkingPy.ArServerBase_setServerKey(*args)

    def rejectSinceUsingCentralServer(*args):
        """rejectSinceUsingCentralServer(self, char centralServerIPString)"""
        return _ArNetworkingPy.ArServerBase_rejectSinceUsingCentralServer(*args)

    def setBackupTimeout(*args):
        """setBackupTimeout(self, double timeoutInMins)"""
        return _ArNetworkingPy.ArServerBase_setBackupTimeout(*args)

    def run(*args):
        """run(self)"""
        return _ArNetworkingPy.ArServerBase_run(*args)

    def runAsync(*args):
        """runAsync(self)"""
        return _ArNetworkingPy.ArServerBase_runAsync(*args)

    def logConnections(*args):
        """
        logConnections(self, char prefix="")
        logConnections(self)
        """
        return _ArNetworkingPy.ArServerBase_logConnections(*args)

    def getNumClients(*args):
        """getNumClients(self) -> int"""
        return _ArNetworkingPy.ArServerBase_getNumClients(*args)

    def findCommandFromName(*args):
        """findCommandFromName(self, char command) -> unsigned int"""
        return _ArNetworkingPy.ArServerBase_findCommandFromName(*args)

    def broadcastPacketTcp(*args):
        """broadcastPacketTcp(self, ArNetPacket packet, char name) -> bool"""
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcp(*args)

    def broadcastPacketTcpToMatching(*args):
        """
        broadcastPacketTcpToMatching(self, ArNetPacket packet, char name, ArServerClientIdentifier identifier, 
            bool matchConnectionID=False) -> bool
        broadcastPacketTcpToMatching(self, ArNetPacket packet, char name, ArServerClientIdentifier identifier) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcpToMatching(*args)

    def broadcastPacketTcpWithExclusion(*args):
        """
        broadcastPacketTcpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient, 
            bool match=False, ArServerClientIdentifier identifier=ArServerClientIdentifier(), 
            bool matchConnectionID=False) -> bool
        broadcastPacketTcpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient, 
            bool match=False, ArServerClientIdentifier identifier=ArServerClientIdentifier()) -> bool
        broadcastPacketTcpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient, 
            bool match=False) -> bool
        broadcastPacketTcpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcpWithExclusion(*args)

    def broadcastPacketUdp(*args):
        """broadcastPacketUdp(self, ArNetPacket packet, char name) -> bool"""
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdp(*args)

    def broadcastPacketUdpWithExclusion(*args):
        """
        broadcastPacketUdpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient, 
            bool match=False, ArServerClientIdentifier identifier=ArServerClientIdentifier(), 
            bool matchConnectionID=False) -> bool
        broadcastPacketUdpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient, 
            bool match=False, ArServerClientIdentifier identifier=ArServerClientIdentifier()) -> bool
        broadcastPacketUdpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient, 
            bool match=False) -> bool
        broadcastPacketUdpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdpWithExclusion(*args)

    def broadcastPacketUdpToMatching(*args):
        """
        broadcastPacketUdpToMatching(self, ArNetPacket packet, char name, ArServerClientIdentifier identifier, 
            bool matchConnectionID) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdpToMatching(*args)

    def idleProcessingPending(*args):
        """idleProcessingPending(self) -> bool"""
        return _ArNetworkingPy.ArServerBase_idleProcessingPending(*args)

    def processPacket(*args):
        """processPacket(self, ArNetPacket packet, sockaddr_in sin)"""
        return _ArNetworkingPy.ArServerBase_processPacket(*args)

    def sendUdp(*args):
        """sendUdp(self, ArNetPacket packet, sockaddr_in sin) -> bool"""
        return _ArNetworkingPy.ArServerBase_sendUdp(*args)

    def logTracking(*args):
        """
        logTracking(self, bool terse=True)
        logTracking(self)
        """
        return _ArNetworkingPy.ArServerBase_logTracking(*args)

    def resetTracking(*args):
        """resetTracking(self)"""
        return _ArNetworkingPy.ArServerBase_resetTracking(*args)

    def runThread(*args):
        """runThread(self, void arg) -> void"""
        return _ArNetworkingPy.ArServerBase_runThread(*args)

    def getTcpPort(*args):
        """getTcpPort(self) -> unsigned int"""
        return _ArNetworkingPy.ArServerBase_getTcpPort(*args)

    def getUdpPort(*args):
        """getUdpPort(self) -> unsigned int"""
        return _ArNetworkingPy.ArServerBase_getUdpPort(*args)

    def getOpenOnIP(*args):
        """getOpenOnIP(self) -> char"""
        return _ArNetworkingPy.ArServerBase_getOpenOnIP(*args)

    def addCycleCallback(*args):
        """addCycleCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerBase_addCycleCallback(*args)

    def remCycleCallback(*args):
        """remCycleCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerBase_remCycleCallback(*args)

    def addClientRemovedCallback(*args):
        """addClientRemovedCallback(self, ArFunctor1<(p.ArServerClient)> functor)"""
        return _ArNetworkingPy.ArServerBase_addClientRemovedCallback(*args)

    def remClientRemovedCallback(*args):
        """remClientRemovedCallback(self, ArFunctor1<(p.ArServerClient)> functor)"""
        return _ArNetworkingPy.ArServerBase_remClientRemovedCallback(*args)

    def makeNewServerClientFromSocket(*args):
        """makeNewServerClientFromSocket(self, ArSocket socket, bool doNotReject) -> ArServerClient"""
        return _ArNetworkingPy.ArServerBase_makeNewServerClientFromSocket(*args)

    def getUserInfo(*args):
        """getUserInfo(self) -> ArServerUserInfo"""
        return _ArNetworkingPy.ArServerBase_getUserInfo(*args)

    def setUserInfo(*args):
        """setUserInfo(self, ArServerUserInfo userInfo)"""
        return _ArNetworkingPy.ArServerBase_setUserInfo(*args)

    def addDataAdvanced(*args):
        """
        addDataAdvanced(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup=None, 
            char dataFlags=None, unsigned int commandNumber=0, 
            ArFunctor2<(long,unsigned int)> requestChangedFunctor=None, 
            ArFunctor2<(p.ArServerClient,p.ArNetPacket)> requestOnceFunctor=None) -> bool
        addDataAdvanced(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup=None, 
            char dataFlags=None, unsigned int commandNumber=0, 
            ArFunctor2<(long,unsigned int)> requestChangedFunctor=None) -> bool
        addDataAdvanced(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup=None, 
            char dataFlags=None, unsigned int commandNumber=0) -> bool
        addDataAdvanced(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup=None, 
            char dataFlags=None) -> bool
        addDataAdvanced(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup=None) -> bool
        addDataAdvanced(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription) -> bool
        """
        return _ArNetworkingPy.ArServerBase_addDataAdvanced(*args)

    def setAdditionalDataFlags(*args):
        """setAdditionalDataFlags(self, char additionalDataFlags)"""
        return _ArNetworkingPy.ArServerBase_setAdditionalDataFlags(*args)

    def getFrequency(*args):
        """
        getFrequency(self, unsigned int command, bool internalCall=False) -> long
        getFrequency(self, unsigned int command) -> long
        """
        return _ArNetworkingPy.ArServerBase_getFrequency(*args)

    def broadcastPacketTcpByCommand(*args):
        """broadcastPacketTcpByCommand(self, ArNetPacket packet, unsigned int command) -> bool"""
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcpByCommand(*args)

    def broadcastPacketTcpByCommandWithExclusion(*args):
        """
        broadcastPacketTcpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, 
            bool match=False, ArServerClientIdentifier identifier=ArServerClientIdentifier(), 
            bool matchConnectionID=False) -> bool
        broadcastPacketTcpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, 
            bool match=False, ArServerClientIdentifier identifier=ArServerClientIdentifier()) -> bool
        broadcastPacketTcpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, 
            bool match=False) -> bool
        broadcastPacketTcpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcpByCommandWithExclusion(*args)

    def broadcastPacketUdpByCommand(*args):
        """broadcastPacketUdpByCommand(self, ArNetPacket packet, unsigned int command) -> bool"""
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdpByCommand(*args)

    def broadcastPacketUdpByCommandWithExclusion(*args):
        """
        broadcastPacketUdpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, 
            bool match=False, ArServerClientIdentifier identifier=ArServerClientIdentifier(), 
            bool matchConnectionID=False) -> bool
        broadcastPacketUdpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, 
            bool match=False, ArServerClientIdentifier identifier=ArServerClientIdentifier()) -> bool
        broadcastPacketUdpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, 
            bool match=False) -> bool
        broadcastPacketUdpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdpByCommandWithExclusion(*args)

    def closeConnectionID(*args):
        """closeConnectionID(self, UByte4 idNum)"""
        return _ArNetworkingPy.ArServerBase_closeConnectionID(*args)

    def dataHasFlag(*args):
        """dataHasFlag(self, char name, char dataFlag) -> bool"""
        return _ArNetworkingPy.ArServerBase_dataHasFlag(*args)

    def dataHasFlagByCommand(*args):
        """dataHasFlagByCommand(self, unsigned int command, char dataFlag) -> bool"""
        return _ArNetworkingPy.ArServerBase_dataHasFlagByCommand(*args)

    def setDebugLogging(*args):
        """
        setDebugLogging(self, bool debugLogging=False)
        setDebugLogging(self)
        """
        return _ArNetworkingPy.ArServerBase_setDebugLogging(*args)

    def getDebugLogging(*args):
        """getDebugLogging(self) -> bool"""
        return _ArNetworkingPy.ArServerBase_getDebugLogging(*args)

    def getMostClients(*args):
        """getMostClients(self) -> int"""
        return _ArNetworkingPy.ArServerBase_getMostClients(*args)

    def allowingIdlePackets(*args):
        """allowingIdlePackets(self) -> bool"""
        return _ArNetworkingPy.ArServerBase_allowingIdlePackets(*args)

    def addIdleSingleShotCallback(*args):
        """addIdleSingleShotCallback(self, ArFunctor functor) -> bool"""
        return _ArNetworkingPy.ArServerBase_addIdleSingleShotCallback(*args)

    def hasSlowPackets(*args):
        """hasSlowPackets(self) -> bool"""
        return _ArNetworkingPy.ArServerBase_hasSlowPackets(*args)

    def hasIdlePackets(*args):
        """hasIdlePackets(self) -> bool"""
        return _ArNetworkingPy.ArServerBase_hasIdlePackets(*args)

    def hasIdleCallbacks(*args):
        """hasIdleCallbacks(self) -> bool"""
        return _ArNetworkingPy.ArServerBase_hasIdleCallbacks(*args)

ArServerBase_swigregister = _ArNetworkingPy.ArServerBase_swigregister
ArServerBase_swigregister(ArServerBase)

class ArServerMode(_object):
    """Proxy of C++ ArServerMode class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerMode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerMode, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerMode
    __del__ = lambda self : None;
    def getActionGroup(*args):
        """getActionGroup(self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerMode_getActionGroup(*args)

    def activate(*args):
        """activate(self)"""
        return _ArNetworkingPy.ArServerMode_activate(*args)

    def deactivate(*args):
        """deactivate(self)"""
        return _ArNetworkingPy.ArServerMode_deactivate(*args)

    def activationDenied(*args):
        """activationDenied(self)"""
        return _ArNetworkingPy.ArServerMode_activationDenied(*args)

    def userTask(*args):
        """userTask(self)"""
        return _ArNetworkingPy.ArServerMode_userTask(*args)

    def requestUnlock(*args):
        """requestUnlock(self)"""
        return _ArNetworkingPy.ArServerMode_requestUnlock(*args)

    def forceUnlock(*args):
        """forceUnlock(self)"""
        return _ArNetworkingPy.ArServerMode_forceUnlock(*args)

    def lockMode(*args):
        """
        lockMode(self, bool willUnlockIfRequested=False)
        lockMode(self)
        """
        return _ArNetworkingPy.ArServerMode_lockMode(*args)

    def unlockMode(*args):
        """unlockMode(self)"""
        return _ArNetworkingPy.ArServerMode_unlockMode(*args)

    def getMode(*args):
        """getMode(self) -> char"""
        return _ArNetworkingPy.ArServerMode_getMode(*args)

    def getStatus(*args):
        """getStatus(self) -> char"""
        return _ArNetworkingPy.ArServerMode_getStatus(*args)

    def getName(*args):
        """getName(self) -> char"""
        return _ArNetworkingPy.ArServerMode_getName(*args)

    def isActive(*args):
        """isActive(self) -> bool"""
        return _ArNetworkingPy.ArServerMode_isActive(*args)

    def willUnlockIfRequested(*args):
        """willUnlockIfRequested() -> bool"""
        return _ArNetworkingPy.ArServerMode_willUnlockIfRequested(*args)

    if _newclass:willUnlockIfRequested = staticmethod(willUnlockIfRequested)
    __swig_getmethods__["willUnlockIfRequested"] = lambda x: willUnlockIfRequested
    def getActiveMode(*args):
        """getActiveMode() -> ArServerMode"""
        return _ArNetworkingPy.ArServerMode_getActiveMode(*args)

    if _newclass:getActiveMode = staticmethod(getActiveMode)
    __swig_getmethods__["getActiveMode"] = lambda x: getActiveMode
    def hasSetActivityTime(*args):
        """hasSetActivityTime(self) -> bool"""
        return _ArNetworkingPy.ArServerMode_hasSetActivityTime(*args)

    def getActivityTime(*args):
        """getActivityTime(self) -> ArTime"""
        return _ArNetworkingPy.ArServerMode_getActivityTime(*args)

    def setActivityTimeToNow(*args):
        """setActivityTimeToNow(self)"""
        return _ArNetworkingPy.ArServerMode_setActivityTimeToNow(*args)

    def getActiveModeActivityTimeSecSince(*args):
        """getActiveModeActivityTimeSecSince() -> int"""
        return _ArNetworkingPy.ArServerMode_getActiveModeActivityTimeSecSince(*args)

    if _newclass:getActiveModeActivityTimeSecSince = staticmethod(getActiveModeActivityTimeSecSince)
    __swig_getmethods__["getActiveModeActivityTimeSecSince"] = lambda x: getActiveModeActivityTimeSecSince
    def addAsDefaultMode(*args):
        """
        addAsDefaultMode(self, Pos pos=LAST)
        addAsDefaultMode(self)
        """
        return _ArNetworkingPy.ArServerMode_addAsDefaultMode(*args)

    def checkDefault(*args):
        """checkDefault(self)"""
        return _ArNetworkingPy.ArServerMode_checkDefault(*args)

    def setMode(*args):
        """setMode(self, char str)"""
        return _ArNetworkingPy.ArServerMode_setMode(*args)

    def setStatus(*args):
        """setStatus(self, char str)"""
        return _ArNetworkingPy.ArServerMode_setStatus(*args)

    def isAutoResumeAfterInterrupt(*args):
        """isAutoResumeAfterInterrupt(self) -> bool"""
        return _ArNetworkingPy.ArServerMode_isAutoResumeAfterInterrupt(*args)

    def addModeData(*args):
        """
        addModeData(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup=None, 
            char dataFlags=None) -> bool
        addModeData(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup=None) -> bool
        addModeData(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription) -> bool
        """
        return _ArNetworkingPy.ArServerMode_addModeData(*args)

    def getModeDataList(*args):
        """getModeDataList(ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerMode_getModeDataList(*args)

    if _newclass:getModeDataList = staticmethod(getModeDataList)
    __swig_getmethods__["getModeDataList"] = lambda x: getModeDataList
    def getModeInfo(*args):
        """getModeInfo(ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerMode_getModeInfo(*args)

    if _newclass:getModeInfo = staticmethod(getModeInfo)
    __swig_getmethods__["getModeInfo"] = lambda x: getModeInfo
    def getModeBusy(*args):
        """getModeBusy(ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerMode_getModeBusy(*args)

    if _newclass:getModeBusy = staticmethod(getModeBusy)
    __swig_getmethods__["getModeBusy"] = lambda x: getModeBusy
    def addActivateCallback(*args):
        """
        addActivateCallback(self, ArFunctor functor, int position=50)
        addActivateCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerMode_addActivateCallback(*args)

    def remActivateCallback(*args):
        """remActivateCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerMode_remActivateCallback(*args)

    def addDeactivateCallback(*args):
        """
        addDeactivateCallback(self, ArFunctor functor, int position=50)
        addDeactivateCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerMode_addDeactivateCallback(*args)

    def remDeactivateCallback(*args):
        """remDeactivateCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerMode_remDeactivateCallback(*args)

    def addSingleShotDeactivateCallback(*args):
        """
        addSingleShotDeactivateCallback(self, ArFunctor functor, int position=50)
        addSingleShotDeactivateCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerMode_addSingleShotDeactivateCallback(*args)

    def remSingleShotDeactivateCallback(*args):
        """remSingleShotDeactivateCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerMode_remSingleShotDeactivateCallback(*args)

    def getIdleMode(*args):
        """getIdleMode() -> ArServerModeIdle"""
        return _ArNetworkingPy.ArServerMode_getIdleMode(*args)

    if _newclass:getIdleMode = staticmethod(getIdleMode)
    __swig_getmethods__["getIdleMode"] = lambda x: getIdleMode
ArServerMode_swigregister = _ArNetworkingPy.ArServerMode_swigregister
ArServerMode_swigregister(ArServerMode)

def ArServerMode_willUnlockIfRequested(*args):
  """ArServerMode_willUnlockIfRequested() -> bool"""
  return _ArNetworkingPy.ArServerMode_willUnlockIfRequested(*args)

def ArServerMode_getActiveMode(*args):
  """ArServerMode_getActiveMode() -> ArServerMode"""
  return _ArNetworkingPy.ArServerMode_getActiveMode(*args)

def ArServerMode_getActiveModeActivityTimeSecSince(*args):
  """ArServerMode_getActiveModeActivityTimeSecSince() -> int"""
  return _ArNetworkingPy.ArServerMode_getActiveModeActivityTimeSecSince(*args)

def ArServerMode_getModeDataList(*args):
  """ArServerMode_getModeDataList(ArServerClient client, ArNetPacket packet)"""
  return _ArNetworkingPy.ArServerMode_getModeDataList(*args)

def ArServerMode_getModeInfo(*args):
  """ArServerMode_getModeInfo(ArServerClient client, ArNetPacket packet)"""
  return _ArNetworkingPy.ArServerMode_getModeInfo(*args)

def ArServerMode_getModeBusy(*args):
  """ArServerMode_getModeBusy(ArServerClient client, ArNetPacket packet)"""
  return _ArNetworkingPy.ArServerMode_getModeBusy(*args)

def ArServerMode_getIdleMode(*args):
  """ArServerMode_getIdleMode() -> ArServerModeIdle"""
  return _ArNetworkingPy.ArServerMode_getIdleMode(*args)

class ArClientArg(_object):
    """Proxy of C++ ArClientArg class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientArg, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientArg, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, bool isDisplayHintParsed=False, Priority lastPriority=LAST_PRIORITY) -> ArClientArg
        __init__(self, bool isDisplayHintParsed=False) -> ArClientArg
        __init__(self) -> ArClientArg
        """
        this = _ArNetworkingPy.new_ArClientArg(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientArg
    __del__ = lambda self : None;
    def isSendableParamType(*args):
        """isSendableParamType(self, ArConfigArg arg) -> bool"""
        return _ArNetworkingPy.ArClientArg_isSendableParamType(*args)

    def createArg(*args):
        """createArg(self, ArNetPacket packet, ArConfigArg argOut) -> bool"""
        return _ArNetworkingPy.ArClientArg_createArg(*args)

    def createPacket(*args):
        """createPacket(self, ArConfigArg arg, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientArg_createPacket(*args)

    def bufToArgValue(*args):
        """bufToArgValue(self, ArNetPacket packet, ArConfigArg arg) -> bool"""
        return _ArNetworkingPy.ArClientArg_bufToArgValue(*args)

    def argValueToBuf(*args):
        """argValueToBuf(self, ArConfigArg arg, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientArg_argValueToBuf(*args)

    def argTextToBuf(*args):
        """argTextToBuf(self, ArConfigArg arg, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientArg_argTextToBuf(*args)

ArClientArg_swigregister = _ArNetworkingPy.ArClientArg_swigregister
ArClientArg_swigregister(ArClientArg)

class ArClientBase(AriaPy.ArASyncTask):
    """Proxy of C++ ArClientBase class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArASyncTask]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientBase, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArASyncTask]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientBase, name)
    __repr__ = _swig_repr
    STATE_NO_CONNECTION = _ArNetworkingPy.ArClientBase_STATE_NO_CONNECTION
    STATE_FAILED_CONNECTION = _ArNetworkingPy.ArClientBase_STATE_FAILED_CONNECTION
    STATE_OPENED_SOCKET = _ArNetworkingPy.ArClientBase_STATE_OPENED_SOCKET
    STATE_EXCHANGED_INTROS = _ArNetworkingPy.ArClientBase_STATE_EXCHANGED_INTROS
    STATE_REJECTED = _ArNetworkingPy.ArClientBase_STATE_REJECTED
    STATE_WAITING_LIST = _ArNetworkingPy.ArClientBase_STATE_WAITING_LIST
    STATE_CONNECTED = _ArNetworkingPy.ArClientBase_STATE_CONNECTED
    STATE_LOST_CONNECTION = _ArNetworkingPy.ArClientBase_STATE_LOST_CONNECTION
    CLIENT_KEY_LENGTH = _ArNetworkingPy.ArClientBase_CLIENT_KEY_LENGTH
    NON_BLOCKING_CONTINUE = _ArNetworkingPy.ArClientBase_NON_BLOCKING_CONTINUE
    NON_BLOCKING_CONNECTED = _ArNetworkingPy.ArClientBase_NON_BLOCKING_CONNECTED
    NON_BLOCKING_FAILED = _ArNetworkingPy.ArClientBase_NON_BLOCKING_FAILED
    def __init__(self, *args): 
        """__init__(self) -> ArClientBase"""
        this = _ArNetworkingPy.new_ArClientBase(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientBase
    __del__ = lambda self : None;
    def setRobotName(*args):
        """
        setRobotName(self, char name, bool debugLogging=False, int robotId=0)
        setRobotName(self, char name, bool debugLogging=False)
        setRobotName(self, char name)
        """
        return _ArNetworkingPy.ArClientBase_setRobotName(*args)

    def getRobotName(*args):
        """getRobotName(self) -> char"""
        return _ArNetworkingPy.ArClientBase_getRobotName(*args)

    def getLogPrefix(*args):
        """getLogPrefix(self) -> char"""
        return _ArNetworkingPy.ArClientBase_getLogPrefix(*args)

    def getDebugLogging(*args):
        """getDebugLogging(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_getDebugLogging(*args)

    def blockingConnect(*args):
        """
        blockingConnect(self, char host, int port, bool print=True, char user=None, 
            char password=None, char openOnIP=None) -> bool
        blockingConnect(self, char host, int port, bool print=True, char user=None, 
            char password=None) -> bool
        blockingConnect(self, char host, int port, bool print=True, char user=None) -> bool
        blockingConnect(self, char host, int port, bool print=True) -> bool
        blockingConnect(self, char host, int port) -> bool
        """
        return _ArNetworkingPy.ArClientBase_blockingConnect(*args)

    def disconnect(*args):
        """disconnect(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_disconnect(*args)

    def disconnectSoon(*args):
        """disconnectSoon(self)"""
        return _ArNetworkingPy.ArClientBase_disconnectSoon(*args)

    def isConnected(*args):
        """isConnected(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_isConnected(*args)

    def wasRejected(*args):
        """wasRejected(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_wasRejected(*args)

    def getState(*args):
        """getState(self) -> int"""
        return _ArNetworkingPy.ArClientBase_getState(*args)

    def addHandler(*args):
        """addHandler(self, char name, ArFunctor1<(p.ArNetPacket)> functor) -> bool"""
        return _ArNetworkingPy.ArClientBase_addHandler(*args)

    def remHandler(*args):
        """remHandler(self, char name, ArFunctor1<(p.ArNetPacket)> functor) -> bool"""
        return _ArNetworkingPy.ArClientBase_remHandler(*args)

    def request(*args):
        """
        request(self, char name, long mSec, ArNetPacket packet=None) -> bool
        request(self, char name, long mSec) -> bool
        """
        return _ArNetworkingPy.ArClientBase_request(*args)

    def requestStop(*args):
        """requestStop(self, char name) -> bool"""
        return _ArNetworkingPy.ArClientBase_requestStop(*args)

    def requestOnce(*args):
        """
        requestOnce(self, char name, ArNetPacket packet=None, bool quiet=False) -> bool
        requestOnce(self, char name, ArNetPacket packet=None) -> bool
        requestOnce(self, char name) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestOnce(*args)

    def requestOnceUdp(*args):
        """
        requestOnceUdp(self, char name, ArNetPacket packet=None, bool quiet=False) -> bool
        requestOnceUdp(self, char name, ArNetPacket packet=None) -> bool
        requestOnceUdp(self, char name) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestOnceUdp(*args)

    def requestOnceWithString(*args):
        """requestOnceWithString(self, char name, char str) -> bool"""
        return _ArNetworkingPy.ArClientBase_requestOnceWithString(*args)

    def dataExists(*args):
        """dataExists(self, char name) -> bool"""
        return _ArNetworkingPy.ArClientBase_dataExists(*args)

    def getHost(*args):
        """getHost(self) -> char"""
        return _ArNetworkingPy.ArClientBase_getHost(*args)

    def setServerKey(*args):
        """
        setServerKey(self, char serverKey, bool print=True)
        setServerKey(self, char serverKey)
        """
        return _ArNetworkingPy.ArClientBase_setServerKey(*args)

    def getLastPacketReceived(*args):
        """getLastPacketReceived(self) -> ArTime"""
        return _ArNetworkingPy.ArClientBase_getLastPacketReceived(*args)

    def setBackupTimeout(*args):
        """setBackupTimeout(self, double timeoutInMins)"""
        return _ArNetworkingPy.ArClientBase_setBackupTimeout(*args)

    def run(*args):
        """run(self)"""
        return _ArNetworkingPy.ArClientBase_run(*args)

    def runAsync(*args):
        """runAsync(self)"""
        return _ArNetworkingPy.ArClientBase_runAsync(*args)

    def stopRunning(*args):
        """stopRunning(self)"""
        return _ArNetworkingPy.ArClientBase_stopRunning(*args)

    def isStopped(*args):
        """isStopped(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_isStopped(*args)

    def logDataList(*args):
        """logDataList(self)"""
        return _ArNetworkingPy.ArClientBase_logDataList(*args)

    def addCycleCallback(*args):
        """addCycleCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientBase_addCycleCallback(*args)

    def remCycleCallback(*args):
        """remCycleCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientBase_remCycleCallback(*args)

    def sendPacketTcp(*args):
        """sendPacketTcp(self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientBase_sendPacketTcp(*args)

    def sendPacketUdp(*args):
        """sendPacketUdp(self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientBase_sendPacketUdp(*args)

    def setConnectTimeoutTime(*args):
        """setConnectTimeoutTime(self, int sec)"""
        return _ArNetworkingPy.ArClientBase_setConnectTimeoutTime(*args)

    def getConnectTimeoutTime(*args):
        """getConnectTimeoutTime(self) -> int"""
        return _ArNetworkingPy.ArClientBase_getConnectTimeoutTime(*args)

    def logTracking(*args):
        """logTracking(self, bool terse)"""
        return _ArNetworkingPy.ArClientBase_logTracking(*args)

    def resetTracking(*args):
        """resetTracking(self)"""
        return _ArNetworkingPy.ArClientBase_resetTracking(*args)

    def addServerShutdownCB(*args):
        """
        addServerShutdownCB(self, ArFunctor functor, Pos position=LAST)
        addServerShutdownCB(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientBase_addServerShutdownCB(*args)

    def remServerShutdownCB(*args):
        """remServerShutdownCB(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientBase_remServerShutdownCB(*args)

    def addDisconnectOnErrorCB(*args):
        """
        addDisconnectOnErrorCB(self, ArFunctor functor, Pos position=LAST)
        addDisconnectOnErrorCB(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientBase_addDisconnectOnErrorCB(*args)

    def remDisconnectOnErrorCB(*args):
        """remDisconnectOnErrorCB(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientBase_remDisconnectOnErrorCB(*args)

    def loopOnce(*args):
        """loopOnce(self)"""
        return _ArNetworkingPy.ArClientBase_loopOnce(*args)

    def processPacket(*args):
        """processPacket(self, ArNetPacket packet, bool tcp)"""
        return _ArNetworkingPy.ArClientBase_processPacket(*args)

    def processPacketUdp(*args):
        """processPacketUdp(self, ArNetPacket packet, sockaddr_in sin)"""
        return _ArNetworkingPy.ArClientBase_processPacketUdp(*args)

    def setTcpOnlyFromServer(*args):
        """setTcpOnlyFromServer(self)"""
        return _ArNetworkingPy.ArClientBase_setTcpOnlyFromServer(*args)

    def setTcpOnlyToServer(*args):
        """setTcpOnlyToServer(self)"""
        return _ArNetworkingPy.ArClientBase_setTcpOnlyToServer(*args)

    def isTcpOnlyFromServer(*args):
        """isTcpOnlyFromServer(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_isTcpOnlyFromServer(*args)

    def isTcpOnlyToServer(*args):
        """isTcpOnlyToServer(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_isTcpOnlyToServer(*args)

    def getClientKey(*args):
        """getClientKey(self, unsigned char key)"""
        return _ArNetworkingPy.ArClientBase_getClientKey(*args)

    def startNonBlockingDisconnect(*args):
        """startNonBlockingDisconnect(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_startNonBlockingDisconnect(*args)

    def finishNonBlockingDisconnect(*args):
        """finishNonBlockingDisconnect(self)"""
        return _ArNetworkingPy.ArClientBase_finishNonBlockingDisconnect(*args)

    def getName(*args):
        """
        getName(self, ArNetPacket packet, bool internalCall=False) -> char
        getName(self, ArNetPacket packet) -> char
        getName(self, unsigned int command, bool internalCall=False) -> char
        getName(self, unsigned int command) -> char
        """
        return _ArNetworkingPy.ArClientBase_getName(*args)

    def runThread(*args):
        """runThread(self, void arg) -> void"""
        return _ArNetworkingPy.ArClientBase_runThread(*args)

    def getTcpAddr(*args):
        """getTcpAddr(self) -> in_addr"""
        return _ArNetworkingPy.ArClientBase_getTcpAddr(*args)

    def internalBlockingConnect(*args):
        """
        internalBlockingConnect(self, char host, int port, bool print, char user, char password, 
            ArSocket tcpSocket, char openOnIP=None) -> bool
        internalBlockingConnect(self, char host, int port, bool print, char user, char password, 
            ArSocket tcpSocket) -> bool
        """
        return _ArNetworkingPy.ArClientBase_internalBlockingConnect(*args)

    def internalNonBlockingConnectStart(*args):
        """
        internalNonBlockingConnectStart(self, char host, int port, bool print, char user, char password, 
            ArSocket tcpSocket, char openOnIP=None) -> int
        internalNonBlockingConnectStart(self, char host, int port, bool print, char user, char password, 
            ArSocket tcpSocket) -> int
        """
        return _ArNetworkingPy.ArClientBase_internalNonBlockingConnectStart(*args)

    def internalNonBlockingConnectContinue(*args):
        """internalNonBlockingConnectContinue(self) -> int"""
        return _ArNetworkingPy.ArClientBase_internalNonBlockingConnectContinue(*args)

    def getTcpSocket(*args):
        """getTcpSocket(self) -> ArSocket"""
        return _ArNetworkingPy.ArClientBase_getTcpSocket(*args)

    def getUdpSocket(*args):
        """getUdpSocket(self) -> ArSocket"""
        return _ArNetworkingPy.ArClientBase_getUdpSocket(*args)

    def getDataMap(*args):
        """getDataMap(self) -> std::map<(unsigned int,p.ArClientData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArClientData)>)>)>"""
        return _ArNetworkingPy.ArClientBase_getDataMap(*args)

    def findCommandFromName(*args):
        """findCommandFromName(self, char name) -> unsigned int"""
        return _ArNetworkingPy.ArClientBase_findCommandFromName(*args)

    def requestByCommand(*args):
        """
        requestByCommand(self, unsigned int command, long mSec, ArNetPacket packet=None) -> bool
        requestByCommand(self, unsigned int command, long mSec) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestByCommand(*args)

    def requestStopByCommand(*args):
        """requestStopByCommand(self, unsigned int command) -> bool"""
        return _ArNetworkingPy.ArClientBase_requestStopByCommand(*args)

    def requestOnceByCommand(*args):
        """
        requestOnceByCommand(self, unsigned int command, ArNetPacket packet=None) -> bool
        requestOnceByCommand(self, unsigned int command) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestOnceByCommand(*args)

    def requestOnceByCommandUdp(*args):
        """
        requestOnceByCommandUdp(self, unsigned int command, ArNetPacket packet=None) -> bool
        requestOnceByCommandUdp(self, unsigned int command) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestOnceByCommandUdp(*args)

    def getReceivedDataList(*args):
        """getReceivedDataList(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_getReceivedDataList(*args)

    def getReceivedArgRetList(*args):
        """getReceivedArgRetList(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_getReceivedArgRetList(*args)

    def getReceivedGroupAndFlagsList(*args):
        """getReceivedGroupAndFlagsList(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_getReceivedGroupAndFlagsList(*args)

    def getRejected(*args):
        """getRejected(self) -> int"""
        return _ArNetworkingPy.ArClientBase_getRejected(*args)

    def getRejectedString(*args):
        """getRejectedString(self) -> char"""
        return _ArNetworkingPy.ArClientBase_getRejectedString(*args)

ArClientBase_swigregister = _ArNetworkingPy.ArClientBase_swigregister
ArClientBase_swigregister(ArClientBase)

class ArClientCommands(_object):
    """Proxy of C++ ArClientCommands class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientCommands, name)
    __repr__ = _swig_repr
    SHUTDOWN = _ArNetworkingPy.ArClientCommands_SHUTDOWN
    INTRODUCTION = _ArNetworkingPy.ArClientCommands_INTRODUCTION
    UDP_INTRODUCTION = _ArNetworkingPy.ArClientCommands_UDP_INTRODUCTION
    UDP_CONFIRMATION = _ArNetworkingPy.ArClientCommands_UDP_CONFIRMATION
    TCP_ONLY = _ArNetworkingPy.ArClientCommands_TCP_ONLY
    LIST = _ArNetworkingPy.ArClientCommands_LIST
    REQUEST = _ArNetworkingPy.ArClientCommands_REQUEST
    REQUESTSTOP = _ArNetworkingPy.ArClientCommands_REQUESTSTOP
    def __init__(self, *args): 
        """__init__(self) -> ArClientCommands"""
        this = _ArNetworkingPy.new_ArClientCommands(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientCommands
    __del__ = lambda self : None;
ArClientCommands_swigregister = _ArNetworkingPy.ArClientCommands_swigregister
ArClientCommands_swigregister(ArClientCommands)

class ArClientData(_object):
    """Proxy of C++ ArClientData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientData, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name, char description, unsigned int command, 
            ArFunctor1<(p.ArNetPacket)> functor) -> ArClientData
        """
        this = _ArNetworkingPy.new_ArClientData(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientData
    __del__ = lambda self : None;
    def getName(*args):
        """getName(self) -> char"""
        return _ArNetworkingPy.ArClientData_getName(*args)

    def getDescription(*args):
        """getDescription(self) -> char"""
        return _ArNetworkingPy.ArClientData_getDescription(*args)

    def getCommand(*args):
        """getCommand(self) -> unsigned int"""
        return _ArNetworkingPy.ArClientData_getCommand(*args)

    def getArgumentDescription(*args):
        """getArgumentDescription(self) -> char"""
        return _ArNetworkingPy.ArClientData_getArgumentDescription(*args)

    def getReturnDescription(*args):
        """getReturnDescription(self) -> char"""
        return _ArNetworkingPy.ArClientData_getReturnDescription(*args)

    def getCommandGroup(*args):
        """getCommandGroup(self) -> char"""
        return _ArNetworkingPy.ArClientData_getCommandGroup(*args)

    def hasDataFlag(*args):
        """hasDataFlag(self, char dataFlag) -> bool"""
        return _ArNetworkingPy.ArClientData_hasDataFlag(*args)

    def getDataFlagsString(*args):
        """getDataFlagsString(self) -> char"""
        return _ArNetworkingPy.ArClientData_getDataFlagsString(*args)

    def getFunctorList(*args):
        """getFunctorList(self) -> std::list<(p.ArFunctor1<(p.ArNetPacket)>,std::allocator<(p.ArFunctor1<(p.ArNetPacket)>)>)>"""
        return _ArNetworkingPy.ArClientData_getFunctorList(*args)

    def lockFunctorList(*args):
        """lockFunctorList(self) -> int"""
        return _ArNetworkingPy.ArClientData_lockFunctorList(*args)

    def tryLockFunctorList(*args):
        """tryLockFunctorList(self) -> int"""
        return _ArNetworkingPy.ArClientData_tryLockFunctorList(*args)

    def unlockFunctorList(*args):
        """unlockFunctorList(self) -> int"""
        return _ArNetworkingPy.ArClientData_unlockFunctorList(*args)

    def addFunctor(*args):
        """addFunctor(self, ArFunctor1<(p.ArNetPacket)> functor)"""
        return _ArNetworkingPy.ArClientData_addFunctor(*args)

    def remFunctor(*args):
        """remFunctor(self, ArFunctor1<(p.ArNetPacket)> functor)"""
        return _ArNetworkingPy.ArClientData_remFunctor(*args)

    def setArgRetDescs(*args):
        """setArgRetDescs(self, char argDesc, char retDesc)"""
        return _ArNetworkingPy.ArClientData_setArgRetDescs(*args)

    def setCommandGroup(*args):
        """setCommandGroup(self, char commandGroup)"""
        return _ArNetworkingPy.ArClientData_setCommandGroup(*args)

    def addDataFlags(*args):
        """addDataFlags(self, char dataFlags)"""
        return _ArNetworkingPy.ArClientData_addDataFlags(*args)

ArClientData_swigregister = _ArNetworkingPy.ArClientData_swigregister
ArClientData_swigregister(ArClientData)

class ArClientFileListerItem(_object):
    """Proxy of C++ ArClientFileListerItem class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientFileListerItem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientFileListerItem, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name, time_t atime, time_t mtime, UByte4 size) -> ArClientFileListerItem
        __init__(self, ArClientFileListerItem item) -> ArClientFileListerItem
        """
        this = _ArNetworkingPy.new_ArClientFileListerItem(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientFileListerItem
    __del__ = lambda self : None;
    def getName(*args):
        """getName(self) -> char"""
        return _ArNetworkingPy.ArClientFileListerItem_getName(*args)

    def getLastAccessedTime(*args):
        """getLastAccessedTime(self) -> time_t"""
        return _ArNetworkingPy.ArClientFileListerItem_getLastAccessedTime(*args)

    def getLastModifiedTime(*args):
        """getLastModifiedTime(self) -> time_t"""
        return _ArNetworkingPy.ArClientFileListerItem_getLastModifiedTime(*args)

    def getSize(*args):
        """getSize(self) -> UByte4"""
        return _ArNetworkingPy.ArClientFileListerItem_getSize(*args)

ArClientFileListerItem_swigregister = _ArNetworkingPy.ArClientFileListerItem_swigregister
ArClientFileListerItem_swigregister(ArClientFileListerItem)

class ArClientFileLister(_object):
    """Proxy of C++ ArClientFileLister class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientFileLister, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientFileLister, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArClientBase client) -> ArClientFileLister"""
        this = _ArNetworkingPy.new_ArClientFileLister(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientFileLister
    __del__ = lambda self : None;
    def isAvailable(*args):
        """isAvailable(self) -> bool"""
        return _ArNetworkingPy.ArClientFileLister_isAvailable(*args)

    def changeToTopDir(*args):
        """changeToTopDir(self)"""
        return _ArNetworkingPy.ArClientFileLister_changeToTopDir(*args)

    def changeToDir(*args):
        """changeToDir(self, char dir)"""
        return _ArNetworkingPy.ArClientFileLister_changeToDir(*args)

    def upOneDir(*args):
        """upOneDir(self)"""
        return _ArNetworkingPy.ArClientFileLister_upOneDir(*args)

    def changeToAbsDir(*args):
        """changeToAbsDir(self, char dir)"""
        return _ArNetworkingPy.ArClientFileLister_changeToAbsDir(*args)

    def getCurrentDir(*args):
        """getCurrentDir(self) -> char"""
        return _ArNetworkingPy.ArClientFileLister_getCurrentDir(*args)

    def getWaitingForDir(*args):
        """getWaitingForDir(self) -> char"""
        return _ArNetworkingPy.ArClientFileLister_getWaitingForDir(*args)

    def getDirectories(*args):
        """getDirectories(self) -> std::list<(ArClientFileListerItem,std::allocator<(ArClientFileListerItem)>)>"""
        return _ArNetworkingPy.ArClientFileLister_getDirectories(*args)

    def getFiles(*args):
        """getFiles(self) -> std::list<(ArClientFileListerItem,std::allocator<(ArClientFileListerItem)>)>"""
        return _ArNetworkingPy.ArClientFileLister_getFiles(*args)

    def addUpdatedCallback(*args):
        """
        addUpdatedCallback(self, ArFunctor1_Int functor, Pos position=LAST)
        addUpdatedCallback(self, ArFunctor1_Int functor)
        """
        return _ArNetworkingPy.ArClientFileLister_addUpdatedCallback(*args)

    def remUpdatedCallback(*args):
        """remUpdatedCallback(self, ArFunctor1_Int functor)"""
        return _ArNetworkingPy.ArClientFileLister_remUpdatedCallback(*args)

    def getLastUpdated(*args):
        """getLastUpdated(self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileLister_getLastUpdated(*args)

    def getLastRequested(*args):
        """getLastRequested(self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileLister_getLastRequested(*args)

    def log(*args):
        """log(self, bool withTimes)"""
        return _ArNetworkingPy.ArClientFileLister_log(*args)

ArClientFileLister_swigregister = _ArNetworkingPy.ArClientFileLister_swigregister
ArClientFileLister_swigregister(ArClientFileLister)

class ArClientFileToClient(_object):
    """Proxy of C++ ArClientFileToClient class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientFileToClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientFileToClient, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArClientBase client) -> ArClientFileToClient"""
        this = _ArNetworkingPy.new_ArClientFileToClient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientFileToClient
    __del__ = lambda self : None;
    def isAvailable(*args):
        """isAvailable(self) -> bool"""
        return _ArNetworkingPy.ArClientFileToClient_isAvailable(*args)

    def isAvailableSetTimestamp(*args):
        """isAvailableSetTimestamp(self) -> bool"""
        return _ArNetworkingPy.ArClientFileToClient_isAvailableSetTimestamp(*args)

    def getFileFromDirectory(*args):
        """
        getFileFromDirectory(self, char directory, char fileName, char clientFileName, 
            bool isSetTimestamp=False) -> bool
        getFileFromDirectory(self, char directory, char fileName, char clientFileName) -> bool
        """
        return _ArNetworkingPy.ArClientFileToClient_getFileFromDirectory(*args)

    def cancelGet(*args):
        """cancelGet(self)"""
        return _ArNetworkingPy.ArClientFileToClient_cancelGet(*args)

    def isWaitingForFile(*args):
        """isWaitingForFile(self) -> bool"""
        return _ArNetworkingPy.ArClientFileToClient_isWaitingForFile(*args)

    def getDirectory(*args):
        """getDirectory(self) -> char"""
        return _ArNetworkingPy.ArClientFileToClient_getDirectory(*args)

    def getFileName(*args):
        """getFileName(self) -> char"""
        return _ArNetworkingPy.ArClientFileToClient_getFileName(*args)

    def getClientFileName(*args):
        """getClientFileName(self) -> char"""
        return _ArNetworkingPy.ArClientFileToClient_getClientFileName(*args)

    def addFileReceivedCallback(*args):
        """
        addFileReceivedCallback(self, ArFunctor1_Int functor, Pos position=LAST)
        addFileReceivedCallback(self, ArFunctor1_Int functor)
        """
        return _ArNetworkingPy.ArClientFileToClient_addFileReceivedCallback(*args)

    def remFileReceivedCallback(*args):
        """remFileReceivedCallback(self, ArFunctor1_Int functor)"""
        return _ArNetworkingPy.ArClientFileToClient_remFileReceivedCallback(*args)

    def getLastReceived(*args):
        """getLastReceived(self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileToClient_getLastReceived(*args)

    def getLastRequested(*args):
        """getLastRequested(self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileToClient_getLastRequested(*args)

ArClientFileToClient_swigregister = _ArNetworkingPy.ArClientFileToClient_swigregister
ArClientFileToClient_swigregister(ArClientFileToClient)

class ArClientFileFromClient(_object):
    """Proxy of C++ ArClientFileFromClient class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientFileFromClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientFileFromClient, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArClientBase client) -> ArClientFileFromClient"""
        this = _ArNetworkingPy.new_ArClientFileFromClient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientFileFromClient
    __del__ = lambda self : None;
    def isAvailable(*args):
        """isAvailable(self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isAvailable(*args)

    def isAvailableSlow(*args):
        """isAvailableSlow(self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isAvailableSlow(*args)

    def isAvailableFast(*args):
        """isAvailableFast(self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isAvailableFast(*args)

    def isAvailableSetTimestamp(*args):
        """isAvailableSetTimestamp(self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isAvailableSetTimestamp(*args)

    SPEED_AUTO = _ArNetworkingPy.ArClientFileFromClient_SPEED_AUTO
    SPEED_FAST = _ArNetworkingPy.ArClientFileFromClient_SPEED_FAST
    SPEED_SLOW = _ArNetworkingPy.ArClientFileFromClient_SPEED_SLOW
    def putFileToDirectory(*args):
        """
        putFileToDirectory(self, char directory, char fileName, char clientFileName, 
            SendSpeed sendSpeed=SPEED_AUTO, bool isSetTimestamp=False) -> bool
        putFileToDirectory(self, char directory, char fileName, char clientFileName, 
            SendSpeed sendSpeed=SPEED_AUTO) -> bool
        putFileToDirectory(self, char directory, char fileName, char clientFileName) -> bool
        """
        return _ArNetworkingPy.ArClientFileFromClient_putFileToDirectory(*args)

    def cancelPut(*args):
        """cancelPut(self)"""
        return _ArNetworkingPy.ArClientFileFromClient_cancelPut(*args)

    def isWaitingForReturn(*args):
        """isWaitingForReturn(self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isWaitingForReturn(*args)

    def getDirectory(*args):
        """getDirectory(self) -> char"""
        return _ArNetworkingPy.ArClientFileFromClient_getDirectory(*args)

    def getFileName(*args):
        """getFileName(self) -> char"""
        return _ArNetworkingPy.ArClientFileFromClient_getFileName(*args)

    def getClientFileName(*args):
        """getClientFileName(self) -> char"""
        return _ArNetworkingPy.ArClientFileFromClient_getClientFileName(*args)

    def addFileSentCallback(*args):
        """
        addFileSentCallback(self, ArFunctor1_Int functor, Pos position=LAST)
        addFileSentCallback(self, ArFunctor1_Int functor)
        """
        return _ArNetworkingPy.ArClientFileFromClient_addFileSentCallback(*args)

    def remFileSentCallback(*args):
        """remFileSentCallback(self, ArFunctor1_Int functor)"""
        return _ArNetworkingPy.ArClientFileFromClient_remFileSentCallback(*args)

    def getLastCompletedSend(*args):
        """getLastCompletedSend(self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileFromClient_getLastCompletedSend(*args)

    def getLastStartedSend(*args):
        """getLastStartedSend(self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileFromClient_getLastStartedSend(*args)

ArClientFileFromClient_swigregister = _ArNetworkingPy.ArClientFileFromClient_swigregister
ArClientFileFromClient_swigregister(ArClientFileFromClient)

class ArClientDeleteFileOnServer(_object):
    """Proxy of C++ ArClientDeleteFileOnServer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientDeleteFileOnServer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientDeleteFileOnServer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArClientBase client) -> ArClientDeleteFileOnServer"""
        this = _ArNetworkingPy.new_ArClientDeleteFileOnServer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientDeleteFileOnServer
    __del__ = lambda self : None;
    def isAvailable(*args):
        """isAvailable(self) -> bool"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_isAvailable(*args)

    def deleteFileFromDirectory(*args):
        """deleteFileFromDirectory(self, char directory, char fileName) -> bool"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_deleteFileFromDirectory(*args)

    def isWaitingForReturn(*args):
        """isWaitingForReturn(self) -> bool"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_isWaitingForReturn(*args)

    def getDirectory(*args):
        """getDirectory(self) -> char"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_getDirectory(*args)

    def getFileName(*args):
        """getFileName(self) -> char"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_getFileName(*args)

    def addFileDeletedCallback(*args):
        """
        addFileDeletedCallback(self, ArFunctor1_Int functor, Pos position=LAST)
        addFileDeletedCallback(self, ArFunctor1_Int functor)
        """
        return _ArNetworkingPy.ArClientDeleteFileOnServer_addFileDeletedCallback(*args)

    def remFileDeletedCallback(*args):
        """remFileDeletedCallback(self, ArFunctor1_Int functor)"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_remFileDeletedCallback(*args)

    def getLastCompletedSend(*args):
        """getLastCompletedSend(self) -> ArTime"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_getLastCompletedSend(*args)

    def getLastStartedSend(*args):
        """getLastStartedSend(self) -> ArTime"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_getLastStartedSend(*args)

ArClientDeleteFileOnServer_swigregister = _ArNetworkingPy.ArClientDeleteFileOnServer_swigregister
ArClientDeleteFileOnServer_swigregister(ArClientDeleteFileOnServer)

class ArClientHandlerConfig(_object):
    """Proxy of C++ ArClientHandlerConfig class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientHandlerConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientHandlerConfig, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArClientBase client, bool ignoreBounds=False, char robotName=None) -> ArClientHandlerConfig
        __init__(self, ArClientBase client, bool ignoreBounds=False) -> ArClientHandlerConfig
        __init__(self, ArClientBase client) -> ArClientHandlerConfig
        """
        this = _ArNetworkingPy.new_ArClientHandlerConfig(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientHandlerConfig
    __del__ = lambda self : None;
    def requestConfigFromServer(*args):
        """requestConfigFromServer(self)"""
        return _ArNetworkingPy.ArClientHandlerConfig_requestConfigFromServer(*args)

    def reloadConfigOnServer(*args):
        """reloadConfigOnServer(self)"""
        return _ArNetworkingPy.ArClientHandlerConfig_reloadConfigOnServer(*args)

    def getConfigCopy(*args):
        """getConfigCopy(self) -> ArConfig"""
        return _ArNetworkingPy.ArClientHandlerConfig_getConfigCopy(*args)

    def addGotConfigCB(*args):
        """
        addGotConfigCB(self, ArFunctor functor, Pos position=LAST)
        addGotConfigCB(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_addGotConfigCB(*args)

    def remGotConfigCB(*args):
        """remGotConfigCB(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientHandlerConfig_remGotConfigCB(*args)

    def addSaveConfigSucceededCB(*args):
        """
        addSaveConfigSucceededCB(self, ArFunctor functor, Pos position=LAST)
        addSaveConfigSucceededCB(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_addSaveConfigSucceededCB(*args)

    def remSaveConfigSucceededCB(*args):
        """remSaveConfigSucceededCB(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientHandlerConfig_remSaveConfigSucceededCB(*args)

    def addSaveConfigFailedCB(*args):
        """
        addSaveConfigFailedCB(self, ArFunctor1_CString functor, Pos position=LAST)
        addSaveConfigFailedCB(self, ArFunctor1_CString functor)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_addSaveConfigFailedCB(*args)

    def remSaveConfigFailedCB(*args):
        """remSaveConfigFailedCB(self, ArFunctor1_CString functor)"""
        return _ArNetworkingPy.ArClientHandlerConfig_remSaveConfigFailedCB(*args)

    def haveGottenConfig(*args):
        """haveGottenConfig(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_haveGottenConfig(*args)

    def saveConfigToServer(*args):
        """
        saveConfigToServer(self)
        saveConfigToServer(self, ArConfig config, std::set<(std::string,ArStrCaseCmpOp,std::allocator<(std::string)>)> ignoreTheseSections=None)
        saveConfigToServer(self, ArConfig config)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_saveConfigToServer(*args)

    def haveRequestedDefaults(*args):
        """haveRequestedDefaults(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_haveRequestedDefaults(*args)

    def haveGottenDefaults(*args):
        """haveGottenDefaults(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_haveGottenDefaults(*args)

    def canRequestDefaults(*args):
        """canRequestDefaults(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_canRequestDefaults(*args)

    def requestDefaultConfigFromServer(*args):
        """requestDefaultConfigFromServer(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_requestDefaultConfigFromServer(*args)

    def getDefaultConfig(*args):
        """getDefaultConfig(self) -> ArConfig"""
        return _ArNetworkingPy.ArClientHandlerConfig_getDefaultConfig(*args)

    def requestConfigDefaults(*args):
        """requestConfigDefaults(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_requestConfigDefaults(*args)

    def requestSectionDefaults(*args):
        """requestSectionDefaults(self, char section) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_requestSectionDefaults(*args)

    def addGotConfigDefaultsCB(*args):
        """
        addGotConfigDefaultsCB(self, ArFunctor functor, Pos position=LAST)
        addGotConfigDefaultsCB(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_addGotConfigDefaultsCB(*args)

    def remGotConfigDefaultsCB(*args):
        """remGotConfigDefaultsCB(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientHandlerConfig_remGotConfigDefaultsCB(*args)

    def getConfig(*args):
        """getConfig(self) -> ArConfig"""
        return _ArNetworkingPy.ArClientHandlerConfig_getConfig(*args)

    def lock(*args):
        """lock(self) -> int"""
        return _ArNetworkingPy.ArClientHandlerConfig_lock(*args)

    def tryLock(*args):
        """tryLock(self) -> int"""
        return _ArNetworkingPy.ArClientHandlerConfig_tryLock(*args)

    def unlock(*args):
        """unlock(self) -> int"""
        return _ArNetworkingPy.ArClientHandlerConfig_unlock(*args)

    def setQuiet(*args):
        """setQuiet(self, bool isQuiet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_setQuiet(*args)

    def handleGetConfigBySections(*args):
        """handleGetConfigBySections(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleGetConfigBySections(*args)

    def handleGetConfigSectionFlags(*args):
        """handleGetConfigSectionFlags(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleGetConfigSectionFlags(*args)

    def handleGetConfig(*args):
        """handleGetConfig(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleGetConfig(*args)

    def handleSetConfig(*args):
        """handleSetConfig(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleSetConfig(*args)

    def handleGetConfigDefaults(*args):
        """handleGetConfigDefaults(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleGetConfigDefaults(*args)

ArClientHandlerConfig_swigregister = _ArNetworkingPy.ArClientHandlerConfig_swigregister
ArClientHandlerConfig_swigregister(ArClientHandlerConfig)

class ArClientSimpleConnector(_object):
    """Proxy of C++ ArClientSimpleConnector class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientSimpleConnector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientSimpleConnector, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArArgumentParser parser) -> ArClientSimpleConnector
        __init__(self, int argc) -> ArClientSimpleConnector
        __init__(self, ArArgumentBuilder arguments) -> ArClientSimpleConnector
        """
        this = _ArNetworkingPy.new_ArClientSimpleConnector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientSimpleConnector
    __del__ = lambda self : None;
    def connectClient(*args):
        """
        connectClient(self, ArClientBase client, bool print=True) -> bool
        connectClient(self, ArClientBase client) -> bool
        """
        return _ArNetworkingPy.ArClientSimpleConnector_connectClient(*args)

    def parseArgs(*args):
        """
        parseArgs(self) -> bool
        parseArgs(self, ArArgumentParser parser) -> bool
        """
        return _ArNetworkingPy.ArClientSimpleConnector_parseArgs(*args)

    def logOptions(*args):
        """logOptions(self)"""
        return _ArNetworkingPy.ArClientSimpleConnector_logOptions(*args)

ArClientSimpleConnector_swigregister = _ArNetworkingPy.ArClientSimpleConnector_swigregister
ArClientSimpleConnector_swigregister(ArClientSimpleConnector)

class ArHybridForwarderVideo(AriaPy.ArCameraCollectionItem):
    """Proxy of C++ ArHybridForwarderVideo class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArCameraCollectionItem]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArHybridForwarderVideo, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArCameraCollectionItem]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArHybridForwarderVideo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArClientBase client) -> ArHybridForwarderVideo
        __init__(self, ArServerBase server, char hostname="localhost", int port=7070) -> ArHybridForwarderVideo
        __init__(self, ArServerBase server, char hostname="localhost") -> ArHybridForwarderVideo
        __init__(self, ArServerBase server) -> ArHybridForwarderVideo
        """
        this = _ArNetworkingPy.new_ArHybridForwarderVideo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArHybridForwarderVideo
    __del__ = lambda self : None;
    def isForwardingVideo(*args):
        """isForwardingVideo(self) -> bool"""
        return _ArNetworkingPy.ArHybridForwarderVideo_isForwardingVideo(*args)

    def getCameraName(*args):
        """getCameraName(self) -> char"""
        return _ArNetworkingPy.ArHybridForwarderVideo_getCameraName(*args)

    def setCameraName(*args):
        """setCameraName(self, char cameraName)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_setCameraName(*args)

    def addToCameraCollection(*args):
        """addToCameraCollection(self, ArCameraCollection collection)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_addToCameraCollection(*args)

    def sendVideoSize(*args):
        """sendVideoSize(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_sendVideoSize(*args)

    def sendVideo(*args):
        """sendVideo(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_sendVideo(*args)

    def receiveVideoSize(*args):
        """receiveVideoSize(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_receiveVideoSize(*args)

    def receiveVideo(*args):
        """receiveVideo(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_receiveVideo(*args)

    def clientCycleCallback(*args):
        """clientCycleCallback(self)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_clientCycleCallback(*args)

    def setVideoRequestTime(*args):
        """
        setVideoRequestTime(self, int ms)
        setVideoRequestTime(self) -> int
        """
        return _ArNetworkingPy.ArHybridForwarderVideo_setVideoRequestTime(*args)

ArHybridForwarderVideo_swigregister = _ArNetworkingPy.ArHybridForwarderVideo_swigregister
ArHybridForwarderVideo_swigregister(ArHybridForwarderVideo)

class ArNetPacketReceiverTcp(_object):
    """Proxy of C++ ArNetPacketReceiverTcp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNetPacketReceiverTcp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArNetPacketReceiverTcp, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArNetPacketReceiverTcp"""
        this = _ArNetworkingPy.new_ArNetPacketReceiverTcp(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArNetPacketReceiverTcp
    __del__ = lambda self : None;
    def setSocket(*args):
        """setSocket(self, ArSocket socket)"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_setSocket(*args)

    def getSocket(*args):
        """getSocket(self) -> ArSocket"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_getSocket(*args)

    def setProcessPacketCB(*args):
        """setProcessPacketCB(self, ArFunctor1<(p.ArNetPacket)> functor)"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_setProcessPacketCB(*args)

    def getProcessPacketCB(*args):
        """getProcessPacketCB(self) -> ArFunctor1<(p.ArNetPacket)>"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_getProcessPacketCB(*args)

    def setLoggingPrefix(*args):
        """setLoggingPrefix(self, char loggingPrefix)"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_setLoggingPrefix(*args)

    def readData(*args):
        """readData(self) -> bool"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_readData(*args)

    def setQuiet(*args):
        """setQuiet(self, bool quiet)"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_setQuiet(*args)

    def getQuiet(*args):
        """getQuiet(self) -> bool"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_getQuiet(*args)

ArNetPacketReceiverTcp_swigregister = _ArNetworkingPy.ArNetPacketReceiverTcp_swigregister
ArNetPacketReceiverTcp_swigregister(ArNetPacketReceiverTcp)

class ArNetPacketReceiverUdp(_object):
    """Proxy of C++ ArNetPacketReceiverUdp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNetPacketReceiverUdp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArNetPacketReceiverUdp, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArNetPacketReceiverUdp"""
        this = _ArNetworkingPy.new_ArNetPacketReceiverUdp(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArNetPacketReceiverUdp
    __del__ = lambda self : None;
    def setSocket(*args):
        """setSocket(self, ArSocket socket)"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_setSocket(*args)

    def getSocket(*args):
        """getSocket(self) -> ArSocket"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_getSocket(*args)

    def setProcessPacketCB(*args):
        """setProcessPacketCB(self, ArFunctor2<(p.ArNetPacket,p.sockaddr_in)> functor)"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_setProcessPacketCB(*args)

    def getProcessPacketCB(*args):
        """getProcessPacketCB(self) -> ArFunctor2<(p.ArNetPacket,p.sockaddr_in)>"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_getProcessPacketCB(*args)

    def readData(*args):
        """readData(self) -> bool"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_readData(*args)

ArNetPacketReceiverUdp_swigregister = _ArNetworkingPy.ArNetPacketReceiverUdp_swigregister
ArNetPacketReceiverUdp_swigregister(ArNetPacketReceiverUdp)

class ArNetPacketSenderTcp(_object):
    """Proxy of C++ ArNetPacketSenderTcp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNetPacketSenderTcp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArNetPacketSenderTcp, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArNetPacketSenderTcp"""
        this = _ArNetworkingPy.new_ArNetPacketSenderTcp(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArNetPacketSenderTcp
    __del__ = lambda self : None;
    def setSocket(*args):
        """setSocket(self, ArSocket socket)"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_setSocket(*args)

    def getSocket(*args):
        """getSocket(self) -> ArSocket"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_getSocket(*args)

    def setBackupTimeout(*args):
        """setBackupTimeout(self, double connectionTimeoutInMins)"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_setBackupTimeout(*args)

    def setDebugLogging(*args):
        """setDebugLogging(self, bool debugLogging)"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_setDebugLogging(*args)

    def setLoggingPrefix(*args):
        """setLoggingPrefix(self, char prefix)"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_setLoggingPrefix(*args)

    def sendPacket(*args):
        """
        sendPacket(self, ArNetPacket packet, char loggingString="")
        sendPacket(self, ArNetPacket packet)
        """
        return _ArNetworkingPy.ArNetPacketSenderTcp_sendPacket(*args)

    def sendData(*args):
        """sendData(self) -> bool"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_sendData(*args)

ArNetPacketSenderTcp_swigregister = _ArNetworkingPy.ArNetPacketSenderTcp_swigregister
ArNetPacketSenderTcp_swigregister(ArNetPacketSenderTcp)

class ArServerClient(_object):
    """Proxy of C++ ArServerClient class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerClient, name)
    __repr__ = _swig_repr
    STATE_SENT_INTRO = _ArNetworkingPy.ArServerClient_STATE_SENT_INTRO
    STATE_REJECTED = _ArNetworkingPy.ArServerClient_STATE_REJECTED
    STATE_CONNECTED = _ArNetworkingPy.ArServerClient_STATE_CONNECTED
    STATE_DISCONNECTED = _ArNetworkingPy.ArServerClient_STATE_DISCONNECTED
    def __init__(self, *args): 
        """
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo=None, 
            int rejecting=0, 
            char rejectingString="", 
            bool debugLogging=False, 
            char serverClientName="ArServerBase_unknown", 
            bool logPasswordFailureVerbosely=False, bool allowSlowPackets=True, 
            bool allowIdlePackets=True) -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo=None, 
            int rejecting=0, 
            char rejectingString="", 
            bool debugLogging=False, 
            char serverClientName="ArServerBase_unknown", 
            bool logPasswordFailureVerbosely=False, bool allowSlowPackets=True) -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo=None, 
            int rejecting=0, 
            char rejectingString="", 
            bool debugLogging=False, 
            char serverClientName="ArServerBase_unknown", 
            bool logPasswordFailureVerbosely=False) -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo=None, 
            int rejecting=0, 
            char rejectingString="", 
            bool debugLogging=False, 
            char serverClientName="ArServerBase_unknown") -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo=None, 
            int rejecting=0, 
            char rejectingString="", 
            bool debugLogging=False) -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo=None, 
            int rejecting=0, 
            char rejectingString="") -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo=None, 
            int rejecting=0) -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo=None) -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey) -> ArServerClient
        """
        this = _ArNetworkingPy.new_ArServerClient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerClient
    __del__ = lambda self : None;
    def tcpCallback(*args):
        """tcpCallback(self) -> bool"""
        return _ArNetworkingPy.ArServerClient_tcpCallback(*args)

    def slowPacketCallback(*args):
        """slowPacketCallback(self) -> bool"""
        return _ArNetworkingPy.ArServerClient_slowPacketCallback(*args)

    def idlePacketCallback(*args):
        """idlePacketCallback(self) -> bool"""
        return _ArNetworkingPy.ArServerClient_idlePacketCallback(*args)

    def setBackupTimeout(*args):
        """setBackupTimeout(self, double timeoutInMins)"""
        return _ArNetworkingPy.ArServerClient_setBackupTimeout(*args)

    def processPacket(*args):
        """
        processPacket(self, ArNetPacket packet, bool tcp=True)
        processPacket(self, ArNetPacket packet)
        """
        return _ArNetworkingPy.ArServerClient_processPacket(*args)

    def sendPacketTcp(*args):
        """sendPacketTcp(self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerClient_sendPacketTcp(*args)

    def sendPacketUdp(*args):
        """sendPacketUdp(self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerClient_sendPacketUdp(*args)

    def hasGroupAccess(*args):
        """hasGroupAccess(self, char group) -> bool"""
        return _ArNetworkingPy.ArServerClient_hasGroupAccess(*args)

    def broadcastPacketTcp(*args):
        """broadcastPacketTcp(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerClient_broadcastPacketTcp(*args)

    def broadcastPacketUdp(*args):
        """broadcastPacketUdp(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerClient_broadcastPacketUdp(*args)

    def logTracking(*args):
        """logTracking(self, bool terse)"""
        return _ArNetworkingPy.ArServerClient_logTracking(*args)

    def resetTracking(*args):
        """resetTracking(self)"""
        return _ArNetworkingPy.ArServerClient_resetTracking(*args)

    def getIPString(*args):
        """getIPString(self) -> char"""
        return _ArNetworkingPy.ArServerClient_getIPString(*args)

    def getIdentifier(*args):
        """getIdentifier(self) -> ArServerClientIdentifier"""
        return _ArNetworkingPy.ArServerClient_getIdentifier(*args)

    def setIdentifier(*args):
        """setIdentifier(self, ArServerClientIdentifier identifier)"""
        return _ArNetworkingPy.ArServerClient_setIdentifier(*args)

    def shutdown(*args):
        """shutdown(self)"""
        return _ArNetworkingPy.ArServerClient_shutdown(*args)

    def setUdpAddress(*args):
        """setUdpAddress(self, sockaddr_in sin)"""
        return _ArNetworkingPy.ArServerClient_setUdpAddress(*args)

    def getUdpAddress(*args):
        """getUdpAddress(self) -> sockaddr_in"""
        return _ArNetworkingPy.ArServerClient_getUdpAddress(*args)

    def getAuthKey(*args):
        """getAuthKey(self) -> long"""
        return _ArNetworkingPy.ArServerClient_getAuthKey(*args)

    def processAuthPacket(*args):
        """processAuthPacket(self, ArNetPacket packet, sockaddr_in sin)"""
        return _ArNetworkingPy.ArServerClient_processAuthPacket(*args)

    def handleRequests(*args):
        """handleRequests(self)"""
        return _ArNetworkingPy.ArServerClient_handleRequests(*args)

    def getTcpSocket(*args):
        """getTcpSocket(self) -> ArSocket"""
        return _ArNetworkingPy.ArServerClient_getTcpSocket(*args)

    def forceDisconnect(*args):
        """forceDisconnect(self, bool quiet)"""
        return _ArNetworkingPy.ArServerClient_forceDisconnect(*args)

    def getFrequency(*args):
        """getFrequency(self, UByte2 command) -> long"""
        return _ArNetworkingPy.ArServerClient_getFrequency(*args)

    def useTcpOnly(*args):
        """useTcpOnly(self)"""
        return _ArNetworkingPy.ArServerClient_useTcpOnly(*args)

    def isTcpOnly(*args):
        """isTcpOnly(self) -> bool"""
        return _ArNetworkingPy.ArServerClient_isTcpOnly(*args)

    def getState(*args):
        """getState(self) -> int"""
        return _ArNetworkingPy.ArServerClient_getState(*args)

    def hasSlowPackets(*args):
        """hasSlowPackets(self) -> bool"""
        return _ArNetworkingPy.ArServerClient_hasSlowPackets(*args)

    def hasIdlePackets(*args):
        """hasIdlePackets(self) -> bool"""
        return _ArNetworkingPy.ArServerClient_hasIdlePackets(*args)

    def findCommandFromName(*args):
        """findCommandFromName(self, char commandName) -> unsigned int"""
        return _ArNetworkingPy.ArServerClient_findCommandFromName(*args)

    def getCreationTime(*args):
        """getCreationTime(self) -> ArTime"""
        return _ArNetworkingPy.ArServerClient_getCreationTime(*args)

ArServerClient_swigregister = _ArNetworkingPy.ArServerClient_swigregister
ArServerClient_swigregister(ArServerClient)

class ArServerClientIdentifier(_object):
    """Proxy of C++ ArServerClientIdentifier class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerClientIdentifier, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerClientIdentifier, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> ArServerClientIdentifier"""
        this = _ArNetworkingPy.new_ArServerClientIdentifier(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerClientIdentifier
    __del__ = lambda self : None;
    def getIDString(*args):
        """getIDString(self) -> char"""
        return _ArNetworkingPy.ArServerClientIdentifier_getIDString(*args)

    def setConnectionID(*args):
        """setConnectionID(self, UByte4 idNum)"""
        return _ArNetworkingPy.ArServerClientIdentifier_setConnectionID(*args)

    def getConnectionID(*args):
        """getConnectionID(self) -> UByte4"""
        return _ArNetworkingPy.ArServerClientIdentifier_getConnectionID(*args)

    def setSelfIdentifier(*args):
        """setSelfIdentifier(self, char selfIdentifier)"""
        return _ArNetworkingPy.ArServerClientIdentifier_setSelfIdentifier(*args)

    def getSelfIdentifier(*args):
        """getSelfIdentifier(self) -> char"""
        return _ArNetworkingPy.ArServerClientIdentifier_getSelfIdentifier(*args)

    def setHereGoal(*args):
        """setHereGoal(self, char selfIdentifier)"""
        return _ArNetworkingPy.ArServerClientIdentifier_setHereGoal(*args)

    def getHereGoal(*args):
        """getHereGoal(self) -> char"""
        return _ArNetworkingPy.ArServerClientIdentifier_getHereGoal(*args)

    def matches(*args):
        """matches(self, ArServerClientIdentifier identifier, bool matchConnectionID) -> bool"""
        return _ArNetworkingPy.ArServerClientIdentifier_matches(*args)

    def rebuildIDString(*args):
        """rebuildIDString(self)"""
        return _ArNetworkingPy.ArServerClientIdentifier_rebuildIDString(*args)

ArServerClientIdentifier_swigregister = _ArNetworkingPy.ArServerClientIdentifier_swigregister
ArServerClientIdentifier_swigregister(ArServerClientIdentifier)

class ArServerClientData(_object):
    """Proxy of C++ ArServerClientData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerClientData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerClientData, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerData serverData, long mSecInterval, ArNetPacket packet) -> ArServerClientData"""
        this = _ArNetworkingPy.new_ArServerClientData(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerClientData
    __del__ = lambda self : None;
    def getServerData(*args):
        """getServerData(self) -> ArServerData"""
        return _ArNetworkingPy.ArServerClientData_getServerData(*args)

    def getMSec(*args):
        """getMSec(self) -> long"""
        return _ArNetworkingPy.ArServerClientData_getMSec(*args)

    def getPacket(*args):
        """getPacket(self) -> ArNetPacket"""
        return _ArNetworkingPy.ArServerClientData_getPacket(*args)

    def getLastSent(*args):
        """getLastSent(self) -> ArTime"""
        return _ArNetworkingPy.ArServerClientData_getLastSent(*args)

    def setLastSentToNow(*args):
        """setLastSentToNow(self)"""
        return _ArNetworkingPy.ArServerClientData_setLastSentToNow(*args)

    def setMSec(*args):
        """setMSec(self, long mSec)"""
        return _ArNetworkingPy.ArServerClientData_setMSec(*args)

    def setPacket(*args):
        """setPacket(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerClientData_setPacket(*args)

ArServerClientData_swigregister = _ArNetworkingPy.ArServerClientData_swigregister
ArServerClientData_swigregister(ArServerClientData)

class ArServerCommands(_object):
    """Proxy of C++ ArServerCommands class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerCommands, name)
    __repr__ = _swig_repr
    SHUTDOWN = _ArNetworkingPy.ArServerCommands_SHUTDOWN
    INTRODUCTION = _ArNetworkingPy.ArServerCommands_INTRODUCTION
    UDP_INTRODUCTION = _ArNetworkingPy.ArServerCommands_UDP_INTRODUCTION
    UDP_CONFIRMATION = _ArNetworkingPy.ArServerCommands_UDP_CONFIRMATION
    CONNECTED = _ArNetworkingPy.ArServerCommands_CONNECTED
    REJECTED = _ArNetworkingPy.ArServerCommands_REJECTED
    TCP_ONLY = _ArNetworkingPy.ArServerCommands_TCP_ONLY
    LIST = _ArNetworkingPy.ArServerCommands_LIST
    LISTSINGLE = _ArNetworkingPy.ArServerCommands_LISTSINGLE
    LISTARGRET = _ArNetworkingPy.ArServerCommands_LISTARGRET
    LISTARGRETSINGLE = _ArNetworkingPy.ArServerCommands_LISTARGRETSINGLE
    LISTGROUPANDFLAGS = _ArNetworkingPy.ArServerCommands_LISTGROUPANDFLAGS
    LISTGROUPANDFLAGSSINGLE = _ArNetworkingPy.ArServerCommands_LISTGROUPANDFLAGSSINGLE
    def __init__(self, *args): 
        """__init__(self) -> ArServerCommands"""
        this = _ArNetworkingPy.new_ArServerCommands(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerCommands
    __del__ = lambda self : None;
ArServerCommands_swigregister = _ArNetworkingPy.ArServerCommands_swigregister
ArServerCommands_swigregister(ArServerCommands)

class ArServerData(_object):
    """Proxy of C++ ArServerData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerData, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name, char description, unsigned int command, 
            ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, char returnDescription, 
            char commandGroup=None, char dataFlags=None, 
            ArRetFunctor1<(long,unsigned int)> getFrequencyFunctor=None, 
            ArFunctor2<(long,unsigned int)> requestChangedFunctor=None, 
            ArFunctor2<(p.ArServerClient,p.ArNetPacket)> requestOnceFunctor=None) -> ArServerData
        __init__(self, char name, char description, unsigned int command, 
            ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, char returnDescription, 
            char commandGroup=None, char dataFlags=None, 
            ArRetFunctor1<(long,unsigned int)> getFrequencyFunctor=None, 
            ArFunctor2<(long,unsigned int)> requestChangedFunctor=None) -> ArServerData
        __init__(self, char name, char description, unsigned int command, 
            ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, char returnDescription, 
            char commandGroup=None, char dataFlags=None, 
            ArRetFunctor1<(long,unsigned int)> getFrequencyFunctor=None) -> ArServerData
        __init__(self, char name, char description, unsigned int command, 
            ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, char returnDescription, 
            char commandGroup=None, char dataFlags=None) -> ArServerData
        __init__(self, char name, char description, unsigned int command, 
            ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, char returnDescription, 
            char commandGroup=None) -> ArServerData
        __init__(self, char name, char description, unsigned int command, 
            ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, char returnDescription) -> ArServerData
        """
        this = _ArNetworkingPy.new_ArServerData(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerData
    __del__ = lambda self : None;
    def getName(*args):
        """getName(self) -> char"""
        return _ArNetworkingPy.ArServerData_getName(*args)

    def getDescription(*args):
        """getDescription(self) -> char"""
        return _ArNetworkingPy.ArServerData_getDescription(*args)

    def getCommand(*args):
        """getCommand(self) -> unsigned int"""
        return _ArNetworkingPy.ArServerData_getCommand(*args)

    def getFunctor(*args):
        """getFunctor(self) -> ArFunctor2<(p.ArServerClient,p.ArNetPacket)>"""
        return _ArNetworkingPy.ArServerData_getFunctor(*args)

    def getArgumentDescription(*args):
        """getArgumentDescription(self) -> char"""
        return _ArNetworkingPy.ArServerData_getArgumentDescription(*args)

    def getReturnDescription(*args):
        """getReturnDescription(self) -> char"""
        return _ArNetworkingPy.ArServerData_getReturnDescription(*args)

    def getCommandGroup(*args):
        """getCommandGroup(self) -> char"""
        return _ArNetworkingPy.ArServerData_getCommandGroup(*args)

    def getRequestOnceFunctor(*args):
        """getRequestOnceFunctor(self) -> ArFunctor2<(p.ArServerClient,p.ArNetPacket)>"""
        return _ArNetworkingPy.ArServerData_getRequestOnceFunctor(*args)

    def hasDataFlag(*args):
        """hasDataFlag(self, char dataFlag) -> bool"""
        return _ArNetworkingPy.ArServerData_hasDataFlag(*args)

    def addDataFlags(*args):
        """addDataFlags(self, char dataFlags) -> bool"""
        return _ArNetworkingPy.ArServerData_addDataFlags(*args)

    def remDataFlag(*args):
        """remDataFlag(self, char dataFlag) -> bool"""
        return _ArNetworkingPy.ArServerData_remDataFlag(*args)

    def isSlowPacket(*args):
        """isSlowPacket(self) -> bool"""
        return _ArNetworkingPy.ArServerData_isSlowPacket(*args)

    def isIdlePacket(*args):
        """isIdlePacket(self) -> bool"""
        return _ArNetworkingPy.ArServerData_isIdlePacket(*args)

    def getDataFlagsString(*args):
        """getDataFlagsString(self) -> char"""
        return _ArNetworkingPy.ArServerData_getDataFlagsString(*args)

    def callRequestChangedFunctor(*args):
        """callRequestChangedFunctor(self)"""
        return _ArNetworkingPy.ArServerData_callRequestChangedFunctor(*args)

ArServerData_swigregister = _ArNetworkingPy.ArServerData_swigregister
ArServerData_swigregister(ArServerData)

class ArServerFileLister(_object):
    """Proxy of C++ ArServerFileLister class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerFileLister, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerFileLister, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, char topDir, char defaultUploadDownloadDir=None) -> ArServerFileLister
        __init__(self, ArServerBase server, char topDir) -> ArServerFileLister
        """
        this = _ArNetworkingPy.new_ArServerFileLister(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerFileLister
    __del__ = lambda self : None;
    def getDirListing(*args):
        """getDirListing(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileLister_getDirListing(*args)

    def getDirListingMultiplePackets(*args):
        """getDirListingMultiplePackets(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileLister_getDirListingMultiplePackets(*args)

    def getDefaultUploadDownloadDir(*args):
        """getDefaultUploadDownloadDir(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileLister_getDefaultUploadDownloadDir(*args)

ArServerFileLister_swigregister = _ArNetworkingPy.ArServerFileLister_swigregister
ArServerFileLister_swigregister(ArServerFileLister)

class ArServerFileToClient(_object):
    """Proxy of C++ ArServerFileToClient class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerFileToClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerFileToClient, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, char topDir) -> ArServerFileToClient"""
        this = _ArNetworkingPy.new_ArServerFileToClient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerFileToClient
    __del__ = lambda self : None;
    def getFile(*args):
        """getFile(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileToClient_getFile(*args)

    def getFileWithTimestamp(*args):
        """getFileWithTimestamp(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileToClient_getFileWithTimestamp(*args)

ArServerFileToClient_swigregister = _ArNetworkingPy.ArServerFileToClient_swigregister
ArServerFileToClient_swigregister(ArServerFileToClient)

class ArServerFileFromClient(_object):
    """Proxy of C++ ArServerFileFromClient class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerFileFromClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerFileFromClient, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, char topDir, char tempDir) -> ArServerFileFromClient"""
        this = _ArNetworkingPy.new_ArServerFileFromClient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerFileFromClient
    __del__ = lambda self : None;
    def putFile(*args):
        """putFile(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileFromClient_putFile(*args)

    def putFileInterleaved(*args):
        """putFileInterleaved(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileFromClient_putFileInterleaved(*args)

    def putFileWithTimestamp(*args):
        """putFileWithTimestamp(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileFromClient_putFileWithTimestamp(*args)

    def putFileWithTimestampInterleaved(*args):
        """putFileWithTimestampInterleaved(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileFromClient_putFileWithTimestampInterleaved(*args)

    def addPreMoveCallback(*args):
        """
        addPreMoveCallback(self, ArFunctor functor, Pos position=LAST)
        addPreMoveCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerFileFromClient_addPreMoveCallback(*args)

    def remPreMoveCallback(*args):
        """remPreMoveCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerFileFromClient_remPreMoveCallback(*args)

    def addPostMoveCallback(*args):
        """
        addPostMoveCallback(self, ArFunctor functor, Pos position=LAST)
        addPostMoveCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerFileFromClient_addPostMoveCallback(*args)

    def remPostMoveCallback(*args):
        """remPostMoveCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerFileFromClient_remPostMoveCallback(*args)

    def getMovingFileName(*args):
        """getMovingFileName(self) -> char"""
        return _ArNetworkingPy.ArServerFileFromClient_getMovingFileName(*args)

ArServerFileFromClient_swigregister = _ArNetworkingPy.ArServerFileFromClient_swigregister
ArServerFileFromClient_swigregister(ArServerFileFromClient)

class ArServerDeleteFileOnServer(_object):
    """Proxy of C++ ArServerDeleteFileOnServer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerDeleteFileOnServer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerDeleteFileOnServer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, char topDir) -> ArServerDeleteFileOnServer"""
        this = _ArNetworkingPy.new_ArServerDeleteFileOnServer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerDeleteFileOnServer
    __del__ = lambda self : None;
    def deleteFile(*args):
        """deleteFile(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerDeleteFileOnServer_deleteFile(*args)

    def addPreDeleteCallback(*args):
        """
        addPreDeleteCallback(self, ArFunctor functor, Pos position=LAST)
        addPreDeleteCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerDeleteFileOnServer_addPreDeleteCallback(*args)

    def remPreDeleteCallback(*args):
        """remPreDeleteCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerDeleteFileOnServer_remPreDeleteCallback(*args)

    def addPostDeleteCallback(*args):
        """
        addPostDeleteCallback(self, ArFunctor functor, Pos position=LAST)
        addPostDeleteCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerDeleteFileOnServer_addPostDeleteCallback(*args)

    def remPostDeleteCallback(*args):
        """remPostDeleteCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerDeleteFileOnServer_remPostDeleteCallback(*args)

    def getDeletingFileName(*args):
        """getDeletingFileName(self) -> char"""
        return _ArNetworkingPy.ArServerDeleteFileOnServer_getDeletingFileName(*args)

ArServerDeleteFileOnServer_swigregister = _ArNetworkingPy.ArServerDeleteFileOnServer_swigregister
ArServerDeleteFileOnServer_swigregister(ArServerDeleteFileOnServer)

class ArServerHandlerCamera(AriaPy.ArCameraCollectionItem):
    """Proxy of C++ ArServerHandlerCamera class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArCameraCollectionItem]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerCamera, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArCameraCollectionItem]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerCamera, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char cameraName, ArServerBase server, ArRobot robot, 
            ArPTZ camera, ArCameraCollection collection) -> ArServerHandlerCamera
        __init__(self, ArServerBase server, ArRobot robot, ArPTZ camera) -> ArServerHandlerCamera
        """
        this = _ArNetworkingPy.new_ArServerHandlerCamera(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerCamera
    __del__ = lambda self : None;
    def setCameraAbs(*args):
        """
        setCameraAbs(self, double pan, double tilt, double zoom, bool lockRobot=True)
        setCameraAbs(self, double pan, double tilt, double zoom)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_setCameraAbs(*args)

    def setCameraRel(*args):
        """
        setCameraRel(self, double pan, double tilt, double zoom, bool lockRobot=True)
        setCameraRel(self, double pan, double tilt, double zoom)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_setCameraRel(*args)

    def setCameraPct(*args):
        """
        setCameraPct(self, double panPct, double tiltPct, bool lockRobot=True)
        setCameraPct(self, double panPct, double tiltPct)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_setCameraPct(*args)

    def resetCamera(*args):
        """
        resetCamera(self, bool lockRobot=True)
        resetCamera(self)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_resetCamera(*args)

    def cameraModeLookAtGoal(*args):
        """cameraModeLookAtGoal(self)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModeLookAtGoal(*args)

    def cameraModeLookAtPoint(*args):
        """
        cameraModeLookAtPoint(self, ArPose pose, bool controlZoom=True)
        cameraModeLookAtPoint(self, ArPose pose)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModeLookAtPoint(*args)

    def cameraModeLookAtGoalSetGoal(*args):
        """cameraModeLookAtGoalSetGoal(self, ArPose pose)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModeLookAtGoalSetGoal(*args)

    def cameraModeLookAtGoalClearGoal(*args):
        """cameraModeLookAtGoalClearGoal(self)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModeLookAtGoalClearGoal(*args)

    def cameraModePosition(*args):
        """cameraModePosition(self)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModePosition(*args)

    def getCameraName(*args):
        """getCameraName(self) -> char"""
        return _ArNetworkingPy.ArServerHandlerCamera_getCameraName(*args)

    def addToCameraCollection(*args):
        """addToCameraCollection(self, ArCameraCollection collection)"""
        return _ArNetworkingPy.ArServerHandlerCamera_addToCameraCollection(*args)

    def handleGetCameraData(*args):
        """handleGetCameraData(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleGetCameraData(*args)

    def handleGetCameraInfo(*args):
        """handleGetCameraInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleGetCameraInfo(*args)

    def handleSetCameraAbs(*args):
        """handleSetCameraAbs(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleSetCameraAbs(*args)

    def handleSetCameraPct(*args):
        """handleSetCameraPct(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleSetCameraPct(*args)

    def handleSetCameraRel(*args):
        """handleSetCameraRel(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleSetCameraRel(*args)

    def handleGetCameraModeList(*args):
        """handleGetCameraModeList(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleGetCameraModeList(*args)

    def handleCameraModeUpdated(*args):
        """handleCameraModeUpdated(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleCameraModeUpdated(*args)

    def handleSetCameraMode(*args):
        """handleSetCameraMode(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleSetCameraMode(*args)

    def handleResetCamera(*args):
        """handleResetCamera(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleResetCamera(*args)

    def camera(*args):
        """camera(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_camera(*args)

    def cameraAbs(*args):
        """cameraAbs(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraAbs(*args)

    def cameraPct(*args):
        """cameraPct(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraPct(*args)

    def cameraUpdate(*args):
        """cameraUpdate(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraUpdate(*args)

    def cameraInfo(*args):
        """cameraInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraInfo(*args)

ArServerHandlerCamera_swigregister = _ArNetworkingPy.ArServerHandlerCamera_swigregister
ArServerHandlerCamera_swigregister(ArServerHandlerCamera)

class ArServerHandlerCameraCollection(_object):
    """Proxy of C++ ArServerHandlerCameraCollection class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerCameraCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerCameraCollection, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, ArCameraCollection cameraCollection) -> ArServerHandlerCameraCollection"""
        this = _ArNetworkingPy.new_ArServerHandlerCameraCollection(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerCameraCollection
    __del__ = lambda self : None;
    def getCameraList(*args):
        """getCameraList(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCameraCollection_getCameraList(*args)

    def setParams(*args):
        """setParams(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCameraCollection_setParams(*args)

    def handleCameraCollectionModified(*args):
        """handleCameraCollectionModified(self)"""
        return _ArNetworkingPy.ArServerHandlerCameraCollection_handleCameraCollectionModified(*args)

ArServerHandlerCameraCollection_swigregister = _ArNetworkingPy.ArServerHandlerCameraCollection_swigregister
ArServerHandlerCameraCollection_swigregister(ArServerHandlerCameraCollection)

class ArServerHandlerCommMonitor(_object):
    """Proxy of C++ ArServerHandlerCommMonitor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerCommMonitor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerCommMonitor, name)
    __repr__ = _swig_repr
    MIN_HEARTBEAT_INTERVAL = _ArNetworkingPy.ArServerHandlerCommMonitor_MIN_HEARTBEAT_INTERVAL
    DEFAULT_HEARTBEAT_INTERVAL = _ArNetworkingPy.ArServerHandlerCommMonitor_DEFAULT_HEARTBEAT_INTERVAL
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, int heartbeatInterval=DEFAULT_HEARTBEAT_INTERVAL) -> ArServerHandlerCommMonitor
        __init__(self, ArServerBase server) -> ArServerHandlerCommMonitor
        """
        this = _ArNetworkingPy.new_ArServerHandlerCommMonitor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerCommMonitor
    __del__ = lambda self : None;
    def handleGetHeartbeatInterval(*args):
        """handleGetHeartbeatInterval(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommMonitor_handleGetHeartbeatInterval(*args)

    def handleAckCommTcp(*args):
        """handleAckCommTcp(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommMonitor_handleAckCommTcp(*args)

    def handleAckCommUdp(*args):
        """handleAckCommUdp(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommMonitor_handleAckCommUdp(*args)

    def cycleCallback(*args):
        """cycleCallback(self)"""
        return _ArNetworkingPy.ArServerHandlerCommMonitor_cycleCallback(*args)

ArServerHandlerCommMonitor_swigregister = _ArNetworkingPy.ArServerHandlerCommMonitor_swigregister
ArServerHandlerCommMonitor_swigregister(ArServerHandlerCommMonitor)

class ArServerHandlerCommands(_object):
    """Proxy of C++ ArServerHandlerCommands class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerCommands, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server) -> ArServerHandlerCommands"""
        this = _ArNetworkingPy.new_ArServerHandlerCommands(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerCommands
    __del__ = lambda self : None;
    def addCommand(*args):
        """
        addCommand(self, char name, char description, ArFunctor functor, char commandGroup=None) -> bool
        addCommand(self, char name, char description, ArFunctor functor) -> bool
        """
        return _ArNetworkingPy.ArServerHandlerCommands_addCommand(*args)

    def addStringCommand(*args):
        """
        addStringCommand(self, char name, char description, ArFunctor1<(p.ArArgumentBuilder)> functor, 
            char commandGroup=None) -> bool
        addStringCommand(self, char name, char description, ArFunctor1<(p.ArArgumentBuilder)> functor) -> bool
        """
        return _ArNetworkingPy.ArServerHandlerCommands_addStringCommand(*args)

    def setPrefix(*args):
        """setPrefix(self, char prefix)"""
        return _ArNetworkingPy.ArServerHandlerCommands_setPrefix(*args)

    def getPrefix(*args):
        """getPrefix(self) -> char"""
        return _ArNetworkingPy.ArServerHandlerCommands_getPrefix(*args)

    def netListCommands(*args):
        """netListCommands(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommands_netListCommands(*args)

    def netListStringCommands(*args):
        """netListStringCommands(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommands_netListStringCommands(*args)

ArServerHandlerCommands_swigregister = _ArNetworkingPy.ArServerHandlerCommands_swigregister
ArServerHandlerCommands_swigregister(ArServerHandlerCommands)

class ArServerHandlerConfig(_object):
    """Proxy of C++ ArServerHandlerConfig class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerConfig, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArConfig config, char defaultFile=None, 
            char defaultFileBaseDirectory=None) -> ArServerHandlerConfig
        __init__(self, ArServerBase server, ArConfig config, char defaultFile=None) -> ArServerHandlerConfig
        __init__(self, ArServerBase server, ArConfig config) -> ArServerHandlerConfig
        """
        this = _ArNetworkingPy.new_ArServerHandlerConfig(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerConfig
    __del__ = lambda self : None;
    def reloadConfig(*args):
        """reloadConfig(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_reloadConfig(*args)

    def getConfigBySections(*args):
        """getConfigBySections(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigBySections(*args)

    def getConfig(*args):
        """getConfig(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfig(*args)

    def setConfig(*args):
        """setConfig(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setConfig(*args)

    def getConfigDefaults(*args):
        """getConfigDefaults(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigDefaults(*args)

    def getConfigSectionFlags(*args):
        """getConfigSectionFlags(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigSectionFlags(*args)

    def addPreWriteCallback(*args):
        """
        addPreWriteCallback(self, ArFunctor functor, Pos position=LAST)
        addPreWriteCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerConfig_addPreWriteCallback(*args)

    def remPreWriteCallback(*args):
        """remPreWriteCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerConfig_remPreWriteCallback(*args)

    def addPostWriteCallback(*args):
        """
        addPostWriteCallback(self, ArFunctor functor, Pos position=LAST)
        addPostWriteCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerConfig_addPostWriteCallback(*args)

    def remPostWriteCallback(*args):
        """remPostWriteCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerConfig_remPostWriteCallback(*args)

    def addConfigUpdatedCallback(*args):
        """
        addConfigUpdatedCallback(self, ArFunctor functor, Pos position=LAST)
        addConfigUpdatedCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerConfig_addConfigUpdatedCallback(*args)

    def remConfigUpdatedCallback(*args):
        """remConfigUpdatedCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerConfig_remConfigUpdatedCallback(*args)

    def lockConfig(*args):
        """lockConfig(self) -> int"""
        return _ArNetworkingPy.ArServerHandlerConfig_lockConfig(*args)

    def tryLockConfig(*args):
        """tryLockConfig(self) -> int"""
        return _ArNetworkingPy.ArServerHandlerConfig_tryLockConfig(*args)

    def unlockConfig(*args):
        """unlockConfig(self) -> int"""
        return _ArNetworkingPy.ArServerHandlerConfig_unlockConfig(*args)

    def writeConfig(*args):
        """writeConfig(self) -> bool"""
        return _ArNetworkingPy.ArServerHandlerConfig_writeConfig(*args)

    def configUpdated(*args):
        """
        configUpdated(self, ArServerClient client=None) -> bool
        configUpdated(self) -> bool
        """
        return _ArNetworkingPy.ArServerHandlerConfig_configUpdated(*args)

    def loadDefaultsFromFile(*args):
        """loadDefaultsFromFile(self) -> bool"""
        return _ArNetworkingPy.ArServerHandlerConfig_loadDefaultsFromFile(*args)

    def loadDefaultsFromPacket(*args):
        """loadDefaultsFromPacket(self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerHandlerConfig_loadDefaultsFromPacket(*args)

    def createEmptyConfigDefaults(*args):
        """createEmptyConfigDefaults(self)"""
        return _ArNetworkingPy.ArServerHandlerConfig_createEmptyConfigDefaults(*args)

ArServerHandlerConfig_swigregister = _ArNetworkingPy.ArServerHandlerConfig_swigregister
ArServerHandlerConfig_swigregister(ArServerHandlerConfig)

class ArServerHandlerMap(_object):
    """Proxy of C++ ArServerHandlerMap class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerMap, name)
    __repr__ = _swig_repr
    LINES = _ArNetworkingPy.ArServerHandlerMap_LINES
    POINTS = _ArNetworkingPy.ArServerHandlerMap_POINTS
    BOTH = _ArNetworkingPy.ArServerHandlerMap_BOTH
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArMapInterface arMap=None, DataToSend dataToSend=BOTH) -> ArServerHandlerMap
        __init__(self, ArServerBase server, ArMapInterface arMap=None) -> ArServerHandlerMap
        __init__(self, ArServerBase server) -> ArServerHandlerMap
        """
        this = _ArNetworkingPy.new_ArServerHandlerMap(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerMap
    __del__ = lambda self : None;
    def loadMap(*args):
        """loadMap(self, char mapFile) -> bool"""
        return _ArNetworkingPy.ArServerHandlerMap_loadMap(*args)

    def useMap(*args):
        """
        useMap(self, ArMapInterface mapObj, bool takeOwnershipOfMap=False)
        useMap(self, ArMapInterface mapObj)
        """
        return _ArNetworkingPy.ArServerHandlerMap_useMap(*args)

    def getMap(*args):
        """getMap(self) -> ArMapInterface"""
        return _ArNetworkingPy.ArServerHandlerMap_getMap(*args)

    def serverGetMapId(*args):
        """serverGetMapId(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapId(*args)

    def serverGetMapName(*args):
        """serverGetMapName(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapName(*args)

    def serverGetMap(*args):
        """serverGetMap(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMap(*args)

    def serverGetMapBinary(*args):
        """serverGetMapBinary(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapBinary(*args)

    def serverGetMapMultiScans(*args):
        """serverGetMapMultiScans(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapMultiScans(*args)

    def serverGetMapWithMaxCategory(*args):
        """serverGetMapWithMaxCategory(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapWithMaxCategory(*args)

    def serverGetGoals(*args):
        """serverGetGoals(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetGoals(*args)

    def setDataToSend(*args):
        """setDataToSend(self, DataToSend dataToSend)"""
        return _ArNetworkingPy.ArServerHandlerMap_setDataToSend(*args)

    def getDataToSend(*args):
        """getDataToSend(self) -> int"""
        return _ArNetworkingPy.ArServerHandlerMap_getDataToSend(*args)

ArServerHandlerMap_swigregister = _ArNetworkingPy.ArServerHandlerMap_swigregister
ArServerHandlerMap_swigregister(ArServerHandlerMap)

class ArServerHandlerMapping(_object):
    """Proxy of C++ ArServerHandlerMapping class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerMapping, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerMapping, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser, 
            char baseDirectory="", char tempDirectory="", 
            bool useReflectorValues=False, ArLaser laser2=None, 
            char sickSuffix=None, char sick2Suffix=None) -> ArServerHandlerMapping
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser, 
            char baseDirectory="", char tempDirectory="", 
            bool useReflectorValues=False, ArLaser laser2=None, 
            char sickSuffix=None) -> ArServerHandlerMapping
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser, 
            char baseDirectory="", char tempDirectory="", 
            bool useReflectorValues=False, ArLaser laser2=None) -> ArServerHandlerMapping
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser, 
            char baseDirectory="", char tempDirectory="", 
            bool useReflectorValues=False) -> ArServerHandlerMapping
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser, 
            char baseDirectory="", char tempDirectory="") -> ArServerHandlerMapping
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser, 
            char baseDirectory="") -> ArServerHandlerMapping
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser) -> ArServerHandlerMapping
        """
        this = _ArNetworkingPy.new_ArServerHandlerMapping(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerMapping
    __del__ = lambda self : None;
    def serverMappingStart(*args):
        """serverMappingStart(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMapping_serverMappingStart(*args)

    def serverMappingEnd(*args):
        """serverMappingEnd(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMapping_serverMappingEnd(*args)

    def serverMappingStatus(*args):
        """serverMappingStatus(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMapping_serverMappingStatus(*args)

    def isMapping(*args):
        """isMapping(self) -> bool"""
        return _ArNetworkingPy.ArServerHandlerMapping_isMapping(*args)

    def getFileName(*args):
        """getFileName(self) -> char"""
        return _ArNetworkingPy.ArServerHandlerMapping_getFileName(*args)

    def getMapName(*args):
        """getMapName(self) -> char"""
        return _ArNetworkingPy.ArServerHandlerMapping_getMapName(*args)

    def addSimpleCommands(*args):
        """addSimpleCommands(self, ArServerHandlerCommands handlerCommands)"""
        return _ArNetworkingPy.ArServerHandlerMapping_addSimpleCommands(*args)

    def simpleLoopStart(*args):
        """simpleLoopStart(self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerHandlerMapping_simpleLoopStart(*args)

    def simpleLoopEnd(*args):
        """simpleLoopEnd(self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerHandlerMapping_simpleLoopEnd(*args)

    def addStringForStartOfLogs(*args):
        """
        addStringForStartOfLogs(self, char str, Pos position=LAST)
        addStringForStartOfLogs(self, char str)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addStringForStartOfLogs(*args)

    def remStringForStartOfLogs(*args):
        """remStringForStartOfLogs(self, char str)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remStringForStartOfLogs(*args)

    def addTagToLog(*args):
        """addTagToLog(self, char str)"""
        return _ArNetworkingPy.ArServerHandlerMapping_addTagToLog(*args)

    def addInfoToLog(*args):
        """addInfoToLog(self, char str)"""
        return _ArNetworkingPy.ArServerHandlerMapping_addInfoToLog(*args)

    def addLocationData(*args):
        """addLocationData(self, char name, ArRetFunctor2<(int,ArTime,p.ArPose)> functor) -> bool"""
        return _ArNetworkingPy.ArServerHandlerMapping_addLocationData(*args)

    def addMappingStartCallback(*args):
        """
        addMappingStartCallback(self, ArFunctor functor, Pos position=LAST)
        addMappingStartCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addMappingStartCallback(*args)

    def remMappingStartCallback(*args):
        """remMappingStartCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remMappingStartCallback(*args)

    def addMappingEndCallback(*args):
        """
        addMappingEndCallback(self, ArFunctor functor, Pos position=LAST)
        addMappingEndCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addMappingEndCallback(*args)

    def remMappingEndCallback(*args):
        """remMappingEndCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remMappingEndCallback(*args)

    def addPreMoveCallback(*args):
        """
        addPreMoveCallback(self, ArFunctor functor, Pos position=LAST)
        addPreMoveCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addPreMoveCallback(*args)

    def remPreMoveCallback(*args):
        """remPreMoveCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remPreMoveCallback(*args)

    def addPostMoveCallback(*args):
        """
        addPostMoveCallback(self, ArFunctor functor, Pos position=LAST)
        addPostMoveCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addPostMoveCallback(*args)

    def remPostMoveCallback(*args):
        """remPostMoveCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remPostMoveCallback(*args)

    def packetHandler(*args):
        """packetHandler(self, ArRobotPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerHandlerMapping_packetHandler(*args)

    def getLocationDataMap(*args):
        """getLocationDataMap(self) -> 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)>)>)>)>"""
        return _ArNetworkingPy.ArServerHandlerMapping_getLocationDataMap(*args)

    def addStringsForStartOfLogToMap(*args):
        """addStringsForStartOfLogToMap(self, ArMap arMap)"""
        return _ArNetworkingPy.ArServerHandlerMapping_addStringsForStartOfLogToMap(*args)

ArServerHandlerMapping_swigregister = _ArNetworkingPy.ArServerHandlerMapping_swigregister
ArServerHandlerMapping_swigregister(ArServerHandlerMapping)

class ArServerInfoDrawings(_object):
    """Proxy of C++ ArServerInfoDrawings class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerInfoDrawings, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerInfoDrawings, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server) -> ArServerInfoDrawings"""
        this = _ArNetworkingPy.new_ArServerInfoDrawings(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerInfoDrawings
    __del__ = lambda self : None;
    def addDrawing(*args):
        """addDrawing(self, ArDrawingData drawingData, char name, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor) -> bool"""
        return _ArNetworkingPy.ArServerInfoDrawings_addDrawing(*args)

    def addRangeDevice(*args):
        """addRangeDevice(self, ArRangeDevice rangeDevice) -> bool"""
        return _ArNetworkingPy.ArServerInfoDrawings_addRangeDevice(*args)

    def addRobotsRangeDevices(*args):
        """addRobotsRangeDevices(self, ArRobot robot) -> bool"""
        return _ArNetworkingPy.ArServerInfoDrawings_addRobotsRangeDevices(*args)

    def netListDrawings(*args):
        """netListDrawings(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoDrawings_netListDrawings(*args)

    def netGetDrawingList(*args):
        """netGetDrawingList(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoDrawings_netGetDrawingList(*args)

    def netRangeDeviceCurrent(*args):
        """netRangeDeviceCurrent(self, ArServerClient client, ArNetPacket packet, ArRangeDevice device)"""
        return _ArNetworkingPy.ArServerInfoDrawings_netRangeDeviceCurrent(*args)

    def netRangeDeviceCumulative(*args):
        """netRangeDeviceCumulative(self, ArServerClient client, ArNetPacket packet, ArRangeDevice device)"""
        return _ArNetworkingPy.ArServerInfoDrawings_netRangeDeviceCumulative(*args)

ArServerInfoDrawings_swigregister = _ArNetworkingPy.ArServerInfoDrawings_swigregister
ArServerInfoDrawings_swigregister(ArServerInfoDrawings)

class ArServerInfoRobot(_object):
    """Proxy of C++ ArServerInfoRobot class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerInfoRobot, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerInfoRobot, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, ArRobot robot) -> ArServerInfoRobot"""
        this = _ArNetworkingPy.new_ArServerInfoRobot(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerInfoRobot
    __del__ = lambda self : None;
    def update(*args):
        """update(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_update(*args)

    def updateNumbers(*args):
        """updateNumbers(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_updateNumbers(*args)

    def updateStrings(*args):
        """updateStrings(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_updateStrings(*args)

    def batteryInfo(*args):
        """batteryInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_batteryInfo(*args)

    def physicalInfo(*args):
        """physicalInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_physicalInfo(*args)

    def activityTimeInfo(*args):
        """activityTimeInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_activityTimeInfo(*args)

ArServerInfoRobot_swigregister = _ArNetworkingPy.ArServerInfoRobot_swigregister
ArServerInfoRobot_swigregister(ArServerInfoRobot)

class ArServerInfoSensor(_object):
    """Proxy of C++ ArServerInfoSensor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerInfoSensor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerInfoSensor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, ArRobot robot) -> ArServerInfoSensor"""
        this = _ArNetworkingPy.new_ArServerInfoSensor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerInfoSensor
    __del__ = lambda self : None;
    def getSensorList(*args):
        """getSensorList(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoSensor_getSensorList(*args)

    def getSensorCurrent(*args):
        """getSensorCurrent(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoSensor_getSensorCurrent(*args)

    def getSensorCumulative(*args):
        """getSensorCumulative(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoSensor_getSensorCumulative(*args)

ArServerInfoSensor_swigregister = _ArNetworkingPy.ArServerInfoSensor_swigregister
ArServerInfoSensor_swigregister(ArServerInfoSensor)

class ArServerInfoStrings(_object):
    """Proxy of C++ ArServerInfoStrings class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerInfoStrings, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerInfoStrings, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server) -> ArServerInfoStrings"""
        this = _ArNetworkingPy.new_ArServerInfoStrings(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerInfoStrings
    __del__ = lambda self : None;
    def netGetStringsInfo(*args):
        """netGetStringsInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoStrings_netGetStringsInfo(*args)

    def netGetStrings(*args):
        """netGetStrings(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoStrings_netGetStrings(*args)

    def addString(*args):
        """addString(self, char name, UByte2 maxLen, ArFunctor2<(p.char,ArTypes::UByte2)> functor)"""
        return _ArNetworkingPy.ArServerInfoStrings_addString(*args)

    def getAddStringFunctor(*args):
        """getAddStringFunctor(self) -> ArFunctor3<(p.q(const).char,ArTypes::UByte2,p.ArFunctor2<(p.char,ArTypes::UByte2)>)>"""
        return _ArNetworkingPy.ArServerInfoStrings_getAddStringFunctor(*args)

ArServerInfoStrings_swigregister = _ArNetworkingPy.ArServerInfoStrings_swigregister
ArServerInfoStrings_swigregister(ArServerInfoStrings)

class ArServerModeDrive(ArServerMode):
    """Proxy of C++ ArServerModeDrive class"""
    __swig_setmethods__ = {}
    for _s in [ArServerMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeDrive, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeDrive, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick=False) -> ArServerModeDrive
        __init__(self, ArServerBase server, ArRobot robot) -> ArServerModeDrive
        """
        this = _ArNetworkingPy.new_ArServerModeDrive(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeDrive
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return _ArNetworkingPy.ArServerModeDrive_activate(*args)

    def deactivate(*args):
        """deactivate(self)"""
        return _ArNetworkingPy.ArServerModeDrive_deactivate(*args)

    def addControlCommands(*args):
        """addControlCommands(self, ArServerHandlerCommands handlerCommands)"""
        return _ArNetworkingPy.ArServerModeDrive_addControlCommands(*args)

    def driveJoystick(*args):
        """
        driveJoystick(self, double vel, double rotVel, bool isActivating=True)
        driveJoystick(self, double vel, double rotVel)
        """
        return _ArNetworkingPy.ArServerModeDrive_driveJoystick(*args)

    def serverDriveJoystick(*args):
        """serverDriveJoystick(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerModeDrive_serverDriveJoystick(*args)

    def userTask(*args):
        """userTask(self)"""
        return _ArNetworkingPy.ArServerModeDrive_userTask(*args)

    def setThrottleParams(*args):
        """setThrottleParams(self, int lowSpeed, int highSpeed)"""
        return _ArNetworkingPy.ArServerModeDrive_setThrottleParams(*args)

    def getActionGroup(*args):
        """getActionGroup(self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeDrive_getActionGroup(*args)

    def setSafeDriving(*args):
        """setSafeDriving(self, bool safe)"""
        return _ArNetworkingPy.ArServerModeDrive_setSafeDriving(*args)

    def getSafeDriving(*args):
        """getSafeDriving(self) -> bool"""
        return _ArNetworkingPy.ArServerModeDrive_getSafeDriving(*args)

    def setExtraUnsafeAction(*args):
        """setExtraUnsafeAction(self, ArAction action)"""
        return _ArNetworkingPy.ArServerModeDrive_setExtraUnsafeAction(*args)

ArServerModeDrive_swigregister = _ArNetworkingPy.ArServerModeDrive_swigregister
ArServerModeDrive_swigregister(ArServerModeDrive)

class ArServerModeIdle(ArServerMode):
    """Proxy of C++ ArServerModeIdle class"""
    __swig_setmethods__ = {}
    for _s in [ArServerMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeIdle, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeIdle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, ArRobot robot) -> ArServerModeIdle"""
        this = _ArNetworkingPy.new_ArServerModeIdle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeIdle
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return _ArNetworkingPy.ArServerModeIdle_activate(*args)

    def deactivate(*args):
        """deactivate(self)"""
        return _ArNetworkingPy.ArServerModeIdle_deactivate(*args)

    def userTask(*args):
        """userTask(self)"""
        return _ArNetworkingPy.ArServerModeIdle_userTask(*args)

    def setModeInterrupted(*args):
        """setModeInterrupted(self, ArServerMode modeInterrupted)"""
        return _ArNetworkingPy.ArServerModeIdle_setModeInterrupted(*args)

    def getModeInterrupted(*args):
        """getModeInterrupted(self) -> ArServerMode"""
        return _ArNetworkingPy.ArServerModeIdle_getModeInterrupted(*args)

    def getActionGroup(*args):
        """getActionGroup(self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeIdle_getActionGroup(*args)

    def addToConfig(*args):
        """
        addToConfig(self, ArConfig config, char section="Teleop settings")
        addToConfig(self, ArConfig config)
        """
        return _ArNetworkingPy.ArServerModeIdle_addToConfig(*args)

    def setUseLocationDependentDevices(*args):
        """
        setUseLocationDependentDevices(self, bool useLocationDependentDevices, bool internal=False)
        setUseLocationDependentDevices(self, bool useLocationDependentDevices)
        """
        return _ArNetworkingPy.ArServerModeIdle_setUseLocationDependentDevices(*args)

    def getUseLocationDependentDevices(*args):
        """getUseLocationDependentDevices(self) -> bool"""
        return _ArNetworkingPy.ArServerModeIdle_getUseLocationDependentDevices(*args)

ArServerModeIdle_swigregister = _ArNetworkingPy.ArServerModeIdle_swigregister
ArServerModeIdle_swigregister(ArServerModeIdle)

class ArServerModeRatioDrive(ArServerMode):
    """Proxy of C++ ArServerModeRatioDrive class"""
    __swig_setmethods__ = {}
    for _s in [ArServerMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeRatioDrive, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeRatioDrive, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick=True, 
            bool useComputerJoystick=True, 
            bool useRobotJoystick=True, bool useServerCommands=True, 
            char name="ratioDrive", bool robotJoystickOverridesLocks=True) -> ArServerModeRatioDrive
        __init__(self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick=True, 
            bool useComputerJoystick=True, 
            bool useRobotJoystick=True, bool useServerCommands=True, 
            char name="ratioDrive") -> ArServerModeRatioDrive
        __init__(self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick=True, 
            bool useComputerJoystick=True, 
            bool useRobotJoystick=True, bool useServerCommands=True) -> ArServerModeRatioDrive
        __init__(self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick=True, 
            bool useComputerJoystick=True, 
            bool useRobotJoystick=True) -> ArServerModeRatioDrive
        __init__(self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick=True, 
            bool useComputerJoystick=True) -> ArServerModeRatioDrive
        __init__(self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick=True) -> ArServerModeRatioDrive
        __init__(self, ArServerBase server, ArRobot robot) -> ArServerModeRatioDrive
        """
        this = _ArNetworkingPy.new_ArServerModeRatioDrive(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeRatioDrive
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_activate(*args)

    def deactivate(*args):
        """deactivate(self)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_deactivate(*args)

    def addControlCommands(*args):
        """addControlCommands(self, ArServerHandlerCommands handlerCommands)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_addControlCommands(*args)

    def ratioDrive(*args):
        """
        ratioDrive(self, double transRatio, double rotRatio, double throttleRatio, 
            bool isActivating=False, double latRatio=0)
        ratioDrive(self, double transRatio, double rotRatio, double throttleRatio, 
            bool isActivating=False)
        ratioDrive(self, double transRatio, double rotRatio, double throttleRatio)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_ratioDrive(*args)

    def addToConfig(*args):
        """addToConfig(self, ArConfig config, char section)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_addToConfig(*args)

    def userTask(*args):
        """userTask(self)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_userTask(*args)

    def getActionGroup(*args):
        """getActionGroup(self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeRatioDrive_getActionGroup(*args)

    def getActionRatioInput(*args):
        """getActionRatioInput(self) -> ArActionRatioInput"""
        return _ArNetworkingPy.ArServerModeRatioDrive_getActionRatioInput(*args)

    def setSafeDriving(*args):
        """
        setSafeDriving(self, bool safe, bool internal=False)
        setSafeDriving(self, bool safe)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_setSafeDriving(*args)

    def getSafeDriving(*args):
        """getSafeDriving(self) -> bool"""
        return _ArNetworkingPy.ArServerModeRatioDrive_getSafeDriving(*args)

    def setUseLocationDependentDevices(*args):
        """
        setUseLocationDependentDevices(self, bool useLocationDependentDevices, bool internal=False)
        setUseLocationDependentDevices(self, bool useLocationDependentDevices)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_setUseLocationDependentDevices(*args)

    def getUseLocationDependentDevices(*args):
        """getUseLocationDependentDevices(self) -> bool"""
        return _ArNetworkingPy.ArServerModeRatioDrive_getUseLocationDependentDevices(*args)

    def addSafeDrivingCallback(*args):
        """
        addSafeDrivingCallback(self, ArFunctor functor, int position=50)
        addSafeDrivingCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_addSafeDrivingCallback(*args)

    def remSafeDrivingCallback(*args):
        """remSafeDrivingCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_remSafeDrivingCallback(*args)

    def addUnsafeDrivingCallback(*args):
        """
        addUnsafeDrivingCallback(self, ArFunctor functor, int position=50)
        addUnsafeDrivingCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_addUnsafeDrivingCallback(*args)

    def remUnsafeDrivingCallback(*args):
        """remUnsafeDrivingCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_remUnsafeDrivingCallback(*args)

    def addDrivingBackwardsCallback(*args):
        """
        addDrivingBackwardsCallback(self, ArFunctor functor, int position=50)
        addDrivingBackwardsCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_addDrivingBackwardsCallback(*args)

    def remDrivingBackwardsCallback(*args):
        """remDrivingBackwardsCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_remDrivingBackwardsCallback(*args)

ArServerModeRatioDrive_swigregister = _ArNetworkingPy.ArServerModeRatioDrive_swigregister
ArServerModeRatioDrive_swigregister(ArServerModeRatioDrive)

class ArServerModeStop(ArServerMode):
    """Proxy of C++ ArServerModeStop class"""
    __swig_setmethods__ = {}
    for _s in [ArServerMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeStop, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeStop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArRobot robot, bool defunct=False) -> ArServerModeStop
        __init__(self, ArServerBase server, ArRobot robot) -> ArServerModeStop
        """
        this = _ArNetworkingPy.new_ArServerModeStop(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeStop
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return _ArNetworkingPy.ArServerModeStop_activate(*args)

    def deactivate(*args):
        """deactivate(self)"""
        return _ArNetworkingPy.ArServerModeStop_deactivate(*args)

    def stop(*args):
        """stop(self)"""
        return _ArNetworkingPy.ArServerModeStop_stop(*args)

    def netStop(*args):
        """netStop(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerModeStop_netStop(*args)

    def userTask(*args):
        """userTask(self)"""
        return _ArNetworkingPy.ArServerModeStop_userTask(*args)

    def checkDefault(*args):
        """checkDefault(self)"""
        return _ArNetworkingPy.ArServerModeStop_checkDefault(*args)

    def getActionGroup(*args):
        """getActionGroup(self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeStop_getActionGroup(*args)

    def addToConfig(*args):
        """
        addToConfig(self, ArConfig config, char section="Teleop settings")
        addToConfig(self, ArConfig config)
        """
        return _ArNetworkingPy.ArServerModeStop_addToConfig(*args)

    def setUseLocationDependentDevices(*args):
        """
        setUseLocationDependentDevices(self, bool useLocationDependentDevices, bool internal=False)
        setUseLocationDependentDevices(self, bool useLocationDependentDevices)
        """
        return _ArNetworkingPy.ArServerModeStop_setUseLocationDependentDevices(*args)

    def getUseLocationDependentDevices(*args):
        """getUseLocationDependentDevices(self) -> bool"""
        return _ArNetworkingPy.ArServerModeStop_getUseLocationDependentDevices(*args)

ArServerModeStop_swigregister = _ArNetworkingPy.ArServerModeStop_swigregister
ArServerModeStop_swigregister(ArServerModeStop)

class ArServerModeWander(ArServerMode):
    """Proxy of C++ ArServerModeWander class"""
    __swig_setmethods__ = {}
    for _s in [ArServerMode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeWander, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeWander, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, ArRobot robot) -> ArServerModeWander"""
        this = _ArNetworkingPy.new_ArServerModeWander(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeWander
    __del__ = lambda self : None;
    def activate(*args):
        """activate(self)"""
        return _ArNetworkingPy.ArServerModeWander_activate(*args)

    def deactivate(*args):
        """deactivate(self)"""
        return _ArNetworkingPy.ArServerModeWander_deactivate(*args)

    def wander(*args):
        """wander(self)"""
        return _ArNetworkingPy.ArServerModeWander_wander(*args)

    def netWander(*args):
        """netWander(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerModeWander_netWander(*args)

    def userTask(*args):
        """userTask(self)"""
        return _ArNetworkingPy.ArServerModeWander_userTask(*args)

    def checkDefault(*args):
        """checkDefault(self)"""
        return _ArNetworkingPy.ArServerModeWander_checkDefault(*args)

    def getActionGroup(*args):
        """getActionGroup(self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeWander_getActionGroup(*args)

ArServerModeWander_swigregister = _ArNetworkingPy.ArServerModeWander_swigregister
ArServerModeWander_swigregister(ArServerModeWander)

class ArServerSimpleComUC(_object):
    """Proxy of C++ ArServerSimpleComUC class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComUC, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComUC, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerHandlerCommands handlerCommands, ArRobot robot) -> ArServerSimpleComUC"""
        this = _ArNetworkingPy.new_ArServerSimpleComUC(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComUC
    __del__ = lambda self : None;
    def command(*args):
        """command(self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerSimpleComUC_command(*args)

    def motionCommand(*args):
        """motionCommand(self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerSimpleComUC_motionCommand(*args)

ArServerSimpleComUC_swigregister = _ArNetworkingPy.ArServerSimpleComUC_swigregister
ArServerSimpleComUC_swigregister(ArServerSimpleComUC)

class ArServerSimpleComMovementLogging(_object):
    """Proxy of C++ ArServerSimpleComMovementLogging class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComMovementLogging, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComMovementLogging, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerHandlerCommands handlerCommands, ArRobot robot, 
            ArServerHandlerPopup popupHandler=None) -> ArServerSimpleComMovementLogging
        __init__(self, ArServerHandlerCommands handlerCommands, ArRobot robot) -> ArServerSimpleComMovementLogging
        """
        this = _ArNetworkingPy.new_ArServerSimpleComMovementLogging(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComMovementLogging
    __del__ = lambda self : None;
    def logMovementSentEnable(*args):
        """logMovementSentEnable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logMovementSentEnable(*args)

    def logMovementSentDisable(*args):
        """logMovementSentDisable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logMovementSentDisable(*args)

    def logMovementReceivedEnable(*args):
        """logMovementReceivedEnable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logMovementReceivedEnable(*args)

    def logMovementReceivedDisable(*args):
        """logMovementReceivedDisable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logMovementReceivedDisable(*args)

    def logVelocitiesReceivedEnable(*args):
        """logVelocitiesReceivedEnable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logVelocitiesReceivedEnable(*args)

    def logVelocitiesReceivedDisable(*args):
        """logVelocitiesReceivedDisable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logVelocitiesReceivedDisable(*args)

    def packetsReceivedTrackingEnable(*args):
        """packetsReceivedTrackingEnable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_packetsReceivedTrackingEnable(*args)

    def packetsReceivedTrackingDisable(*args):
        """packetsReceivedTrackingDisable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_packetsReceivedTrackingDisable(*args)

    def packetsSentTrackingEnable(*args):
        """packetsSentTrackingEnable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_packetsSentTrackingEnable(*args)

    def packetsSentTrackingDisable(*args):
        """packetsSentTrackingDisable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_packetsSentTrackingDisable(*args)

    def logActionsEnable(*args):
        """logActionsEnable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logActionsEnable(*args)

    def logActionsDisable(*args):
        """logActionsDisable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logActionsDisable(*args)

    def logActions(*args):
        """logActions(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logActions(*args)

    def popupMovementParams(*args):
        """popupMovementParams(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_popupMovementParams(*args)

    def resetOdometer(*args):
        """resetOdometer(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_resetOdometer(*args)

ArServerSimpleComMovementLogging_swigregister = _ArNetworkingPy.ArServerSimpleComMovementLogging_swigregister
ArServerSimpleComMovementLogging_swigregister(ArServerSimpleComMovementLogging)

class ArServerSimpleComGyro(_object):
    """Proxy of C++ ArServerSimpleComGyro class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComGyro, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComGyro, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerHandlerCommands handlerCommands, ArRobot robot, 
            ArAnalogGyro gyro) -> ArServerSimpleComGyro
        """
        this = _ArNetworkingPy.new_ArServerSimpleComGyro(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComGyro
    __del__ = lambda self : None;
    def gyroEnable(*args):
        """gyroEnable(self)"""
        return _ArNetworkingPy.ArServerSimpleComGyro_gyroEnable(*args)

    def gyroDisable(*args):
        """gyroDisable(self)"""
        return _ArNetworkingPy.ArServerSimpleComGyro_gyroDisable(*args)

ArServerSimpleComGyro_swigregister = _ArNetworkingPy.ArServerSimpleComGyro_swigregister
ArServerSimpleComGyro_swigregister(ArServerSimpleComGyro)

class ArServerSimpleComLogRobotConfig(_object):
    """Proxy of C++ ArServerSimpleComLogRobotConfig class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComLogRobotConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComLogRobotConfig, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerHandlerCommands commands, ArRobot robot, ArServerHandlerPopup popupHandler=None) -> ArServerSimpleComLogRobotConfig
        __init__(self, ArServerHandlerCommands commands, ArRobot robot) -> ArServerSimpleComLogRobotConfig
        """
        this = _ArNetworkingPy.new_ArServerSimpleComLogRobotConfig(*args)
        try: self.this.append(this)
        except: self.this = this
    def logConfig(*args):
        """logConfig(self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_logConfig(*args)

    def logMovementConfig(*args):
        """logMovementConfig(self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_logMovementConfig(*args)

    def logOrigConfig(*args):
        """logOrigConfig(self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_logOrigConfig(*args)

    def popupConfig(*args):
        """popupConfig(self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_popupConfig(*args)

    def popupOrigConfig(*args):
        """popupOrigConfig(self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_popupOrigConfig(*args)

    def popupMovementConfig(*args):
        """popupMovementConfig(self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_popupMovementConfig(*args)

    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComLogRobotConfig
    __del__ = lambda self : None;
ArServerSimpleComLogRobotConfig_swigregister = _ArNetworkingPy.ArServerSimpleComLogRobotConfig_swigregister
ArServerSimpleComLogRobotConfig_swigregister(ArServerSimpleComLogRobotConfig)

class ArServerSimpleComLogActions(_object):
    """Proxy of C++ ArServerSimpleComLogActions class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComLogActions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComLogActions, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerHandlerCommands commands, ArRobot robot) -> ArServerSimpleComLogActions"""
        this = _ArNetworkingPy.new_ArServerSimpleComLogActions(*args)
        try: self.this.append(this)
        except: self.this = this
    def logActions(*args):
        """logActions(self)"""
        return _ArNetworkingPy.ArServerSimpleComLogActions_logActions(*args)

    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComLogActions
    __del__ = lambda self : None;
ArServerSimpleComLogActions_swigregister = _ArNetworkingPy.ArServerSimpleComLogActions_swigregister
ArServerSimpleComLogActions_swigregister(ArServerSimpleComLogActions)

class ArServerSimpleServerCommands(_object):
    """Proxy of C++ ArServerSimpleServerCommands class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleServerCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleServerCommands, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerHandlerCommands commands, ArServerBase server, 
            bool addLogConnections=True) -> ArServerSimpleServerCommands
        __init__(self, ArServerHandlerCommands commands, ArServerBase server) -> ArServerSimpleServerCommands
        """
        this = _ArNetworkingPy.new_ArServerSimpleServerCommands(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleServerCommands
    __del__ = lambda self : None;
    def logTerseTracking(*args):
        """logTerseTracking(self)"""
        return _ArNetworkingPy.ArServerSimpleServerCommands_logTerseTracking(*args)

    def logVerboseTracking(*args):
        """logVerboseTracking(self)"""
        return _ArNetworkingPy.ArServerSimpleServerCommands_logVerboseTracking(*args)

    def resetTracking(*args):
        """resetTracking(self)"""
        return _ArNetworkingPy.ArServerSimpleServerCommands_resetTracking(*args)

    def logConnections(*args):
        """logConnections(self)"""
        return _ArNetworkingPy.ArServerSimpleServerCommands_logConnections(*args)

ArServerSimpleServerCommands_swigregister = _ArNetworkingPy.ArServerSimpleServerCommands_swigregister
ArServerSimpleServerCommands_swigregister(ArServerSimpleServerCommands)

class ArServerSimplePopup(_object):
    """Proxy of C++ ArServerSimplePopup class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimplePopup, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimplePopup, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerHandlerCommands commands, ArServerHandlerPopup popupHandler) -> ArServerSimplePopup"""
        this = _ArNetworkingPy.new_ArServerSimplePopup(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimplePopup
    __del__ = lambda self : None;
    def simplePopup(*args):
        """simplePopup(self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerSimplePopup_simplePopup(*args)

ArServerSimplePopup_swigregister = _ArNetworkingPy.ArServerSimplePopup_swigregister
ArServerSimplePopup_swigregister(ArServerSimplePopup)

class ArServerSimpleLogRobotDebugPackets(_object):
    """Proxy of C++ ArServerSimpleLogRobotDebugPackets class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleLogRobotDebugPackets, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleLogRobotDebugPackets, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerHandlerCommands commands, ArRobot robot, char baseDirectory="") -> ArServerSimpleLogRobotDebugPackets
        __init__(self, ArServerHandlerCommands commands, ArRobot robot) -> ArServerSimpleLogRobotDebugPackets
        """
        this = _ArNetworkingPy.new_ArServerSimpleLogRobotDebugPackets(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleLogRobotDebugPackets
    __del__ = lambda self : None;
    def startLogging(*args):
        """
        startLogging(self, char fileName="robotDebugPacketsLog.txt") -> bool
        startLogging(self) -> bool
        """
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_startLogging(*args)

    def stopLogging(*args):
        """stopLogging(self) -> bool"""
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_stopLogging(*args)

    def packetHandler(*args):
        """packetHandler(self, ArRobotPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_packetHandler(*args)

    def addToInfoGroup(*args):
        """
        addToInfoGroup(self, ArStringInfoGroup infoGroup, char name, int whichVal, 
            char format="%d")
        addToInfoGroup(self, ArStringInfoGroup infoGroup, char name, int whichVal)
        """
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_addToInfoGroup(*args)

    def getNumValues(*args):
        """getNumValues(self) -> int"""
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_getNumValues(*args)

    def getValue(*args):
        """getValue(self, int whichVal) -> int"""
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_getValue(*args)

ArServerSimpleLogRobotDebugPackets_swigregister = _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_swigregister
ArServerSimpleLogRobotDebugPackets_swigregister(ArServerSimpleLogRobotDebugPackets)

class ArServerSimpleConnectionTester(_object):
    """Proxy of C++ ArServerSimpleConnectionTester class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleConnectionTester, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleConnectionTester, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerHandlerCommands handlerCommands, ArRobot robot) -> ArServerSimpleConnectionTester"""
        this = _ArNetworkingPy.new_ArServerSimpleConnectionTester(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleConnectionTester
    __del__ = lambda self : None;
    def connectionTestStart(*args):
        """connectionTestStart(self)"""
        return _ArNetworkingPy.ArServerSimpleConnectionTester_connectionTestStart(*args)

    def connectionTestStop(*args):
        """connectionTestStop(self)"""
        return _ArNetworkingPy.ArServerSimpleConnectionTester_connectionTestStop(*args)

ArServerSimpleConnectionTester_swigregister = _ArNetworkingPy.ArServerSimpleConnectionTester_swigregister
ArServerSimpleConnectionTester_swigregister(ArServerSimpleConnectionTester)

class ArServerSimpleOpener(_object):
    """Proxy of C++ ArServerSimpleOpener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleOpener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleOpener, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArArgumentParser parser, char prefix="") -> ArServerSimpleOpener
        __init__(self, ArArgumentParser parser) -> ArServerSimpleOpener
        """
        this = _ArNetworkingPy.new_ArServerSimpleOpener(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleOpener
    __del__ = lambda self : None;
    def open(*args):
        """
        open(self, ArServerBase server, char baseDirectory="", int secondsToTryFor=240) -> bool
        open(self, ArServerBase server, char baseDirectory="") -> bool
        open(self, ArServerBase server) -> bool
        """
        return _ArNetworkingPy.ArServerSimpleOpener_open(*args)

    def parseArgs(*args):
        """
        parseArgs(self) -> bool
        parseArgs(self, ArArgumentParser parser) -> bool
        """
        return _ArNetworkingPy.ArServerSimpleOpener_parseArgs(*args)

    def logOptions(*args):
        """logOptions(self)"""
        return _ArNetworkingPy.ArServerSimpleOpener_logOptions(*args)

    def checkAndLog(*args):
        """checkAndLog(self) -> bool"""
        return _ArNetworkingPy.ArServerSimpleOpener_checkAndLog(*args)

    def wasUserFileBad(*args):
        """wasUserFileBad(self) -> bool"""
        return _ArNetworkingPy.ArServerSimpleOpener_wasUserFileBad(*args)

    def didOpenFail(*args):
        """didOpenFail(self) -> bool"""
        return _ArNetworkingPy.ArServerSimpleOpener_didOpenFail(*args)

    def getPort(*args):
        """getPort(self) -> int"""
        return _ArNetworkingPy.ArServerSimpleOpener_getPort(*args)

    def parseFile(*args):
        """parseFile(self, char fileName) -> bool"""
        return _ArNetworkingPy.ArServerSimpleOpener_parseFile(*args)

    def setServerTcpOnly(*args):
        """setServerTcpOnly(self, bool serverTcpOnly)"""
        return _ArNetworkingPy.ArServerSimpleOpener_setServerTcpOnly(*args)

ArServerSimpleOpener_swigregister = _ArNetworkingPy.ArServerSimpleOpener_swigregister
ArServerSimpleOpener_swigregister(ArServerSimpleOpener)

class ArServerUserInfo(_object):
    """Proxy of C++ ArServerUserInfo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerUserInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerUserInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char baseDirectory=None) -> ArServerUserInfo
        __init__(self) -> ArServerUserInfo
        """
        this = _ArNetworkingPy.new_ArServerUserInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerUserInfo
    __del__ = lambda self : None;
    def readFile(*args):
        """readFile(self, char fileName) -> bool"""
        return _ArNetworkingPy.ArServerUserInfo_readFile(*args)

    def setBaseDirectory(*args):
        """setBaseDirectory(self, char baseDirectory)"""
        return _ArNetworkingPy.ArServerUserInfo_setBaseDirectory(*args)

    def matchUserPassword(*args):
        """
        matchUserPassword(self, char user, unsigned char password, char passwordKey, 
            char serverKey, bool logFailureVerbosely=False) -> bool
        matchUserPassword(self, char user, unsigned char password, char passwordKey, 
            char serverKey) -> bool
        """
        return _ArNetworkingPy.ArServerUserInfo_matchUserPassword(*args)

    def doNotUse(*args):
        """doNotUse(self) -> bool"""
        return _ArNetworkingPy.ArServerUserInfo_doNotUse(*args)

    def getUsersGroups(*args):
        """getUsersGroups(self, char user) -> std::set<(std::string,ArStrCaseCmpOp,std::allocator<(std::string)>)>"""
        return _ArNetworkingPy.ArServerUserInfo_getUsersGroups(*args)

    def logUsers(*args):
        """logUsers(self)"""
        return _ArNetworkingPy.ArServerUserInfo_logUsers(*args)

ArServerUserInfo_swigregister = _ArNetworkingPy.ArServerUserInfo_swigregister
ArServerUserInfo_swigregister(ArServerUserInfo)



