libcapsclient/libs/swig/gempa/CAPS.py

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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_CAPS')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_CAPS')
    _CAPS = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_CAPS', [dirname(__file__)])
        except ImportError:
            import _CAPS
            return _CAPS
        try:
            _mod = imp.load_module('_CAPS', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _CAPS = swig_import_helper()
    del swig_import_helper
else:
    import _CAPS
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            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("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

class TimeSpan(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeSpan, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TimeSpan, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CAPS.new_TimeSpan(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, arg2):
        return _CAPS.TimeSpan___eq__(self, arg2)

    def __ne__(self, arg2):
        return _CAPS.TimeSpan___ne__(self, arg2)

    def __lt__(self, arg2):
        return _CAPS.TimeSpan___lt__(self, arg2)

    def __le__(self, arg2):
        return _CAPS.TimeSpan___le__(self, arg2)

    def __gt__(self, arg2):
        return _CAPS.TimeSpan___gt__(self, arg2)

    def __ge__(self, arg2):
        return _CAPS.TimeSpan___ge__(self, arg2)

    def __add__(self, arg2):
        return _CAPS.TimeSpan___add__(self, arg2)

    def __sub__(self, arg2):
        return _CAPS.TimeSpan___sub__(self, arg2)

    def __iadd__(self, arg2):
        return _CAPS.TimeSpan___iadd__(self, arg2)

    def __isub__(self, arg2):
        return _CAPS.TimeSpan___isub__(self, arg2)

    def abs(self):
        return _CAPS.TimeSpan_abs(self)

    def seconds(self):
        return _CAPS.TimeSpan_seconds(self)

    def microseconds(self):
        return _CAPS.TimeSpan_microseconds(self)

    def length(self):
        return _CAPS.TimeSpan_length(self)

    def set(self, seconds):
        return _CAPS.TimeSpan_set(self, seconds)

    def setUSecs(self, arg2):
        return _CAPS.TimeSpan_setUSecs(self, arg2)

    def elapsedTime(self, days, hours=None, minutes=None, seconds=None):
        return _CAPS.TimeSpan_elapsedTime(self, days, hours, minutes, seconds)
    __swig_destroy__ = _CAPS.delete_TimeSpan
    __del__ = lambda self: None
TimeSpan_swigregister = _CAPS.TimeSpan_swigregister
TimeSpan_swigregister(TimeSpan)

class Time(TimeSpan):
    __swig_setmethods__ = {}
    for _s in [TimeSpan]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Time, name, value)
    __swig_getmethods__ = {}
    for _s in [TimeSpan]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Time, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CAPS.new_Time(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __nonzero__(self):
        return _CAPS.Time___nonzero__(self)
    __bool__ = __nonzero__



    def __add__(self, arg2):
        return _CAPS.Time___add__(self, arg2)

    def __sub__(self, *args):
        return _CAPS.Time___sub__(self, *args)

    def __iadd__(self, arg2):
        return _CAPS.Time___iadd__(self, arg2)

    def __isub__(self, arg2):
        return _CAPS.Time___isub__(self, arg2)

    def set(self, year, month, day, hour, min, sec, usec):
        return _CAPS.Time_set(self, year, month, day, hour, min, sec, usec)

    def get(self, year, month=None, day=None, hour=None, min=None, sec=None, usec=None):
        return _CAPS.Time_get(self, year, month, day, hour, min, sec, usec)

    def get2(self, year, yday=None, hour=None, min=None, sec=None, usec=None):
        return _CAPS.Time_get2(self, year, yday, hour, min, sec, usec)
    if _newclass:
        LocalTime = staticmethod(_CAPS.Time_LocalTime)
    else:
        LocalTime = _CAPS.Time_LocalTime
    if _newclass:
        GMT = staticmethod(_CAPS.Time_GMT)
    else:
        GMT = _CAPS.Time_GMT
    if _newclass:
        FromYearDay = staticmethod(_CAPS.Time_FromYearDay)
    else:
        FromYearDay = _CAPS.Time_FromYearDay

    def localtime(self):
        return _CAPS.Time_localtime(self)

    def gmt(self):
        return _CAPS.Time_gmt(self)

    def toLocalTime(self):
        return _CAPS.Time_toLocalTime(self)

    def toGMT(self):
        return _CAPS.Time_toGMT(self)

    def valid(self):
        return _CAPS.Time_valid(self)

    def toString(self, fmt):
        return _CAPS.Time_toString(self, fmt)

    def iso(self):
        return _CAPS.Time_iso(self)

    def fromString(self, str, fmt):
        return _CAPS.Time_fromString(self, str, fmt)
    if _newclass:
        FromString = staticmethod(_CAPS.Time_FromString)
    else:
        FromString = _CAPS.Time_FromString
    __swig_destroy__ = _CAPS.delete_Time
    __del__ = lambda self: None
Time_swigregister = _CAPS.Time_swigregister
Time_swigregister(Time)
cvar = _CAPS.cvar
Time.Null = _CAPS.cvar.Time_Null

def Time_LocalTime():
    return _CAPS.Time_LocalTime()
Time_LocalTime = _CAPS.Time_LocalTime

def Time_GMT():
    return _CAPS.Time_GMT()
Time_GMT = _CAPS.Time_GMT

def Time_FromYearDay(year, year_day):
    return _CAPS.Time_FromYearDay(year, year_day)
Time_FromYearDay = _CAPS.Time_FromYearDay

def Time_FromString(str, fmt):
    return _CAPS.Time_FromString(str, fmt)
Time_FromString = _CAPS.Time_FromString

UnknownPacket = _CAPS.UnknownPacket
RawDataPacket = _CAPS.RawDataPacket
MSEEDPacket = _CAPS.MSEEDPacket
ANYPacket = _CAPS.ANYPacket
RTCM2Packet = _CAPS.RTCM2Packet
MetaDataPacket = _CAPS.MetaDataPacket
FixedRawDataPacket = _CAPS.FixedRawDataPacket
PacketTypeCount = _CAPS.PacketTypeCount
DT_Unknown = _CAPS.DT_Unknown
DT_DOUBLE = _CAPS.DT_DOUBLE
DT_FLOAT = _CAPS.DT_FLOAT
DT_INT64 = _CAPS.DT_INT64
DT_INT32 = _CAPS.DT_INT32
DT_INT16 = _CAPS.DT_INT16
DT_INT8 = _CAPS.DT_INT8
class UOM(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UOM, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UOM, name)
    __repr__ = _swig_repr
    __swig_setmethods__["str"] = _CAPS.UOM_str_set
    __swig_getmethods__["str"] = _CAPS.UOM_str_get
    if _newclass:
        str = _swig_property(_CAPS.UOM_str_get, _CAPS.UOM_str_set)
    __swig_setmethods__["ID"] = _CAPS.UOM_ID_set
    __swig_getmethods__["ID"] = _CAPS.UOM_ID_get
    if _newclass:
        ID = _swig_property(_CAPS.UOM_ID_get, _CAPS.UOM_ID_set)

    def __init__(self):
        this = _CAPS.new_UOM()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_UOM
    __del__ = lambda self: None
UOM_swigregister = _CAPS.UOM_swigregister
UOM_swigregister(UOM)

class Quality(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Quality, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Quality, name)
    __repr__ = _swig_repr
    __swig_setmethods__["str"] = _CAPS.Quality_str_set
    __swig_getmethods__["str"] = _CAPS.Quality_str_get
    if _newclass:
        str = _swig_property(_CAPS.Quality_str_get, _CAPS.Quality_str_set)
    __swig_setmethods__["ID"] = _CAPS.Quality_ID_set
    __swig_getmethods__["ID"] = _CAPS.Quality_ID_get
    if _newclass:
        ID = _swig_property(_CAPS.Quality_ID_get, _CAPS.Quality_ID_set)

    def __init__(self):
        this = _CAPS.new_Quality()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_Quality
    __del__ = lambda self: None
Quality_swigregister = _CAPS.Quality_swigregister
Quality_swigregister(Quality)

class TimeStamp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeStamp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TimeStamp, name)
    __repr__ = _swig_repr
    __swig_setmethods__["year"] = _CAPS.TimeStamp_year_set
    __swig_getmethods__["year"] = _CAPS.TimeStamp_year_get
    if _newclass:
        year = _swig_property(_CAPS.TimeStamp_year_get, _CAPS.TimeStamp_year_set)
    __swig_setmethods__["yday"] = _CAPS.TimeStamp_yday_set
    __swig_getmethods__["yday"] = _CAPS.TimeStamp_yday_get
    if _newclass:
        yday = _swig_property(_CAPS.TimeStamp_yday_get, _CAPS.TimeStamp_yday_set)
    __swig_setmethods__["hour"] = _CAPS.TimeStamp_hour_set
    __swig_getmethods__["hour"] = _CAPS.TimeStamp_hour_get
    if _newclass:
        hour = _swig_property(_CAPS.TimeStamp_hour_get, _CAPS.TimeStamp_hour_set)
    __swig_setmethods__["minute"] = _CAPS.TimeStamp_minute_set
    __swig_getmethods__["minute"] = _CAPS.TimeStamp_minute_get
    if _newclass:
        minute = _swig_property(_CAPS.TimeStamp_minute_get, _CAPS.TimeStamp_minute_set)
    __swig_setmethods__["second"] = _CAPS.TimeStamp_second_set
    __swig_getmethods__["second"] = _CAPS.TimeStamp_second_get
    if _newclass:
        second = _swig_property(_CAPS.TimeStamp_second_get, _CAPS.TimeStamp_second_set)
    __swig_setmethods__["unused"] = _CAPS.TimeStamp_unused_set
    __swig_getmethods__["unused"] = _CAPS.TimeStamp_unused_get
    if _newclass:
        unused = _swig_property(_CAPS.TimeStamp_unused_get, _CAPS.TimeStamp_unused_set)
    __swig_setmethods__["usec"] = _CAPS.TimeStamp_usec_set
    __swig_getmethods__["usec"] = _CAPS.TimeStamp_usec_get
    if _newclass:
        usec = _swig_property(_CAPS.TimeStamp_usec_get, _CAPS.TimeStamp_usec_set)

    def __init__(self):
        this = _CAPS.new_TimeStamp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_TimeStamp
    __del__ = lambda self: None
TimeStamp_swigregister = _CAPS.TimeStamp_swigregister
TimeStamp_swigregister(TimeStamp)

class PacketDataHeader(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PacketDataHeader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PacketDataHeader, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CAPS.new_PacketDataHeader(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["version"] = _CAPS.PacketDataHeader_version_set
    __swig_getmethods__["version"] = _CAPS.PacketDataHeader_version_get
    if _newclass:
        version = _swig_property(_CAPS.PacketDataHeader_version_get, _CAPS.PacketDataHeader_version_set)
    __swig_setmethods__["packetType"] = _CAPS.PacketDataHeader_packetType_set
    __swig_getmethods__["packetType"] = _CAPS.PacketDataHeader_packetType_get
    if _newclass:
        packetType = _swig_property(_CAPS.PacketDataHeader_packetType_get, _CAPS.PacketDataHeader_packetType_set)
    __swig_setmethods__["unitOfMeasurement"] = _CAPS.PacketDataHeader_unitOfMeasurement_set
    __swig_getmethods__["unitOfMeasurement"] = _CAPS.PacketDataHeader_unitOfMeasurement_get
    if _newclass:
        unitOfMeasurement = _swig_property(_CAPS.PacketDataHeader_unitOfMeasurement_get, _CAPS.PacketDataHeader_unitOfMeasurement_set)

    def setUOM(self, type):
        return _CAPS.PacketDataHeader_setUOM(self, type)

    def uom(self, *args):
        return _CAPS.PacketDataHeader_uom(self, *args)

    def __ne__(self, other):
        return _CAPS.PacketDataHeader___ne__(self, other)

    def dataSize(self):
        return _CAPS.PacketDataHeader_dataSize(self)

    def put(self, buf):
        return _CAPS.PacketDataHeader_put(self, buf)

    def get(self, buf):
        return _CAPS.PacketDataHeader_get(self, buf)
    __swig_destroy__ = _CAPS.delete_PacketDataHeader
    __del__ = lambda self: None
PacketDataHeader_swigregister = _CAPS.PacketDataHeader_swigregister
PacketDataHeader_swigregister(PacketDataHeader)

class PacketDataHeaderV2(PacketDataHeader):
    __swig_setmethods__ = {}
    for _s in [PacketDataHeader]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PacketDataHeaderV2, name, value)
    __swig_getmethods__ = {}
    for _s in [PacketDataHeader]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PacketDataHeaderV2, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _CAPS.new_PacketDataHeaderV2()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["samplingFrequencyNumerator"] = _CAPS.PacketDataHeaderV2_samplingFrequencyNumerator_set
    __swig_getmethods__["samplingFrequencyNumerator"] = _CAPS.PacketDataHeaderV2_samplingFrequencyNumerator_get
    if _newclass:
        samplingFrequencyNumerator = _swig_property(_CAPS.PacketDataHeaderV2_samplingFrequencyNumerator_get, _CAPS.PacketDataHeaderV2_samplingFrequencyNumerator_set)
    __swig_setmethods__["samplingFrequencyDenominator"] = _CAPS.PacketDataHeaderV2_samplingFrequencyDenominator_set
    __swig_getmethods__["samplingFrequencyDenominator"] = _CAPS.PacketDataHeaderV2_samplingFrequencyDenominator_get
    if _newclass:
        samplingFrequencyDenominator = _swig_property(_CAPS.PacketDataHeaderV2_samplingFrequencyDenominator_get, _CAPS.PacketDataHeaderV2_samplingFrequencyDenominator_set)
    __swig_setmethods__["quality"] = _CAPS.PacketDataHeaderV2_quality_set
    __swig_getmethods__["quality"] = _CAPS.PacketDataHeaderV2_quality_get
    if _newclass:
        quality = _swig_property(_CAPS.PacketDataHeaderV2_quality_get, _CAPS.PacketDataHeaderV2_quality_set)

    def __ne__(self, other):
        return _CAPS.PacketDataHeaderV2___ne__(self, other)

    def dataSize(self):
        return _CAPS.PacketDataHeaderV2_dataSize(self)

    def put(self, buf):
        return _CAPS.PacketDataHeaderV2_put(self, buf)

    def get(self, buf):
        return _CAPS.PacketDataHeaderV2_get(self, buf)
    __swig_destroy__ = _CAPS.delete_PacketDataHeaderV2
    __del__ = lambda self: None
PacketDataHeaderV2_swigregister = _CAPS.PacketDataHeaderV2_swigregister
PacketDataHeaderV2_swigregister(PacketDataHeaderV2)

NetworkCode = _CAPS.NetworkCode
StationCode = _CAPS.StationCode
LocationCode = _CAPS.LocationCode
ChannelCode = _CAPS.ChannelCode
StreamIDComponentSize = _CAPS.StreamIDComponentSize
class PacketHeaderV1(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PacketHeaderV1, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PacketHeaderV1, name)
    __repr__ = _swig_repr
    __swig_setmethods__["SIDSize"] = _CAPS.PacketHeaderV1_SIDSize_set
    __swig_getmethods__["SIDSize"] = _CAPS.PacketHeaderV1_SIDSize_get
    if _newclass:
        SIDSize = _swig_property(_CAPS.PacketHeaderV1_SIDSize_get, _CAPS.PacketHeaderV1_SIDSize_set)
    __swig_setmethods__["size"] = _CAPS.PacketHeaderV1_size_set
    __swig_getmethods__["size"] = _CAPS.PacketHeaderV1_size_get
    if _newclass:
        size = _swig_property(_CAPS.PacketHeaderV1_size_get, _CAPS.PacketHeaderV1_size_set)

    def put(self, buf):
        return _CAPS.PacketHeaderV1_put(self, buf)

    def dataSize(self):
        return _CAPS.PacketHeaderV1_dataSize(self)

    def __init__(self):
        this = _CAPS.new_PacketHeaderV1()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_PacketHeaderV1
    __del__ = lambda self: None
PacketHeaderV1_swigregister = _CAPS.PacketHeaderV1_swigregister
PacketHeaderV1_swigregister(PacketHeaderV1)

class PacketHeaderV2(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PacketHeaderV2, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PacketHeaderV2, name)
    __repr__ = _swig_repr
    __swig_setmethods__["SIDSize"] = _CAPS.PacketHeaderV2_SIDSize_set
    __swig_getmethods__["SIDSize"] = _CAPS.PacketHeaderV2_SIDSize_get
    if _newclass:
        SIDSize = _swig_property(_CAPS.PacketHeaderV2_SIDSize_get, _CAPS.PacketHeaderV2_SIDSize_set)
    __swig_setmethods__["size"] = _CAPS.PacketHeaderV2_size_set
    __swig_getmethods__["size"] = _CAPS.PacketHeaderV2_size_get
    if _newclass:
        size = _swig_property(_CAPS.PacketHeaderV2_size_get, _CAPS.PacketHeaderV2_size_set)

    def put(self, buf):
        return _CAPS.PacketHeaderV2_put(self, buf)

    def dataSize(self):
        return _CAPS.PacketHeaderV2_dataSize(self)

    def __init__(self):
        this = _CAPS.new_PacketHeaderV2()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_PacketHeaderV2
    __del__ = lambda self: None
PacketHeaderV2_swigregister = _CAPS.PacketHeaderV2_swigregister
PacketHeaderV2_swigregister(PacketHeaderV2)

class ResponseHeader(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ResponseHeader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ResponseHeader, name)
    __repr__ = _swig_repr
    __swig_setmethods__["id"] = _CAPS.ResponseHeader_id_set
    __swig_getmethods__["id"] = _CAPS.ResponseHeader_id_get
    if _newclass:
        id = _swig_property(_CAPS.ResponseHeader_id_get, _CAPS.ResponseHeader_id_set)
    __swig_setmethods__["size"] = _CAPS.ResponseHeader_size_set
    __swig_getmethods__["size"] = _CAPS.ResponseHeader_size_get
    if _newclass:
        size = _swig_property(_CAPS.ResponseHeader_size_get, _CAPS.ResponseHeader_size_set)

    def get(self, buf):
        return _CAPS.ResponseHeader_get(self, buf)

    def __init__(self):
        this = _CAPS.new_ResponseHeader()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_ResponseHeader
    __del__ = lambda self: None
ResponseHeader_swigregister = _CAPS.ResponseHeader_swigregister
ResponseHeader_swigregister(ResponseHeader)

class DataRecord(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataRecord, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DataRecord, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    RS_Error = _CAPS.DataRecord_RS_Error
    RS_Complete = _CAPS.DataRecord_RS_Complete
    RS_Partial = _CAPS.DataRecord_RS_Partial
    RS_BeforeTimeWindow = _CAPS.DataRecord_RS_BeforeTimeWindow
    RS_AfterTimeWindow = _CAPS.DataRecord_RS_AfterTimeWindow
    RS_Max = _CAPS.DataRecord_RS_Max
    __swig_destroy__ = _CAPS.delete_DataRecord
    __del__ = lambda self: None

    def formatName(self):
        return _CAPS.DataRecord_formatName(self)

    def readMetaData(self, buf, size, header, startTime, endTime):
        return _CAPS.DataRecord_readMetaData(self, buf, size, header, startTime, endTime)

    def canTrim(self):
        return _CAPS.DataRecord_canTrim(self)

    def canMerge(self):
        return _CAPS.DataRecord_canMerge(self)

    def trim(self, start, end):
        return _CAPS.DataRecord_trim(self, start, end)

    def dataSize(self, withHeader=True):
        return _CAPS.DataRecord_dataSize(self, withHeader)

    def get(self, *args):
        return _CAPS.DataRecord_get(self, *args)

    def put(self, buf, withHeader=True):
        return _CAPS.DataRecord_put(self, buf, withHeader)

    def header(self):
        return _CAPS.DataRecord_header(self)

    def startTime(self):
        return _CAPS.DataRecord_startTime(self)

    def endTime(self):
        return _CAPS.DataRecord_endTime(self)

    def packetType(self):
        return _CAPS.DataRecord_packetType(self)

    def buffer(self):
        return _CAPS.DataRecord_buffer(self)

    def data(self):
        return _CAPS.DataRecord_data(self)
DataRecord_swigregister = _CAPS.DataRecord_swigregister
DataRecord_swigregister(DataRecord)

class RawPacket(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RawPacket, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RawPacket, name)
    __repr__ = _swig_repr
    __swig_setmethods__["header"] = _CAPS.RawPacket_header_set
    __swig_getmethods__["header"] = _CAPS.RawPacket_header_get
    if _newclass:
        header = _swig_property(_CAPS.RawPacket_header_get, _CAPS.RawPacket_header_set)
    __swig_setmethods__["SID"] = _CAPS.RawPacket_SID_set
    __swig_getmethods__["SID"] = _CAPS.RawPacket_SID_get
    if _newclass:
        SID = _swig_property(_CAPS.RawPacket_SID_get, _CAPS.RawPacket_SID_set)
    __swig_setmethods__["data"] = _CAPS.RawPacket_data_set
    __swig_getmethods__["data"] = _CAPS.RawPacket_data_get
    if _newclass:
        data = _swig_property(_CAPS.RawPacket_data_get, _CAPS.RawPacket_data_set)
    __swig_setmethods__["record"] = _CAPS.RawPacket_record_set
    __swig_getmethods__["record"] = _CAPS.RawPacket_record_get
    if _newclass:
        record = _swig_property(_CAPS.RawPacket_record_get, _CAPS.RawPacket_record_set)

    def __init__(self):
        this = _CAPS.new_RawPacket()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_RawPacket
    __del__ = lambda self: None
RawPacket_swigregister = _CAPS.RawPacket_swigregister
RawPacket_swigregister(RawPacket)

class MetaPacket(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MetaPacket, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MetaPacket, name)
    __repr__ = _swig_repr
    __swig_setmethods__["SID"] = _CAPS.MetaPacket_SID_set
    __swig_getmethods__["SID"] = _CAPS.MetaPacket_SID_get
    if _newclass:
        SID = _swig_property(_CAPS.MetaPacket_SID_get, _CAPS.MetaPacket_SID_set)
    __swig_setmethods__["packetDataHeader"] = _CAPS.MetaPacket_packetDataHeader_set
    __swig_getmethods__["packetDataHeader"] = _CAPS.MetaPacket_packetDataHeader_get
    if _newclass:
        packetDataHeader = _swig_property(_CAPS.MetaPacket_packetDataHeader_get, _CAPS.MetaPacket_packetDataHeader_set)
    __swig_setmethods__["record"] = _CAPS.MetaPacket_record_set
    __swig_getmethods__["record"] = _CAPS.MetaPacket_record_get
    if _newclass:
        record = _swig_property(_CAPS.MetaPacket_record_get, _CAPS.MetaPacket_record_set)
    __swig_setmethods__["recordHeader"] = _CAPS.MetaPacket_recordHeader_set
    __swig_getmethods__["recordHeader"] = _CAPS.MetaPacket_recordHeader_get
    if _newclass:
        recordHeader = _swig_property(_CAPS.MetaPacket_recordHeader_get, _CAPS.MetaPacket_recordHeader_set)
    __swig_setmethods__["startTime"] = _CAPS.MetaPacket_startTime_set
    __swig_getmethods__["startTime"] = _CAPS.MetaPacket_startTime_get
    if _newclass:
        startTime = _swig_property(_CAPS.MetaPacket_startTime_get, _CAPS.MetaPacket_startTime_set)
    __swig_setmethods__["endTime"] = _CAPS.MetaPacket_endTime_set
    __swig_getmethods__["endTime"] = _CAPS.MetaPacket_endTime_get
    if _newclass:
        endTime = _swig_property(_CAPS.MetaPacket_endTime_get, _CAPS.MetaPacket_endTime_set)
    __swig_setmethods__["timestamp"] = _CAPS.MetaPacket_timestamp_set
    __swig_getmethods__["timestamp"] = _CAPS.MetaPacket_timestamp_get
    if _newclass:
        timestamp = _swig_property(_CAPS.MetaPacket_timestamp_get, _CAPS.MetaPacket_timestamp_set)

    def __init__(self):
        this = _CAPS.new_MetaPacket()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_MetaPacket
    __del__ = lambda self: None
MetaPacket_swigregister = _CAPS.MetaPacket_swigregister
MetaPacket_swigregister(MetaPacket)

class Packet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Packet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Packet, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CAPS.new_Packet(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        return _CAPS.Packet_clone(self)
    __swig_setmethods__["buffer"] = _CAPS.Packet_buffer_set
    __swig_getmethods__["buffer"] = _CAPS.Packet_buffer_get
    if _newclass:
        buffer = _swig_property(_CAPS.Packet_buffer_get, _CAPS.Packet_buffer_set)
    __swig_setmethods__["record"] = _CAPS.Packet_record_set
    __swig_getmethods__["record"] = _CAPS.Packet_record_get
    if _newclass:
        record = _swig_property(_CAPS.Packet_record_get, _CAPS.Packet_record_set)
    __swig_setmethods__["networkCode"] = _CAPS.Packet_networkCode_set
    __swig_getmethods__["networkCode"] = _CAPS.Packet_networkCode_get
    if _newclass:
        networkCode = _swig_property(_CAPS.Packet_networkCode_get, _CAPS.Packet_networkCode_set)
    __swig_setmethods__["stationCode"] = _CAPS.Packet_stationCode_set
    __swig_getmethods__["stationCode"] = _CAPS.Packet_stationCode_get
    if _newclass:
        stationCode = _swig_property(_CAPS.Packet_stationCode_get, _CAPS.Packet_stationCode_set)
    __swig_setmethods__["locationCode"] = _CAPS.Packet_locationCode_set
    __swig_getmethods__["locationCode"] = _CAPS.Packet_locationCode_get
    if _newclass:
        locationCode = _swig_property(_CAPS.Packet_locationCode_get, _CAPS.Packet_locationCode_set)
    __swig_setmethods__["channelCode"] = _CAPS.Packet_channelCode_set
    __swig_getmethods__["channelCode"] = _CAPS.Packet_channelCode_get
    if _newclass:
        channelCode = _swig_property(_CAPS.Packet_channelCode_get, _CAPS.Packet_channelCode_set)
    __swig_setmethods__["streamID"] = _CAPS.Packet_streamID_set
    __swig_getmethods__["streamID"] = _CAPS.Packet_streamID_get
    if _newclass:
        streamID = _swig_property(_CAPS.Packet_streamID_get, _CAPS.Packet_streamID_set)
    __swig_setmethods__["dataType"] = _CAPS.Packet_dataType_set
    __swig_getmethods__["dataType"] = _CAPS.Packet_dataType_get
    if _newclass:
        dataType = _swig_property(_CAPS.Packet_dataType_get, _CAPS.Packet_dataType_set)
    __swig_setmethods__["dt_us"] = _CAPS.Packet_dt_us_set
    __swig_getmethods__["dt_us"] = _CAPS.Packet_dt_us_get
    if _newclass:
        dt_us = _swig_property(_CAPS.Packet_dt_us_get, _CAPS.Packet_dt_us_set)
    __swig_setmethods__["uom"] = _CAPS.Packet_uom_set
    __swig_getmethods__["uom"] = _CAPS.Packet_uom_get
    if _newclass:
        uom = _swig_property(_CAPS.Packet_uom_get, _CAPS.Packet_uom_set)
    __swig_setmethods__["timingQuality"] = _CAPS.Packet_timingQuality_set
    __swig_getmethods__["timingQuality"] = _CAPS.Packet_timingQuality_get
    if _newclass:
        timingQuality = _swig_property(_CAPS.Packet_timingQuality_get, _CAPS.Packet_timingQuality_set)

    def size(self):
        return _CAPS.Packet_size(self)
    __swig_destroy__ = _CAPS.delete_Packet
    __del__ = lambda self: None
Packet_swigregister = _CAPS.Packet_swigregister
Packet_swigregister(Packet)

class AnyDataRecord(DataRecord):
    __swig_setmethods__ = {}
    for _s in [DataRecord]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AnyDataRecord, name, value)
    __swig_getmethods__ = {}
    for _s in [DataRecord]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, AnyDataRecord, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _CAPS.new_AnyDataRecord()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setType(self, type):
        return _CAPS.AnyDataRecord_setType(self, type)

    def type(self):
        return _CAPS.AnyDataRecord_type(self)

    def formatName(self):
        return _CAPS.AnyDataRecord_formatName(self)

    def readMetaData(self, buf, size, header, startTime, endTime):
        return _CAPS.AnyDataRecord_readMetaData(self, buf, size, header, startTime, endTime)

    def header(self):
        return _CAPS.AnyDataRecord_header(self)

    def startTime(self):
        return _CAPS.AnyDataRecord_startTime(self)

    def endTime(self):
        return _CAPS.AnyDataRecord_endTime(self)

    def canTrim(self):
        return _CAPS.AnyDataRecord_canTrim(self)

    def canMerge(self):
        return _CAPS.AnyDataRecord_canMerge(self)

    def trim(self, start, end):
        return _CAPS.AnyDataRecord_trim(self, start, end)

    def dataSize(self, withHeader):
        return _CAPS.AnyDataRecord_dataSize(self, withHeader)

    def get(self, *args):
        return _CAPS.AnyDataRecord_get(self, *args)

    def put(self, buf, withHeader):
        return _CAPS.AnyDataRecord_put(self, buf, withHeader)

    def packetType(self):
        return _CAPS.AnyDataRecord_packetType(self)

    def setStartTime(self, time):
        return _CAPS.AnyDataRecord_setStartTime(self, time)

    def setEndTime(self, time):
        return _CAPS.AnyDataRecord_setEndTime(self, time)

    def setSamplingFrequency(self, numerator, denominator):
        return _CAPS.AnyDataRecord_setSamplingFrequency(self, numerator, denominator)

    def data(self):
        return _CAPS.AnyDataRecord_data(self)

    def setData(self, data, size):
        return _CAPS.AnyDataRecord_setData(self, data, size)
    __swig_destroy__ = _CAPS.delete_AnyDataRecord
    __del__ = lambda self: None
AnyDataRecord_swigregister = _CAPS.AnyDataRecord_swigregister
AnyDataRecord_swigregister(AnyDataRecord)

LL_UNDEFINED = _CAPS.LL_UNDEFINED
LL_ERROR = _CAPS.LL_ERROR
LL_WARNING = _CAPS.LL_WARNING
LL_NOTICE = _CAPS.LL_NOTICE
LL_INFO = _CAPS.LL_INFO
LL_DEBUG = _CAPS.LL_DEBUG
LL_QUANTITY = _CAPS.LL_QUANTITY

def SetLogHandler(arg1, arg2):
    return _CAPS.SetLogHandler(arg1, arg2)
SetLogHandler = _CAPS.SetLogHandler
class SPClock(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SPClock, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SPClock, name)
    __repr__ = _swig_repr
    __swig_getmethods__["freqn"] = _CAPS.SPClock_freqn_get
    if _newclass:
        freqn = _swig_property(_CAPS.SPClock_freqn_get)
    __swig_getmethods__["freqd"] = _CAPS.SPClock_freqd_get
    if _newclass:
        freqd = _swig_property(_CAPS.SPClock_freqd_get)

    def __init__(self, freqn_init, freqd_init):
        this = _CAPS.new_SPClock(freqn_init, freqd_init)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def sync_time(self, time):
        return _CAPS.SPClock_sync_time(self, time)

    def tick(self):
        return _CAPS.SPClock_tick(self)

    def get_time(self, tick_diff):
        return _CAPS.SPClock_get_time(self, tick_diff)

    def correction(self):
        return _CAPS.SPClock_correction(self)
    __swig_destroy__ = _CAPS.delete_SPClock
    __del__ = lambda self: None
SPClock_swigregister = _CAPS.SPClock_swigregister
SPClock_swigregister(SPClock)

class Encoder(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Encoder, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Encoder, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CAPS.delete_Encoder
    __del__ = lambda self: None

    def push(self, sample):
        return _CAPS.Encoder_push(self, sample)

    def flush(self):
        return _CAPS.Encoder_flush(self)

    def reset(self):
        return _CAPS.Encoder_reset(self)

    def type(self):
        return _CAPS.Encoder_type(self)

    def clk(self):
        return _CAPS.Encoder_clk(self)

    def setStartTime(self, time):
        return _CAPS.Encoder_setStartTime(self, time)

    def currentTime(self):
        return _CAPS.Encoder_currentTime(self)

    def timingQuality(self):
        return _CAPS.Encoder_timingQuality(self)

    def setTimingQuality(self, quality):
        return _CAPS.Encoder_setTimingQuality(self, quality)

    def pop(self):
        return _CAPS.Encoder_pop(self)
Encoder_swigregister = _CAPS.Encoder_swigregister
Encoder_swigregister(Encoder)

class EncoderFactory(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EncoderFactory, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EncoderFactory, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CAPS.delete_EncoderFactory
    __del__ = lambda self: None

    def create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator):
        return _CAPS.EncoderFactory_create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator)

    def supportsRecord(self, rec):
        return _CAPS.EncoderFactory_supportsRecord(self, rec)

    def errorString(self):
        return _CAPS.EncoderFactory_errorString(self)
EncoderFactory_swigregister = _CAPS.EncoderFactory_swigregister
EncoderFactory_swigregister(EncoderFactory)

class MSEEDEncoderFactory(EncoderFactory):
    __swig_setmethods__ = {}
    for _s in [EncoderFactory]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MSEEDEncoderFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [EncoderFactory]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MSEEDEncoderFactory, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def setRecordLength(self, recordLength):
        return _CAPS.MSEEDEncoderFactory_setRecordLength(self, recordLength)
    __swig_destroy__ = _CAPS.delete_MSEEDEncoderFactory
    __del__ = lambda self: None
MSEEDEncoderFactory_swigregister = _CAPS.MSEEDEncoderFactory_swigregister
MSEEDEncoderFactory_swigregister(MSEEDEncoderFactory)

class SteimEncoderFactory(MSEEDEncoderFactory):
    __swig_setmethods__ = {}
    for _s in [MSEEDEncoderFactory]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SteimEncoderFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [MSEEDEncoderFactory]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SteimEncoderFactory, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def supportsRecord(self, rec):
        return _CAPS.SteimEncoderFactory_supportsRecord(self, rec)
    __swig_destroy__ = _CAPS.delete_SteimEncoderFactory
    __del__ = lambda self: None
SteimEncoderFactory_swigregister = _CAPS.SteimEncoderFactory_swigregister
SteimEncoderFactory_swigregister(SteimEncoderFactory)

class IdentityEncoderFactory(MSEEDEncoderFactory):
    __swig_setmethods__ = {}
    for _s in [MSEEDEncoderFactory]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IdentityEncoderFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [MSEEDEncoderFactory]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, IdentityEncoderFactory, name)
    __repr__ = _swig_repr

    def create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator):
        return _CAPS.IdentityEncoderFactory_create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator)

    def supportsRecord(self, rec):
        return _CAPS.IdentityEncoderFactory_supportsRecord(self, rec)

    def __init__(self):
        this = _CAPS.new_IdentityEncoderFactory()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_IdentityEncoderFactory
    __del__ = lambda self: None
IdentityEncoderFactory_swigregister = _CAPS.IdentityEncoderFactory_swigregister
IdentityEncoderFactory_swigregister(IdentityEncoderFactory)

class Steim1EncoderFactory(SteimEncoderFactory):
    __swig_setmethods__ = {}
    for _s in [SteimEncoderFactory]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Steim1EncoderFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [SteimEncoderFactory]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Steim1EncoderFactory, name)
    __repr__ = _swig_repr

    def create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator):
        return _CAPS.Steim1EncoderFactory_create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator)

    def __init__(self):
        this = _CAPS.new_Steim1EncoderFactory()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_Steim1EncoderFactory
    __del__ = lambda self: None
