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.
1435 lines
47 KiB
Python
1435 lines
47 KiB
Python
# This file was automatically generated by SWIG (http://www.swig.org).
|
|
# Version 4.0.2
|
|
#
|
|
# 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):
|
|
raise RuntimeError("Python 2.7 or later required")
|
|
|
|
# Import the low-level C/C++ module
|
|
if __package__ or "." in __name__:
|
|
from . import _CAPS
|
|
else:
|
|
import _CAPS
|
|
|
|
try:
|
|
import builtins as __builtin__
|
|
except ImportError:
|
|
import __builtin__
|
|
|
|
def _swig_repr(self):
|
|
try:
|
|
strthis = "proxy of " + self.this.__repr__()
|
|
except __builtin__.Exception:
|
|
strthis = ""
|
|
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
|
|
|
|
|
|
def _swig_setattr_nondynamic_instance_variable(set):
|
|
def set_instance_attr(self, name, value):
|
|
if name == "thisown":
|
|
self.this.own(value)
|
|
elif name == "this":
|
|
set(self, name, value)
|
|
elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
|
|
set(self, name, value)
|
|
else:
|
|
raise AttributeError("You cannot add instance attributes to %s" % self)
|
|
return set_instance_attr
|
|
|
|
|
|
def _swig_setattr_nondynamic_class_variable(set):
|
|
def set_class_attr(cls, name, value):
|
|
if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
|
|
set(cls, name, value)
|
|
else:
|
|
raise AttributeError("You cannot add class attributes to %s" % cls)
|
|
return set_class_attr
|
|
|
|
|
|
def _swig_add_metaclass(metaclass):
|
|
"""Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
|
|
def wrapper(cls):
|
|
return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
|
|
return wrapper
|
|
|
|
|
|
class _SwigNonDynamicMeta(type):
|
|
"""Meta class to enforce nondynamic attributes (no new attributes) for a class"""
|
|
__setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
|
|
|
|
|
|
class TimeSpan(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
_CAPS.TimeSpan_swiginit(self, _CAPS.new_TimeSpan(*args))
|
|
|
|
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
|
|
|
|
# Register TimeSpan in _CAPS:
|
|
_CAPS.TimeSpan_swigregister(TimeSpan)
|
|
|
|
class Time(TimeSpan):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
_CAPS.Time_swiginit(self, _CAPS.new_Time(*args))
|
|
|
|
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)
|
|
|
|
@staticmethod
|
|
def LocalTime():
|
|
return _CAPS.Time_LocalTime()
|
|
|
|
@staticmethod
|
|
def GMT():
|
|
return _CAPS.Time_GMT()
|
|
|
|
@staticmethod
|
|
def FromYearDay(year, year_day):
|
|
return _CAPS.Time_FromYearDay(year, year_day)
|
|
|
|
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)
|
|
|
|
@staticmethod
|
|
def FromString(str, fmt):
|
|
return _CAPS.Time_FromString(str, fmt)
|
|
__swig_destroy__ = _CAPS.delete_Time
|
|
|
|
# Register Time in _CAPS:
|
|
_CAPS.Time_swigregister(Time)
|
|
cvar = _CAPS.cvar
|
|
Time.Null = _CAPS.cvar.Time_Null
|
|
|
|
def Time_LocalTime():
|
|
return _CAPS.Time_LocalTime()
|
|
|
|
def Time_GMT():
|
|
return _CAPS.Time_GMT()
|
|
|
|
def Time_FromYearDay(year, year_day):
|
|
return _CAPS.Time_FromYearDay(year, year_day)
|
|
|
|
def Time_FromString(str, fmt):
|
|
return _CAPS.Time_FromString(str, fmt)
|
|
|
|
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):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
str = property(_CAPS.UOM_str_get, _CAPS.UOM_str_set)
|
|
ID = property(_CAPS.UOM_ID_get, _CAPS.UOM_ID_set)
|
|
|
|
def __init__(self):
|
|
_CAPS.UOM_swiginit(self, _CAPS.new_UOM())
|
|
__swig_destroy__ = _CAPS.delete_UOM
|
|
|
|
# Register UOM in _CAPS:
|
|
_CAPS.UOM_swigregister(UOM)
|
|
|
|
class Quality(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
str = property(_CAPS.Quality_str_get, _CAPS.Quality_str_set)
|
|
ID = property(_CAPS.Quality_ID_get, _CAPS.Quality_ID_set)
|
|
|
|
def __init__(self):
|
|
_CAPS.Quality_swiginit(self, _CAPS.new_Quality())
|
|
__swig_destroy__ = _CAPS.delete_Quality
|
|
|
|
# Register Quality in _CAPS:
|
|
_CAPS.Quality_swigregister(Quality)
|
|
|
|
class TimeStamp(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
year = property(_CAPS.TimeStamp_year_get, _CAPS.TimeStamp_year_set)
|
|
yday = property(_CAPS.TimeStamp_yday_get, _CAPS.TimeStamp_yday_set)
|
|
hour = property(_CAPS.TimeStamp_hour_get, _CAPS.TimeStamp_hour_set)
|
|
minute = property(_CAPS.TimeStamp_minute_get, _CAPS.TimeStamp_minute_set)
|
|
second = property(_CAPS.TimeStamp_second_get, _CAPS.TimeStamp_second_set)
|
|
unused = property(_CAPS.TimeStamp_unused_get, _CAPS.TimeStamp_unused_set)
|
|
usec = property(_CAPS.TimeStamp_usec_get, _CAPS.TimeStamp_usec_set)
|
|
|
|
def __init__(self):
|
|
_CAPS.TimeStamp_swiginit(self, _CAPS.new_TimeStamp())
|
|
__swig_destroy__ = _CAPS.delete_TimeStamp
|
|
|
|
# Register TimeStamp in _CAPS:
|
|
_CAPS.TimeStamp_swigregister(TimeStamp)
|
|
|
|
class PacketDataHeader(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
_CAPS.PacketDataHeader_swiginit(self, _CAPS.new_PacketDataHeader(*args))
|
|
version = property(_CAPS.PacketDataHeader_version_get, _CAPS.PacketDataHeader_version_set)
|
|
packetType = property(_CAPS.PacketDataHeader_packetType_get, _CAPS.PacketDataHeader_packetType_set)
|
|
unitOfMeasurement = 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
|
|
|
|
# Register PacketDataHeader in _CAPS:
|
|
_CAPS.PacketDataHeader_swigregister(PacketDataHeader)
|
|
|
|
class PacketDataHeaderV2(PacketDataHeader):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self):
|
|
_CAPS.PacketDataHeaderV2_swiginit(self, _CAPS.new_PacketDataHeaderV2())
|
|
samplingFrequencyNumerator = property(_CAPS.PacketDataHeaderV2_samplingFrequencyNumerator_get, _CAPS.PacketDataHeaderV2_samplingFrequencyNumerator_set)
|
|
samplingFrequencyDenominator = property(_CAPS.PacketDataHeaderV2_samplingFrequencyDenominator_get, _CAPS.PacketDataHeaderV2_samplingFrequencyDenominator_set)
|
|
quality = 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
|
|
|
|
# Register PacketDataHeaderV2 in _CAPS:
|
|
_CAPS.PacketDataHeaderV2_swigregister(PacketDataHeaderV2)
|
|
|
|
NetworkCode = _CAPS.NetworkCode
|
|
StationCode = _CAPS.StationCode
|
|
LocationCode = _CAPS.LocationCode
|
|
ChannelCode = _CAPS.ChannelCode
|
|
StreamIDComponentSize = _CAPS.StreamIDComponentSize
|
|
class PacketHeaderV1(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
SIDSize = property(_CAPS.PacketHeaderV1_SIDSize_get, _CAPS.PacketHeaderV1_SIDSize_set)
|
|
size = 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):
|
|
_CAPS.PacketHeaderV1_swiginit(self, _CAPS.new_PacketHeaderV1())
|
|
__swig_destroy__ = _CAPS.delete_PacketHeaderV1
|
|
|
|
# Register PacketHeaderV1 in _CAPS:
|
|
_CAPS.PacketHeaderV1_swigregister(PacketHeaderV1)
|
|
|
|
class PacketHeaderV2(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
SIDSize = property(_CAPS.PacketHeaderV2_SIDSize_get, _CAPS.PacketHeaderV2_SIDSize_set)
|
|
size = 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):
|
|
_CAPS.PacketHeaderV2_swiginit(self, _CAPS.new_PacketHeaderV2())
|
|
__swig_destroy__ = _CAPS.delete_PacketHeaderV2
|
|
|
|
# Register PacketHeaderV2 in _CAPS:
|
|
_CAPS.PacketHeaderV2_swigregister(PacketHeaderV2)
|
|
|
|
class ResponseHeader(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
id = property(_CAPS.ResponseHeader_id_get, _CAPS.ResponseHeader_id_set)
|
|
size = property(_CAPS.ResponseHeader_size_get, _CAPS.ResponseHeader_size_set)
|
|
|
|
def get(self, buf):
|
|
return _CAPS.ResponseHeader_get(self, buf)
|
|
|
|
def __init__(self):
|
|
_CAPS.ResponseHeader_swiginit(self, _CAPS.new_ResponseHeader())
|
|
__swig_destroy__ = _CAPS.delete_ResponseHeader
|
|
|
|
# Register ResponseHeader in _CAPS:
|
|
_CAPS.ResponseHeader_swigregister(ResponseHeader)
|
|
|
|
class DataRecord(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
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
|
|
|
|
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)
|
|
|
|
# Register DataRecord in _CAPS:
|
|
_CAPS.DataRecord_swigregister(DataRecord)
|
|
|
|
class RawPacket(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
header = property(_CAPS.RawPacket_header_get, _CAPS.RawPacket_header_set)
|
|
SID = property(_CAPS.RawPacket_SID_get, _CAPS.RawPacket_SID_set)
|
|
data = property(_CAPS.RawPacket_data_get, _CAPS.RawPacket_data_set)
|
|
record = property(_CAPS.RawPacket_record_get, _CAPS.RawPacket_record_set)
|
|
|
|
def __init__(self):
|
|
_CAPS.RawPacket_swiginit(self, _CAPS.new_RawPacket())
|
|
__swig_destroy__ = _CAPS.delete_RawPacket
|
|
|
|
# Register RawPacket in _CAPS:
|
|
_CAPS.RawPacket_swigregister(RawPacket)
|
|
|
|
class MetaPacket(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
SID = property(_CAPS.MetaPacket_SID_get, _CAPS.MetaPacket_SID_set)
|
|
packetDataHeader = property(_CAPS.MetaPacket_packetDataHeader_get, _CAPS.MetaPacket_packetDataHeader_set)
|
|
record = property(_CAPS.MetaPacket_record_get, _CAPS.MetaPacket_record_set)
|
|
recordHeader = property(_CAPS.MetaPacket_recordHeader_get, _CAPS.MetaPacket_recordHeader_set)
|
|
startTime = property(_CAPS.MetaPacket_startTime_get, _CAPS.MetaPacket_startTime_set)
|
|
endTime = property(_CAPS.MetaPacket_endTime_get, _CAPS.MetaPacket_endTime_set)
|
|
timestamp = property(_CAPS.MetaPacket_timestamp_get, _CAPS.MetaPacket_timestamp_set)
|
|
|
|
def __init__(self):
|
|
_CAPS.MetaPacket_swiginit(self, _CAPS.new_MetaPacket())
|
|
__swig_destroy__ = _CAPS.delete_MetaPacket
|
|
|
|
# Register MetaPacket in _CAPS:
|
|
_CAPS.MetaPacket_swigregister(MetaPacket)
|
|
|
|
class Packet(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
_CAPS.Packet_swiginit(self, _CAPS.new_Packet(*args))
|
|
|
|
def clone(self):
|
|
return _CAPS.Packet_clone(self)
|
|
buffer = property(_CAPS.Packet_buffer_get, _CAPS.Packet_buffer_set)
|
|
record = property(_CAPS.Packet_record_get, _CAPS.Packet_record_set)
|
|
networkCode = property(_CAPS.Packet_networkCode_get, _CAPS.Packet_networkCode_set)
|
|
stationCode = property(_CAPS.Packet_stationCode_get, _CAPS.Packet_stationCode_set)
|
|
locationCode = property(_CAPS.Packet_locationCode_get, _CAPS.Packet_locationCode_set)
|
|
channelCode = property(_CAPS.Packet_channelCode_get, _CAPS.Packet_channelCode_set)
|
|
streamID = property(_CAPS.Packet_streamID_get, _CAPS.Packet_streamID_set)
|
|
dataType = property(_CAPS.Packet_dataType_get, _CAPS.Packet_dataType_set)
|
|
dt_us = property(_CAPS.Packet_dt_us_get, _CAPS.Packet_dt_us_set)
|
|
uom = property(_CAPS.Packet_uom_get, _CAPS.Packet_uom_set)
|
|
timingQuality = property(_CAPS.Packet_timingQuality_get, _CAPS.Packet_timingQuality_set)
|
|
|
|
def size(self):
|
|
return _CAPS.Packet_size(self)
|
|
__swig_destroy__ = _CAPS.delete_Packet
|
|
|
|
# Register Packet in _CAPS:
|
|
_CAPS.Packet_swigregister(Packet)
|
|
|
|
class AnyDataRecord(DataRecord):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self):
|
|
_CAPS.AnyDataRecord_swiginit(self, _CAPS.new_AnyDataRecord())
|
|
|
|
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
|
|
|
|
# Register AnyDataRecord in _CAPS:
|
|
_CAPS.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)
|
|
class SPClock(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, freqn, freqd):
|
|
_CAPS.SPClock_swiginit(self, _CAPS.new_SPClock(freqn, freqd))
|
|
|
|
def syncTime(self, time):
|
|
return _CAPS.SPClock_syncTime(self, time)
|
|
|
|
def tick(self):
|
|
return _CAPS.SPClock_tick(self)
|
|
|
|
def getTime(self, tickDiff):
|
|
return _CAPS.SPClock_getTime(self, tickDiff)
|
|
|
|
def correction(self):
|
|
return _CAPS.SPClock_correction(self)
|
|
freqn = property(_CAPS.SPClock_freqn_get)
|
|
freqd = property(_CAPS.SPClock_freqd_get)
|
|
__swig_destroy__ = _CAPS.delete_SPClock
|
|
|
|
# Register SPClock in _CAPS:
|
|
_CAPS.SPClock_swigregister(SPClock)
|
|
|
|
class Encoder(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _CAPS.delete_Encoder
|
|
|
|
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)
|
|
|
|
# Register Encoder in _CAPS:
|
|
_CAPS.Encoder_swigregister(Encoder)
|
|
|
|
class EncoderFactory(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _CAPS.delete_EncoderFactory
|
|
|
|
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)
|
|
|
|
# Register EncoderFactory in _CAPS:
|
|
_CAPS.EncoderFactory_swigregister(EncoderFactory)
|
|
|
|
class MSEEDEncoderFactory(EncoderFactory):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def setRecordLength(self, recordLength):
|
|
return _CAPS.MSEEDEncoderFactory_setRecordLength(self, recordLength)
|
|
__swig_destroy__ = _CAPS.delete_MSEEDEncoderFactory
|
|
|
|
# Register MSEEDEncoderFactory in _CAPS:
|
|
_CAPS.MSEEDEncoderFactory_swigregister(MSEEDEncoderFactory)
|
|
|
|
class SteimEncoderFactory(MSEEDEncoderFactory):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def supportsRecord(self, rec):
|
|
return _CAPS.SteimEncoderFactory_supportsRecord(self, rec)
|
|
__swig_destroy__ = _CAPS.delete_SteimEncoderFactory
|
|
|
|
# Register SteimEncoderFactory in _CAPS:
|
|
_CAPS.SteimEncoderFactory_swigregister(SteimEncoderFactory)
|
|
|
|
class IdentityEncoderFactory(MSEEDEncoderFactory):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__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):
|
|
_CAPS.IdentityEncoderFactory_swiginit(self, _CAPS.new_IdentityEncoderFactory())
|
|
__swig_destroy__ = _CAPS.delete_IdentityEncoderFactory
|
|
|
|
# Register IdentityEncoderFactory in _CAPS:
|
|
_CAPS.IdentityEncoderFactory_swigregister(IdentityEncoderFactory)
|
|
|
|
class Steim1EncoderFactory(SteimEncoderFactory):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__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):
|
|
_CAPS.Steim1EncoderFactory_swiginit(self, _CAPS.new_Steim1EncoderFactory())
|
|
__swig_destroy__ = _CAPS.delete_Steim1EncoderFactory
|
|
|
|
# Register Steim1EncoderFactory in _CAPS:
|
|
_CAPS.Steim1EncoderFactory_swigregister(Steim1EncoderFactory)
|
|
|
|
class Steim2EncoderFactory(SteimEncoderFactory):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__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):
|
|
_CAPS.Steim2EncoderFactory_swiginit(self, _CAPS.new_Steim2EncoderFactory())
|
|
__swig_destroy__ = _CAPS.delete_Steim2EncoderFactory
|
|
|
|
# Register Steim2EncoderFactory in _CAPS:
|
|
_CAPS.Steim2EncoderFactory_swigregister(Steim2EncoderFactory)
|
|
|
|
class MSEEDDataRecord(DataRecord):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def 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
|
|
|
|
# Register MSEEDDataRecord in _CAPS:
|
|
_CAPS.MSEEDDataRecord_swigregister(MSEEDDataRecord)
|
|
|
|
class Plugin(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__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):
|
|
_CAPS.Plugin_swiginit(self, _CAPS.new_Plugin(*args))
|
|
__swig_destroy__ = _CAPS.delete_Plugin
|
|
|
|
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 setAddress(self, addr, defaultPort=18003):
|
|
return _CAPS.Plugin_setAddress(self, addr, defaultPort)
|
|
|
|
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 flushEncoders(self):
|
|
return _CAPS.Plugin_flushEncoders(self)
|
|
|
|
def dumpPackets(self, enable):
|
|
return _CAPS.Plugin_dumpPackets(self, enable)
|
|
|
|
def packetBuffer(self):
|
|
return _CAPS.Plugin_packetBuffer(self)
|
|
|
|
def setAgent(self, agent):
|
|
return _CAPS.Plugin_setAgent(self, agent)
|
|
|
|
def version(self):
|
|
return _CAPS.Plugin_version(self)
|
|
|
|
def push(self, *args):
|
|
return _CAPS.Plugin_push(self, *args)
|
|
|
|
# Register Plugin in _CAPS:
|
|
_CAPS.Plugin_swigregister(Plugin)
|
|
|
|
class RawResponseHeader(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
timeSeconds = property(_CAPS.RawResponseHeader_timeSeconds_get, _CAPS.RawResponseHeader_timeSeconds_set)
|
|
timeMicroSeconds = 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):
|
|
_CAPS.RawResponseHeader_swiginit(self, _CAPS.new_RawResponseHeader())
|
|
__swig_destroy__ = _CAPS.delete_RawResponseHeader
|
|
|
|
# Register RawResponseHeader in _CAPS:
|
|
_CAPS.RawResponseHeader_swigregister(RawResponseHeader)
|
|
|
|
class RawDataRecord(DataRecord):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def 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
|
|
|
|
# Register RawDataRecord in _CAPS:
|
|
_CAPS.RawDataRecord_swigregister(RawDataRecord)
|
|
|
|
class FixedRawDataRecord(RawDataRecord):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def 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
|
|
|
|
# Register FixedRawDataRecord in _CAPS:
|
|
_CAPS.FixedRawDataRecord_swigregister(FixedRawDataRecord)
|
|
|
|
class ChunkHeader(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
chunkSize = 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):
|
|
_CAPS.ChunkHeader_swiginit(self, _CAPS.new_ChunkHeader())
|
|
__swig_destroy__ = _CAPS.delete_ChunkHeader
|
|
|
|
# Register ChunkHeader in _CAPS:
|
|
_CAPS.ChunkHeader_swigregister(ChunkHeader)
|
|
|
|
class ChunkIterator(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
_CAPS.ChunkIterator_swiginit(self, _CAPS.new_ChunkIterator(*args))
|
|
|
|
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
|
|
|
|
# Register ChunkIterator in _CAPS:
|
|
_CAPS.ChunkIterator_swigregister(ChunkIterator)
|
|
ChunkHeaderSize = cvar.ChunkHeaderSize
|
|
|
|
class Chunk(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _CAPS.delete_Chunk
|
|
|
|
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)
|
|
|
|
# Register Chunk in _CAPS:
|
|
_CAPS.Chunk_swigregister(Chunk)
|
|
|
|
class HeadChunk(Chunk):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
data = 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):
|
|
_CAPS.HeadChunk_swiginit(self, _CAPS.new_HeadChunk())
|
|
__swig_destroy__ = _CAPS.delete_HeadChunk
|
|
|
|
# Register HeadChunk in _CAPS:
|
|
_CAPS.HeadChunk_swigregister(HeadChunk)
|
|
|
|
class SID(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
networkCode = property(_CAPS.SID_networkCode_get, _CAPS.SID_networkCode_set)
|
|
stationCode = property(_CAPS.SID_stationCode_get, _CAPS.SID_stationCode_set)
|
|
locationCode = property(_CAPS.SID_locationCode_get, _CAPS.SID_locationCode_set)
|
|
channelCode = 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):
|
|
_CAPS.SID_swiginit(self, _CAPS.new_SID())
|
|
__swig_destroy__ = _CAPS.delete_SID
|
|
|
|
# Register SID in _CAPS:
|
|
_CAPS.SID_swigregister(SID)
|
|
|
|
class SIDChunk(Chunk, SID):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__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):
|
|
_CAPS.SIDChunk_swiginit(self, _CAPS.new_SIDChunk())
|
|
__swig_destroy__ = _CAPS.delete_SIDChunk
|
|
|
|
# Register SIDChunk in _CAPS:
|
|
_CAPS.SIDChunk_swigregister(SIDChunk)
|
|
|
|
class RTCM2DataRecord(DataRecord):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def 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
|
|
|
|
# Register RTCM2DataRecord in _CAPS:
|
|
_CAPS.RTCM2DataRecord_swigregister(RTCM2DataRecord)
|
|
|
|
class Socket(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__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):
|
|
_CAPS.Socket_swiginit(self, _CAPS.new_Socket())
|
|
__swig_destroy__ = _CAPS.delete_Socket
|
|
|
|
@staticmethod
|
|
def toString(arg1):
|
|
return _CAPS.Socket_toString(arg1)
|
|
|
|
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)
|
|
|
|
# Register Socket in _CAPS:
|
|
_CAPS.Socket_swigregister(Socket)
|
|
|
|
def Socket_toString(arg1):
|
|
return _CAPS.Socket_toString(arg1)
|
|
|
|
class SSLSocket(Socket):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
_CAPS.SSLSocket_swiginit(self, _CAPS.new_SSLSocket(*args))
|
|
__swig_destroy__ = _CAPS.delete_SSLSocket
|
|
|
|
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)
|
|
|
|
# Register SSLSocket in _CAPS:
|
|
_CAPS.SSLSocket_swigregister(SSLSocket)
|
|
|
|
class charArray(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, nelements):
|
|
_CAPS.charArray_swiginit(self, _CAPS.new_charArray(nelements))
|
|
__swig_destroy__ = _CAPS.delete_charArray
|
|
|
|
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)
|
|
|
|
@staticmethod
|
|
def frompointer(t):
|
|
return _CAPS.charArray_frompointer(t)
|
|
|
|
# Register charArray in _CAPS:
|
|
_CAPS.charArray_swigregister(charArray)
|
|
|
|
def charArray_frompointer(t):
|
|
return _CAPS.charArray_frompointer(t)
|
|
|
|
class arraybuf(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
_CAPS.arraybuf_swiginit(self, _CAPS.new_arraybuf(*args))
|
|
|
|
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
|
|
|
|
# Register arraybuf in _CAPS:
|
|
_CAPS.arraybuf_swigregister(arraybuf)
|
|
|
|
|
|
def splitAddress(host, port, address, default_port):
|
|
return _CAPS.splitAddress(host, port, address, default_port)
|
|
|
|
def tokenize(str, delim, len_source, len_tok):
|
|
return _CAPS.tokenize(str, delim, len_source, len_tok)
|
|
|
|
def trim(*args):
|
|
return _CAPS.trim(*args)
|
|
|
|
def timeToTimestamp(ts, t):
|
|
return _CAPS.timeToTimestamp(ts, t)
|
|
|
|
def str2int(*args):
|
|
return _CAPS.str2int(*args)
|
|
|
|
def timestampToTime(ts):
|
|
return _CAPS.timestampToTime(ts)
|
|
|
|
def samplesToTimeSpan(head, sampleCount):
|
|
return _CAPS.samplesToTimeSpan(head, sampleCount)
|
|
|
|
def timeSpanToSamples(head, span):
|
|
return _CAPS.timeSpanToSamples(head, span)
|
|
|
|
def timeSpanToSamplesCeil(head, span):
|
|
return _CAPS.timeSpanToSamplesCeil(head, span)
|
|
|
|
def timeSpanToSamplesFloor(head, span):
|
|
return _CAPS.timeSpanToSamplesFloor(head, span)
|
|
|
|
def dataTypeSize(dt):
|
|
return _CAPS.dataTypeSize(dt)
|
|
|
|
|