You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1929 lines
69 KiB
Python
1929 lines
69 KiB
Python
# 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.
|
|
|
|
|