Steim1EncoderFactory_swigregister = _CAPS.Steim1EncoderFactory_swigregister
Steim1EncoderFactory_swigregister(Steim1EncoderFactory)

class Steim2EncoderFactory(SteimEncoderFactory):
    __swig_setmethods__ = {}
    for _s in [SteimEncoderFactory]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Steim2EncoderFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [SteimEncoderFactory]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Steim2EncoderFactory, name)
    __repr__ = _swig_repr

    def create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator):
        return _CAPS.Steim2EncoderFactory_create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator)

    def __init__(self):
        this = _CAPS.new_Steim2EncoderFactory()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_Steim2EncoderFactory
    __del__ = lambda self: None
Steim2EncoderFactory_swigregister = _CAPS.Steim2EncoderFactory_swigregister
Steim2EncoderFactory_swigregister(Steim2EncoderFactory)

class MSEEDDataRecord(DataRecord):
    __swig_setmethods__ = {}
    for _s in [DataRecord]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MSEEDDataRecord, name, value)
    __swig_getmethods__ = {}
    for _s in [DataRecord]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MSEEDDataRecord, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def formatName(self):
        return _CAPS.MSEEDDataRecord_formatName(self)

    def readMetaData(self, buf, size, header, startTime, endTime):
        return _CAPS.MSEEDDataRecord_readMetaData(self, buf, size, header, startTime, endTime)

    def header(self):
        return _CAPS.MSEEDDataRecord_header(self)

    def startTime(self):
        return _CAPS.MSEEDDataRecord_startTime(self)

    def endTime(self):
        return _CAPS.MSEEDDataRecord_endTime(self)

    def canTrim(self):
        return _CAPS.MSEEDDataRecord_canTrim(self)

    def canMerge(self):
        return _CAPS.MSEEDDataRecord_canMerge(self)

    def trim(self, start, end):
        return _CAPS.MSEEDDataRecord_trim(self, start, end)

    def dataSize(self, withHeader):
        return _CAPS.MSEEDDataRecord_dataSize(self, withHeader)

    def get(self, *args):
        return _CAPS.MSEEDDataRecord_get(self, *args)

    def put(self, buf, withHeader):
        return _CAPS.MSEEDDataRecord_put(self, buf, withHeader)

    def packetType(self):
        return _CAPS.MSEEDDataRecord_packetType(self)

    def setData(self, data, size):
        return _CAPS.MSEEDDataRecord_setData(self, data, size)

    def unpackHeader(self):
        return _CAPS.MSEEDDataRecord_unpackHeader(self)
    __swig_destroy__ = _CAPS.delete_MSEEDDataRecord
    __del__ = lambda self: None
MSEEDDataRecord_swigregister = _CAPS.MSEEDDataRecord_swigregister
MSEEDDataRecord_swigregister(MSEEDDataRecord)

class Plugin(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Plugin, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Plugin, name)
    __repr__ = _swig_repr
    Success = _CAPS.Plugin_Success
    PacketSize = _CAPS.Plugin_PacketSize
    PacketLoss = _CAPS.Plugin_PacketLoss
    PacketNotValid = _CAPS.Plugin_PacketNotValid
    PacketNotSupported = _CAPS.Plugin_PacketNotSupported
    MaxFutureEndTimeExceeded = _CAPS.Plugin_MaxFutureEndTimeExceeded

    def __init__(self, *args):
        this = _CAPS.new_Plugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_Plugin
    __del__ = lambda self: None

    def close(self):
        return _CAPS.Plugin_close(self)

    def quit(self):
        return _CAPS.Plugin_quit(self)

    def enableLogging(self):
        return _CAPS.Plugin_enableLogging(self)

    def setBackfillingBufferSize(self, secs):
        return _CAPS.Plugin_setBackfillingBufferSize(self, secs)

    def backfillingBufferSize(self):
        return _CAPS.Plugin_backfillingBufferSize(self)

    def isExitRequested(self):
        return _CAPS.Plugin_isExitRequested(self)

    def stats(self):
        return _CAPS.Plugin_stats(self)

    def resetMaxBytesBuffered(self):
        return _CAPS.Plugin_resetMaxBytesBuffered(self)

    def setEncoderFactory(self, factory):
        return _CAPS.Plugin_setEncoderFactory(self, factory)

    def setHost(self, host):
        return _CAPS.Plugin_setHost(self, host)

    def host(self):
        return _CAPS.Plugin_host(self)

    def setPort(self, port):
        return _CAPS.Plugin_setPort(self, port)

    def port(self):
        return _CAPS.Plugin_port(self)

    def setBufferSize(self, bufferSize):
        return _CAPS.Plugin_setBufferSize(self, bufferSize)

    def bufferSize(self):
        return _CAPS.Plugin_bufferSize(self)

    def setSSLEnabled(self, enable):
        return _CAPS.Plugin_setSSLEnabled(self, enable)

    def setCredentials(self, user, password):
        return _CAPS.Plugin_setCredentials(self, user, password)

    def setMaxFutureEndTime(self, span):
        return _CAPS.Plugin_setMaxFutureEndTime(self, span)

    def setPacketAckFunc(self, func):
        return _CAPS.Plugin_setPacketAckFunc(self, func)

    def setSendTimeout(self, timeout):
        return _CAPS.Plugin_setSendTimeout(self, timeout)

    def setTimeouts(self, *args):
        return _CAPS.Plugin_setTimeouts(self, *args)

    def readJournal(self):
        return _CAPS.Plugin_readJournal(self)

    def setJournal(self, filename):
        return _CAPS.Plugin_setJournal(self, filename)

    def setFlushInterval(self, interval):
        return _CAPS.Plugin_setFlushInterval(self, interval)

    def streamStates(self):
        return _CAPS.Plugin_streamStates(self)

    def writeJournal(self, *args):
        return _CAPS.Plugin_writeJournal(self, *args)

    def version(self):
        return _CAPS.Plugin_version(self)

    def push(self, *args):
        return _CAPS.Plugin_push(self, *args)
Plugin_swigregister = _CAPS.Plugin_swigregister
Plugin_swigregister(Plugin)

class RawResponseHeader(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RawResponseHeader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RawResponseHeader, name)
    __repr__ = _swig_repr
    __swig_setmethods__["timeSeconds"] = _CAPS.RawResponseHeader_timeSeconds_set
    __swig_getmethods__["timeSeconds"] = _CAPS.RawResponseHeader_timeSeconds_get
    if _newclass:
        timeSeconds = _swig_property(_CAPS.RawResponseHeader_timeSeconds_get, _CAPS.RawResponseHeader_timeSeconds_set)
    __swig_setmethods__["timeMicroSeconds"] = _CAPS.RawResponseHeader_timeMicroSeconds_set
    __swig_getmethods__["timeMicroSeconds"] = _CAPS.RawResponseHeader_timeMicroSeconds_get
    if _newclass:
        timeMicroSeconds = _swig_property(_CAPS.RawResponseHeader_timeMicroSeconds_get, _CAPS.RawResponseHeader_timeMicroSeconds_set)

    def get(self, buf):
        return _CAPS.RawResponseHeader_get(self, buf)

    def dataSize(self):
        return _CAPS.RawResponseHeader_dataSize(self)

    def __init__(self):
        this = _CAPS.new_RawResponseHeader()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_RawResponseHeader
    __del__ = lambda self: None
RawResponseHeader_swigregister = _CAPS.RawResponseHeader_swigregister
RawResponseHeader_swigregister(RawResponseHeader)

class RawDataRecord(DataRecord):
    __swig_setmethods__ = {}
    for _s in [DataRecord]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RawDataRecord, name, value)
    __swig_getmethods__ = {}
    for _s in [DataRecord]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RawDataRecord, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def formatName(self):
        return _CAPS.RawDataRecord_formatName(self)

    def readMetaData(self, buf, size, header, startTime, endTime):
        return _CAPS.RawDataRecord_readMetaData(self, buf, size, header, startTime, endTime)

    def setHeader(self, header):
        return _CAPS.RawDataRecord_setHeader(self, header)

    def header(self):
        return _CAPS.RawDataRecord_header(self)

    def startTime(self):
        return _CAPS.RawDataRecord_startTime(self)

    def endTime(self):
        return _CAPS.RawDataRecord_endTime(self)

    def canTrim(self):
        return _CAPS.RawDataRecord_canTrim(self)

    def canMerge(self):
        return _CAPS.RawDataRecord_canMerge(self)

    def trim(self, start, end):
        return _CAPS.RawDataRecord_trim(self, start, end)

    def dataSize(self, withHeader):
        return _CAPS.RawDataRecord_dataSize(self, withHeader)

    def get(self, *args):
        return _CAPS.RawDataRecord_get(self, *args)

    def getData(self, *args):
        return _CAPS.RawDataRecord_getData(self, *args)

    def put(self, buf, withHeader):
        return _CAPS.RawDataRecord_put(self, buf, withHeader)

    def packetType(self):
        return _CAPS.RawDataRecord_packetType(self)

    def setStartTime(self, time):
        return _CAPS.RawDataRecord_setStartTime(self, time)

    def setSamplingFrequency(self, numerator, denominator):
        return _CAPS.RawDataRecord_setSamplingFrequency(self, numerator, denominator)

    def setDataType(self, dt):
        return _CAPS.RawDataRecord_setDataType(self, dt)

    def setBuffer(self, data, size):
        return _CAPS.RawDataRecord_setBuffer(self, data, size)
    __swig_destroy__ = _CAPS.delete_RawDataRecord
    __del__ = lambda self: None
RawDataRecord_swigregister = _CAPS.RawDataRecord_swigregister
RawDataRecord_swigregister(RawDataRecord)

class FixedRawDataRecord(RawDataRecord):
    __swig_setmethods__ = {}
    for _s in [RawDataRecord]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FixedRawDataRecord, name, value)
    __swig_getmethods__ = {}
    for _s in [RawDataRecord]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FixedRawDataRecord, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def canTrim(self):
        return _CAPS.FixedRawDataRecord_canTrim(self)

    def canMerge(self):
        return _CAPS.FixedRawDataRecord_canMerge(self)

    def trim(self, start, end):
        return _CAPS.FixedRawDataRecord_trim(self, start, end)

    def formatName(self):
        return _CAPS.FixedRawDataRecord_formatName(self)

    def get(self, buf, size, arg4, arg5, maxBytes):
        return _CAPS.FixedRawDataRecord_get(self, buf, size, arg4, arg5, maxBytes)

    def packetType(self):
        return _CAPS.FixedRawDataRecord_packetType(self)
    __swig_destroy__ = _CAPS.delete_FixedRawDataRecord
    __del__ = lambda self: None
FixedRawDataRecord_swigregister = _CAPS.FixedRawDataRecord_swigregister
FixedRawDataRecord_swigregister(FixedRawDataRecord)

class ChunkHeader(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChunkHeader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChunkHeader, name)
    __repr__ = _swig_repr
    __swig_setmethods__["chunkSize"] = _CAPS.ChunkHeader_chunkSize_set
    __swig_getmethods__["chunkSize"] = _CAPS.ChunkHeader_chunkSize_get
    if _newclass:
        chunkSize = _swig_property(_CAPS.ChunkHeader_chunkSize_get, _CAPS.ChunkHeader_chunkSize_set)

    def setChunkType(self, type):
        return _CAPS.ChunkHeader_setChunkType(self, type)

    def isChunkType(self, type):
        return _CAPS.ChunkHeader_isChunkType(self, type)

    def validChunkType(self):
        return _CAPS.ChunkHeader_validChunkType(self)

    def dataSize(self):
        return _CAPS.ChunkHeader_dataSize(self)

    def read(self, input):
        return _CAPS.ChunkHeader_read(self, input)

    def write(self, output):
        return _CAPS.ChunkHeader_write(self, output)

    def get(self, input):
        return _CAPS.ChunkHeader_get(self, input)

    def put(self, output):
        return _CAPS.ChunkHeader_put(self, output)

    def __init__(self):
        this = _CAPS.new_ChunkHeader()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_ChunkHeader
    __del__ = lambda self: None
ChunkHeader_swigregister = _CAPS.ChunkHeader_swigregister
ChunkHeader_swigregister(ChunkHeader)

class ChunkIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChunkIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChunkIterator, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CAPS.new_ChunkIterator(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def begin(self, *args):
        return _CAPS.ChunkIterator_begin(self, *args)

    def next(self):
        return _CAPS.ChunkIterator_next(self)

    def header(self):
        return _CAPS.ChunkIterator_header(self)

    def headerPos(self):
        return _CAPS.ChunkIterator_headerPos(self)

    def contentPos(self):
        return _CAPS.ChunkIterator_contentPos(self)

    def istream(self):
        return _CAPS.ChunkIterator_istream(self)
    __swig_destroy__ = _CAPS.delete_ChunkIterator
    __del__ = lambda self: None
ChunkIterator_swigregister = _CAPS.ChunkIterator_swigregister
ChunkIterator_swigregister(ChunkIterator)
ChunkHeaderSize = cvar.ChunkHeaderSize

class Chunk(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Chunk, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Chunk, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CAPS.delete_Chunk
    __del__ = lambda self: None

    def read(self, input, size):
        return _CAPS.Chunk_read(self, input, size)

    def write(self, output):
        return _CAPS.Chunk_write(self, output)

    def get(self, input, size):
        return _CAPS.Chunk_get(self, input, size)

    def put(self, output):
        return _CAPS.Chunk_put(self, output)

    def chunkSize(self):
        return _CAPS.Chunk_chunkSize(self)
Chunk_swigregister = _CAPS.Chunk_swigregister
Chunk_swigregister(Chunk)

class HeadChunk(Chunk):
    __swig_setmethods__ = {}
    for _s in [Chunk]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HeadChunk, name, value)
    __swig_getmethods__ = {}
    for _s in [Chunk]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HeadChunk, name)
    __repr__ = _swig_repr
    __swig_setmethods__["data"] = _CAPS.HeadChunk_data_set
    __swig_getmethods__["data"] = _CAPS.HeadChunk_data_get
    if _newclass:
        data = _swig_property(_CAPS.HeadChunk_data_get, _CAPS.HeadChunk_data_set)

    def chunkSize(self):
        return _CAPS.HeadChunk_chunkSize(self)

    def get(self, input, size):
        return _CAPS.HeadChunk_get(self, input, size)

    def put(self, output):
        return _CAPS.HeadChunk_put(self, output)

    def __init__(self):
        this = _CAPS.new_HeadChunk()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_HeadChunk
    __del__ = lambda self: None
HeadChunk_swigregister = _CAPS.HeadChunk_swigregister
HeadChunk_swigregister(HeadChunk)

class SID(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SID, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SID, name)
    __repr__ = _swig_repr
    __swig_setmethods__["networkCode"] = _CAPS.SID_networkCode_set
    __swig_getmethods__["networkCode"] = _CAPS.SID_networkCode_get
    if _newclass:
        networkCode = _swig_property(_CAPS.SID_networkCode_get, _CAPS.SID_networkCode_set)
    __swig_setmethods__["stationCode"] = _CAPS.SID_stationCode_set
    __swig_getmethods__["stationCode"] = _CAPS.SID_stationCode_get
    if _newclass:
        stationCode = _swig_property(_CAPS.SID_stationCode_get, _CAPS.SID_stationCode_set)
    __swig_setmethods__["locationCode"] = _CAPS.SID_locationCode_set
    __swig_getmethods__["locationCode"] = _CAPS.SID_locationCode_get
    if _newclass:
        locationCode = _swig_property(_CAPS.SID_locationCode_get, _CAPS.SID_locationCode_set)
    __swig_setmethods__["channelCode"] = _CAPS.SID_channelCode_set
    __swig_getmethods__["channelCode"] = _CAPS.SID_channelCode_get
    if _newclass:
        channelCode = _swig_property(_CAPS.SID_channelCode_get, _CAPS.SID_channelCode_set)

    def __eq__(self, other):
        return _CAPS.SID___eq__(self, other)

    def __ne__(self, other):
        return _CAPS.SID___ne__(self, other)

    def toString(self):
        return _CAPS.SID_toString(self)

    def __init__(self):
        this = _CAPS.new_SID()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_SID
    __del__ = lambda self: None
SID_swigregister = _CAPS.SID_swigregister
SID_swigregister(SID)

class SIDChunk(Chunk, SID):
    __swig_setmethods__ = {}
    for _s in [Chunk, SID]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SIDChunk, name, value)
    __swig_getmethods__ = {}
    for _s in [Chunk, SID]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SIDChunk, name)
    __repr__ = _swig_repr

    def chunkSize(self):
        return _CAPS.SIDChunk_chunkSize(self)

    def get(self, input, size):
        return _CAPS.SIDChunk_get(self, input, size)

    def put(self, output):
        return _CAPS.SIDChunk_put(self, output)

    def __init__(self):
        this = _CAPS.new_SIDChunk()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_SIDChunk
    __del__ = lambda self: None
SIDChunk_swigregister = _CAPS.SIDChunk_swigregister
SIDChunk_swigregister(SIDChunk)

class RTCM2DataRecord(DataRecord):
    __swig_setmethods__ = {}
    for _s in [DataRecord]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RTCM2DataRecord, name, value)
    __swig_getmethods__ = {}
    for _s in [DataRecord]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RTCM2DataRecord, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def formatName(self):
        return _CAPS.RTCM2DataRecord_formatName(self)

    def setTimeStamp(self, ts):
        return _CAPS.RTCM2DataRecord_setTimeStamp(self, ts)

    def setSamplingFrequency(self, numerator, denominator):
        return _CAPS.RTCM2DataRecord_setSamplingFrequency(self, numerator, denominator)

    def readMetaData(self, buf, size, header, startTime, endTime):
        return _CAPS.RTCM2DataRecord_readMetaData(self, buf, size, header, startTime, endTime)

    def header(self):
        return _CAPS.RTCM2DataRecord_header(self)

    def startTime(self):
        return _CAPS.RTCM2DataRecord_startTime(self)

    def endTime(self):
        return _CAPS.RTCM2DataRecord_endTime(self)

    def canTrim(self):
        return _CAPS.RTCM2DataRecord_canTrim(self)

    def canMerge(self):
        return _CAPS.RTCM2DataRecord_canMerge(self)

    def trim(self, start, end):
        return _CAPS.RTCM2DataRecord_trim(self, start, end)

    def dataSize(self, withHeader):
        return _CAPS.RTCM2DataRecord_dataSize(self, withHeader)

    def get(self, buf, size, start, end, maxSize=-1):
        return _CAPS.RTCM2DataRecord_get(self, buf, size, start, end, maxSize)

    def put(self, buf, withHeader):
        return _CAPS.RTCM2DataRecord_put(self, buf, withHeader)

    def packetType(self):
        return _CAPS.RTCM2DataRecord_packetType(self)
    __swig_destroy__ = _CAPS.delete_RTCM2DataRecord
    __del__ = lambda self: None
RTCM2DataRecord_swigregister = _CAPS.RTCM2DataRecord_swigregister
RTCM2DataRecord_swigregister(RTCM2DataRecord)

class Socket(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Socket, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Socket, name)
    __repr__ = _swig_repr
    Success = _CAPS.Socket_Success
    Error = _CAPS.Socket_Error
    AllocationError = _CAPS.Socket_AllocationError
    ReuseAdressError = _CAPS.Socket_ReuseAdressError
    BindError = _CAPS.Socket_BindError
    ListenError = _CAPS.Socket_ListenError
    AcceptError = _CAPS.Socket_AcceptError
    ConnectError = _CAPS.Socket_ConnectError
    AddrInfoError = _CAPS.Socket_AddrInfoError
    Timeout = _CAPS.Socket_Timeout
    InvalidSocket = _CAPS.Socket_InvalidSocket
    InvalidPort = _CAPS.Socket_InvalidPort
    InvalidAddressFamily = _CAPS.Socket_InvalidAddressFamily
    InvalidAddress = _CAPS.Socket_InvalidAddress
    InvalidHostname = _CAPS.Socket_InvalidHostname

    def __init__(self):
        this = _CAPS.new_Socket()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_Socket
    __del__ = lambda self: None
    if _newclass:
        toString = staticmethod(_CAPS.Socket_toString)
    else:
        toString = _CAPS.Socket_toString

    def fd(self):
        return _CAPS.Socket_fd(self)

    def isValid(self):
        return _CAPS.Socket_isValid(self)

    def shutdown(self):
        return _CAPS.Socket_shutdown(self)

    def close(self):
        return _CAPS.Socket_close(self)

    def send(self, data):
        return _CAPS.Socket_send(self, data)

    def write(self, data, len):
        return _CAPS.Socket_write(self, data, len)

    def read(self, data, len):
        return _CAPS.Socket_read(self, data, len)

    def flush(self):
        return _CAPS.Socket_flush(self)

    def setSocketTimeout(self, secs, usecs):
        return _CAPS.Socket_setSocketTimeout(self, secs, usecs)

    def setNonBlocking(self, nb):
        return _CAPS.Socket_setNonBlocking(self, nb)

    def connect(self, hostname, port):
        return _CAPS.Socket_connect(self, hostname, port)

    def rx(self):
        return _CAPS.Socket_rx(self)

    def tx(self):
        return _CAPS.Socket_tx(self)
Socket_swigregister = _CAPS.Socket_swigregister
Socket_swigregister(Socket)

def Socket_toString(arg2):
    return _CAPS.Socket_toString(arg2)
Socket_toString = _CAPS.Socket_toString

class SSLSocket(Socket):
    __swig_setmethods__ = {}
    for _s in [Socket]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SSLSocket, name, value)
    __swig_getmethods__ = {}
    for _s in [Socket]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SSLSocket, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CAPS.new_SSLSocket(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_SSLSocket
    __del__ = lambda self: None

    def write(self, data, len):
        return _CAPS.SSLSocket_write(self, data, len)

    def read(self, data, len):
        return _CAPS.SSLSocket_read(self, data, len)

    def connect(self, hostname, port):
        return _CAPS.SSLSocket_connect(self, hostname, port)

    def sessionID(self):
        return _CAPS.SSLSocket_sessionID(self)

    def sessionIDLength(self):
        return _CAPS.SSLSocket_sessionIDLength(self)

    def peerCertificate(self):
        return _CAPS.SSLSocket_peerCertificate(self)
SSLSocket_swigregister = _CAPS.SSLSocket_swigregister
SSLSocket_swigregister(SSLSocket)

class charArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, charArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, charArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _CAPS.new_charArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CAPS.delete_charArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _CAPS.charArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _CAPS.charArray___setitem__(self, index, value)

    def cast(self):
        return _CAPS.charArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_CAPS.charArray_frompointer)
    else:
        frompointer = _CAPS.charArray_frompointer
charArray_swigregister = _CAPS.charArray_swigregister
charArray_swigregister(charArray)

def charArray_frompointer(t):
    return _CAPS.charArray_frompointer(t)
charArray_frompointer = _CAPS.charArray_frompointer

class arraybuf(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, arraybuf, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, arraybuf, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CAPS.new_arraybuf(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def reset(self, buf, len):
        return _CAPS.arraybuf_reset(self, buf, len)

    def seekoff(self, ofs, dir, mode):
        return _CAPS.arraybuf_seekoff(self, ofs, dir, mode)

    def seekpos(self, pos, mode):
        return _CAPS.arraybuf_seekpos(self, pos, mode)

    def xsgetn(self, s, n):
        return _CAPS.arraybuf_xsgetn(self, s, n)

    def tellg(self):
        return _CAPS.arraybuf_tellg(self)

    def tellp(self):
        return _CAPS.arraybuf_tellp(self)
    __swig_destroy__ = _CAPS.delete_arraybuf
    __del__ = lambda self: None
arraybuf_swigregister = _CAPS.arraybuf_swigregister
arraybuf_swigregister(arraybuf)


def splitAddress(host, port, address, default_port):
    return _CAPS.splitAddress(host, port, address, default_port)
splitAddress = _CAPS.splitAddress

def tokenize(str, delim, len_source, len_tok):
    return _CAPS.tokenize(str, delim, len_source, len_tok)
tokenize = _CAPS.tokenize

def trim(*args):
    return _CAPS.trim(*args)
trim = _CAPS.trim

def timeToTimestamp(ts, t):
    return _CAPS.timeToTimestamp(ts, t)
timeToTimestamp = _CAPS.timeToTimestamp

def str2int(*args):
    return _CAPS.str2int(*args)
str2int = _CAPS.str2int

def timestampToTime(ts):
    return _CAPS.timestampToTime(ts)
timestampToTime = _CAPS.timestampToTime

def samplesToTimeSpan(head, sampleCount):
    return _CAPS.samplesToTimeSpan(head, sampleCount)
samplesToTimeSpan = _CAPS.samplesToTimeSpan

def timeSpanToSamples(head, span):
    return _CAPS.timeSpanToSamples(head, span)
timeSpanToSamples = _CAPS.timeSpanToSamples

def timeSpanToSamplesCeil(head, span):
    return _CAPS.timeSpanToSamplesCeil(head, span)
timeSpanToSamplesCeil = _CAPS.timeSpanToSamplesCeil

def timeSpanToSamplesFloor(head, span):
    return _CAPS.timeSpanToSamplesFloor(head, span)
timeSpanToSamplesFloor = _CAPS.timeSpanToSamplesFloor

def dataTypeSize(dt):
    return _CAPS.dataTypeSize(dt)
dataTypeSize = _CAPS.dataTypeSize
# This file is compatible with both classic and new-style classes.