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.
2461 lines
88 KiB
Python
2461 lines
88 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 _io
|
|
else:
|
|
import _io
|
|
|
|
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__)
|
|
|
|
|
|
import weakref
|
|
|
|
class SwigPyIterator(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__ = _io.delete_SwigPyIterator
|
|
|
|
def value(self):
|
|
return _io.SwigPyIterator_value(self)
|
|
|
|
def incr(self, n=1):
|
|
return _io.SwigPyIterator_incr(self, n)
|
|
|
|
def decr(self, n=1):
|
|
return _io.SwigPyIterator_decr(self, n)
|
|
|
|
def distance(self, x):
|
|
return _io.SwigPyIterator_distance(self, x)
|
|
|
|
def equal(self, x):
|
|
return _io.SwigPyIterator_equal(self, x)
|
|
|
|
def copy(self):
|
|
return _io.SwigPyIterator_copy(self)
|
|
|
|
def next(self):
|
|
return _io.SwigPyIterator_next(self)
|
|
|
|
def __next__(self):
|
|
return _io.SwigPyIterator___next__(self)
|
|
|
|
def previous(self):
|
|
return _io.SwigPyIterator_previous(self)
|
|
|
|
def advance(self, n):
|
|
return _io.SwigPyIterator_advance(self, n)
|
|
|
|
def __eq__(self, x):
|
|
return _io.SwigPyIterator___eq__(self, x)
|
|
|
|
def __ne__(self, x):
|
|
return _io.SwigPyIterator___ne__(self, x)
|
|
|
|
def __iadd__(self, n):
|
|
return _io.SwigPyIterator___iadd__(self, n)
|
|
|
|
def __isub__(self, n):
|
|
return _io.SwigPyIterator___isub__(self, n)
|
|
|
|
def __add__(self, n):
|
|
return _io.SwigPyIterator___add__(self, n)
|
|
|
|
def __sub__(self, *args):
|
|
return _io.SwigPyIterator___sub__(self, *args)
|
|
def __iter__(self):
|
|
return self
|
|
|
|
# Register SwigPyIterator in _io:
|
|
_io.SwigPyIterator_swigregister(SwigPyIterator)
|
|
|
|
class ios_base(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")
|
|
__repr__ = _swig_repr
|
|
erase_event = _io.ios_base_erase_event
|
|
imbue_event = _io.ios_base_imbue_event
|
|
copyfmt_event = _io.ios_base_copyfmt_event
|
|
|
|
def register_callback(self, __fn, __index):
|
|
return _io.ios_base_register_callback(self, __fn, __index)
|
|
|
|
def flags(self, *args):
|
|
return _io.ios_base_flags(self, *args)
|
|
|
|
def setf(self, *args):
|
|
return _io.ios_base_setf(self, *args)
|
|
|
|
def unsetf(self, __mask):
|
|
return _io.ios_base_unsetf(self, __mask)
|
|
|
|
def precision(self, *args):
|
|
return _io.ios_base_precision(self, *args)
|
|
|
|
def width(self, *args):
|
|
return _io.ios_base_width(self, *args)
|
|
|
|
@staticmethod
|
|
def sync_with_stdio(__sync=True):
|
|
return _io.ios_base_sync_with_stdio(__sync)
|
|
|
|
def imbue(self, __loc):
|
|
return _io.ios_base_imbue(self, __loc)
|
|
|
|
def getloc(self):
|
|
return _io.ios_base_getloc(self)
|
|
|
|
@staticmethod
|
|
def xalloc():
|
|
return _io.ios_base_xalloc()
|
|
|
|
def iword(self, __ix):
|
|
return _io.ios_base_iword(self, __ix)
|
|
|
|
def pword(self, __ix):
|
|
return _io.ios_base_pword(self, __ix)
|
|
__swig_destroy__ = _io.delete_ios_base
|
|
|
|
# Register ios_base in _io:
|
|
_io.ios_base_swigregister(ios_base)
|
|
cvar = _io.cvar
|
|
ios_base.boolalpha = _io.cvar.ios_base_boolalpha
|
|
ios_base.dec = _io.cvar.ios_base_dec
|
|
ios_base.fixed = _io.cvar.ios_base_fixed
|
|
ios_base.hex = _io.cvar.ios_base_hex
|
|
ios_base.internal = _io.cvar.ios_base_internal
|
|
ios_base.left = _io.cvar.ios_base_left
|
|
ios_base.oct = _io.cvar.ios_base_oct
|
|
ios_base.right = _io.cvar.ios_base_right
|
|
ios_base.scientific = _io.cvar.ios_base_scientific
|
|
ios_base.showbase = _io.cvar.ios_base_showbase
|
|
ios_base.showpoint = _io.cvar.ios_base_showpoint
|
|
ios_base.showpos = _io.cvar.ios_base_showpos
|
|
ios_base.skipws = _io.cvar.ios_base_skipws
|
|
ios_base.unitbuf = _io.cvar.ios_base_unitbuf
|
|
ios_base.uppercase = _io.cvar.ios_base_uppercase
|
|
ios_base.adjustfield = _io.cvar.ios_base_adjustfield
|
|
ios_base.basefield = _io.cvar.ios_base_basefield
|
|
ios_base.floatfield = _io.cvar.ios_base_floatfield
|
|
ios_base.badbit = _io.cvar.ios_base_badbit
|
|
ios_base.eofbit = _io.cvar.ios_base_eofbit
|
|
ios_base.failbit = _io.cvar.ios_base_failbit
|
|
ios_base.goodbit = _io.cvar.ios_base_goodbit
|
|
ios_base.app = _io.cvar.ios_base_app
|
|
ios_base.ate = _io.cvar.ios_base_ate
|
|
ios_base.binary = _io.cvar.ios_base_binary
|
|
ios_base.ios_base_in = _io.cvar.ios_base_ios_base_in
|
|
ios_base.out = _io.cvar.ios_base_out
|
|
ios_base.trunc = _io.cvar.ios_base_trunc
|
|
ios_base.beg = _io.cvar.ios_base_beg
|
|
ios_base.cur = _io.cvar.ios_base_cur
|
|
ios_base.end = _io.cvar.ios_base_end
|
|
|
|
def ios_base_sync_with_stdio(__sync=True):
|
|
return _io.ios_base_sync_with_stdio(__sync)
|
|
|
|
def ios_base_xalloc():
|
|
return _io.ios_base_xalloc()
|
|
|
|
class ios(ios_base):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def rdstate(self):
|
|
return _io.ios_rdstate(self)
|
|
|
|
def clear(self, *args):
|
|
return _io.ios_clear(self, *args)
|
|
|
|
def setstate(self, __state):
|
|
return _io.ios_setstate(self, __state)
|
|
|
|
def good(self):
|
|
return _io.ios_good(self)
|
|
|
|
def eof(self):
|
|
return _io.ios_eof(self)
|
|
|
|
def fail(self):
|
|
return _io.ios_fail(self)
|
|
|
|
def bad(self):
|
|
return _io.ios_bad(self)
|
|
|
|
def exceptions(self, *args):
|
|
return _io.ios_exceptions(self, *args)
|
|
|
|
def __init__(self, __sb):
|
|
_io.ios_swiginit(self, _io.new_ios(__sb))
|
|
__swig_destroy__ = _io.delete_ios
|
|
|
|
def tie(self, *args):
|
|
return _io.ios_tie(self, *args)
|
|
|
|
def rdbuf(self, *args):
|
|
return _io.ios_rdbuf(self, *args)
|
|
|
|
def copyfmt(self, __rhs):
|
|
return _io.ios_copyfmt(self, __rhs)
|
|
|
|
def fill(self, *args):
|
|
return _io.ios_fill(self, *args)
|
|
|
|
def imbue(self, __loc):
|
|
return _io.ios_imbue(self, __loc)
|
|
|
|
def narrow(self, __c, __dfault):
|
|
return _io.ios_narrow(self, __c, __dfault)
|
|
|
|
def widen(self, __c):
|
|
return _io.ios_widen(self, __c)
|
|
|
|
# Register ios in _io:
|
|
_io.ios_swigregister(ios)
|
|
|
|
import seiscomp.math
|
|
import seiscomp.core
|
|
class DatabaseInterface(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::IO::DatabaseInterface class."""
|
|
|
|
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
|
|
|
|
@staticmethod
|
|
def ClassName():
|
|
r"""ClassName() -> char const *"""
|
|
return _io.DatabaseInterface_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _io.DatabaseInterface_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(DatabaseInterface self) -> char const *"""
|
|
return _io.DatabaseInterface_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(DatabaseInterface self) -> RTTI"""
|
|
return _io.DatabaseInterface_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> DatabaseInterface
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> DatabaseInterface
|
|
"""
|
|
return _io.DatabaseInterface_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> DatabaseInterface
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DatabaseInterface
|
|
"""
|
|
return _io.DatabaseInterface_ConstCast(*args)
|
|
__swig_destroy__ = _io.delete_DatabaseInterface
|
|
|
|
@staticmethod
|
|
def Create(service):
|
|
r"""Create(char const * service) -> DatabaseInterface"""
|
|
return _io.DatabaseInterface_Create(service)
|
|
|
|
@staticmethod
|
|
def Open(uri):
|
|
r"""Open(char const * uri) -> DatabaseInterface"""
|
|
return _io.DatabaseInterface_Open(uri)
|
|
|
|
def connect(self, connection):
|
|
r"""connect(DatabaseInterface self, char const * connection) -> bool"""
|
|
return _io.DatabaseInterface_connect(self, connection)
|
|
|
|
def disconnect(self):
|
|
r"""disconnect(DatabaseInterface self)"""
|
|
return _io.DatabaseInterface_disconnect(self)
|
|
|
|
def isConnected(self):
|
|
r"""isConnected(DatabaseInterface self) -> bool"""
|
|
return _io.DatabaseInterface_isConnected(self)
|
|
|
|
def start(self):
|
|
r"""start(DatabaseInterface self)"""
|
|
return _io.DatabaseInterface_start(self)
|
|
|
|
def commit(self):
|
|
r"""commit(DatabaseInterface self)"""
|
|
return _io.DatabaseInterface_commit(self)
|
|
|
|
def rollback(self):
|
|
r"""rollback(DatabaseInterface self)"""
|
|
return _io.DatabaseInterface_rollback(self)
|
|
|
|
def execute(self, command):
|
|
r"""execute(DatabaseInterface self, char const * command) -> bool"""
|
|
return _io.DatabaseInterface_execute(self, command)
|
|
|
|
def beginQuery(self, query):
|
|
r"""beginQuery(DatabaseInterface self, char const * query) -> bool"""
|
|
return _io.DatabaseInterface_beginQuery(self, query)
|
|
|
|
def endQuery(self):
|
|
r"""endQuery(DatabaseInterface self)"""
|
|
return _io.DatabaseInterface_endQuery(self)
|
|
|
|
def defaultValue(self):
|
|
r"""defaultValue(DatabaseInterface self) -> char const *"""
|
|
return _io.DatabaseInterface_defaultValue(self)
|
|
|
|
def lastInsertId(self, table):
|
|
r"""lastInsertId(DatabaseInterface self, char const * table) -> Seiscomp::IO::DatabaseInterface::OID"""
|
|
return _io.DatabaseInterface_lastInsertId(self, table)
|
|
|
|
def numberOfAffectedRows(self):
|
|
r"""numberOfAffectedRows(DatabaseInterface self) -> uint64_t"""
|
|
return _io.DatabaseInterface_numberOfAffectedRows(self)
|
|
|
|
def fetchRow(self):
|
|
r"""fetchRow(DatabaseInterface self) -> bool"""
|
|
return _io.DatabaseInterface_fetchRow(self)
|
|
|
|
def findColumn(self, name):
|
|
r"""findColumn(DatabaseInterface self, char const * name) -> int"""
|
|
return _io.DatabaseInterface_findColumn(self, name)
|
|
|
|
def getRowFieldCount(self):
|
|
r"""getRowFieldCount(DatabaseInterface self) -> int"""
|
|
return _io.DatabaseInterface_getRowFieldCount(self)
|
|
|
|
def getRowFieldName(self, index):
|
|
r"""getRowFieldName(DatabaseInterface self, int index) -> char const *"""
|
|
return _io.DatabaseInterface_getRowFieldName(self, index)
|
|
|
|
def getRowField(self, index):
|
|
r"""getRowField(DatabaseInterface self, int index) -> void const *"""
|
|
return _io.DatabaseInterface_getRowField(self, index)
|
|
|
|
def getRowFieldString(self, index):
|
|
r"""getRowFieldString(DatabaseInterface self, int index) -> string"""
|
|
return _io.DatabaseInterface_getRowFieldString(self, index)
|
|
|
|
def getRowFieldSize(self, index):
|
|
r"""getRowFieldSize(DatabaseInterface self, int index) -> size_t"""
|
|
return _io.DatabaseInterface_getRowFieldSize(self, index)
|
|
|
|
def timeToString(self, arg2):
|
|
r"""timeToString(DatabaseInterface self, Time arg2) -> string"""
|
|
return _io.DatabaseInterface_timeToString(self, arg2)
|
|
|
|
def stringToTime(self, arg2):
|
|
r"""stringToTime(DatabaseInterface self, char const * arg2) -> Time"""
|
|
return _io.DatabaseInterface_stringToTime(self, arg2)
|
|
|
|
def escape(self, out, _in):
|
|
r"""escape(DatabaseInterface self, string out, string _in) -> bool"""
|
|
return _io.DatabaseInterface_escape(self, out, _in)
|
|
|
|
def columnPrefix(self):
|
|
r"""columnPrefix(DatabaseInterface self) -> string"""
|
|
return _io.DatabaseInterface_columnPrefix(self)
|
|
|
|
def convertColumnName(self, name):
|
|
r"""convertColumnName(DatabaseInterface self, string name) -> string"""
|
|
return _io.DatabaseInterface_convertColumnName(self, name)
|
|
|
|
# Register DatabaseInterface in _io:
|
|
_io.DatabaseInterface_swigregister(DatabaseInterface)
|
|
|
|
def DatabaseInterface_ClassName():
|
|
r"""DatabaseInterface_ClassName() -> char const *"""
|
|
return _io.DatabaseInterface_ClassName()
|
|
|
|
def DatabaseInterface_TypeInfo():
|
|
r"""DatabaseInterface_TypeInfo() -> RTTI"""
|
|
return _io.DatabaseInterface_TypeInfo()
|
|
|
|
def DatabaseInterface_Cast(*args):
|
|
r"""
|
|
DatabaseInterface_Cast(BaseObject o) -> DatabaseInterface
|
|
DatabaseInterface_Cast(Seiscomp::Core::BaseObjectPtr o) -> DatabaseInterface
|
|
"""
|
|
return _io.DatabaseInterface_Cast(*args)
|
|
|
|
def DatabaseInterface_ConstCast(*args):
|
|
r"""
|
|
DatabaseInterface_ConstCast(BaseObject o) -> DatabaseInterface
|
|
DatabaseInterface_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DatabaseInterface
|
|
"""
|
|
return _io.DatabaseInterface_ConstCast(*args)
|
|
DatabaseInterface.INVALID_OID = _io.cvar.DatabaseInterface_INVALID_OID
|
|
|
|
def DatabaseInterface_Create(service):
|
|
r"""DatabaseInterface_Create(char const * service) -> DatabaseInterface"""
|
|
return _io.DatabaseInterface_Create(service)
|
|
|
|
def DatabaseInterface_Open(uri):
|
|
r"""DatabaseInterface_Open(char const * uri) -> DatabaseInterface"""
|
|
return _io.DatabaseInterface_Open(uri)
|
|
|
|
class GFSource(seiscomp.math.CoordD):
|
|
r"""Proxy of C++ Seiscomp::IO::GFSource class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, lat=0.0, lon=0.0, d=0.0):
|
|
r"""__init__(GFSource self, double lat=0.0, double lon=0.0, double d=0.0) -> GFSource"""
|
|
_io.GFSource_swiginit(self, _io.new_GFSource(lat, lon, d))
|
|
depth = property(_io.GFSource_depth_get, _io.GFSource_depth_set, doc=r"""depth : double""")
|
|
__swig_destroy__ = _io.delete_GFSource
|
|
|
|
# Register GFSource in _io:
|
|
_io.GFSource_swigregister(GFSource)
|
|
|
|
class GFReceiver(seiscomp.math.CoordD):
|
|
r"""Proxy of C++ Seiscomp::IO::GFReceiver class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, lat=0.0, lon=0.0, e=0.0):
|
|
r"""__init__(GFReceiver self, double lat=0.0, double lon=0.0, double e=0.0) -> GFReceiver"""
|
|
_io.GFReceiver_swiginit(self, _io.new_GFReceiver(lat, lon, e))
|
|
elevation = property(_io.GFReceiver_elevation_get, _io.GFReceiver_elevation_set, doc=r"""elevation : double""")
|
|
__swig_destroy__ = _io.delete_GFReceiver
|
|
|
|
# Register GFReceiver in _io:
|
|
_io.GFReceiver_swigregister(GFReceiver)
|
|
|
|
class GFArchive(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::IO::GFArchive class."""
|
|
|
|
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
|
|
|
|
@staticmethod
|
|
def ClassName():
|
|
r"""ClassName() -> char const *"""
|
|
return _io.GFArchive_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _io.GFArchive_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(GFArchive self) -> char const *"""
|
|
return _io.GFArchive_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(GFArchive self) -> RTTI"""
|
|
return _io.GFArchive_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> GFArchive
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> GFArchive
|
|
"""
|
|
return _io.GFArchive_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> GFArchive
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> GFArchive
|
|
"""
|
|
return _io.GFArchive_ConstCast(*args)
|
|
__swig_destroy__ = _io.delete_GFArchive
|
|
|
|
def setSource(self, arg2):
|
|
r"""setSource(GFArchive self, string arg2) -> bool"""
|
|
return _io.GFArchive_setSource(self, arg2)
|
|
|
|
def close(self):
|
|
r"""close(GFArchive self)"""
|
|
return _io.GFArchive_close(self)
|
|
|
|
def availableModels(self):
|
|
r"""availableModels(GFArchive self) -> std::list< std::string >"""
|
|
return _io.GFArchive_availableModels(self)
|
|
|
|
def availableDepths(self, model):
|
|
r"""availableDepths(GFArchive self, string model) -> std::list< double >"""
|
|
return _io.GFArchive_availableDepths(self, model)
|
|
|
|
def setTimeSpan(self, span):
|
|
r"""setTimeSpan(GFArchive self, TimeSpan span) -> bool"""
|
|
return _io.GFArchive_setTimeSpan(self, span)
|
|
|
|
def addRequest(self, *args):
|
|
r"""
|
|
addRequest(GFArchive self, string id, string model, GFSource source, GFReceiver receiver) -> bool
|
|
addRequest(GFArchive self, string id, string model, GFSource source, GFReceiver receiver, TimeSpan span) -> bool
|
|
"""
|
|
return _io.GFArchive_addRequest(self, *args)
|
|
|
|
def get(self):
|
|
r"""get(GFArchive self) -> GreensFunction"""
|
|
return _io.GFArchive_get(self)
|
|
|
|
def getTravelTime(self, phase, model, source, receiver):
|
|
r"""getTravelTime(GFArchive self, string phase, string model, GFSource source, GFReceiver receiver) -> Seiscomp::Core::Optional< double >::Impl"""
|
|
return _io.GFArchive_getTravelTime(self, phase, model, source, receiver)
|
|
|
|
def hasLocalTravelTimes(self):
|
|
r"""hasLocalTravelTimes(GFArchive self) -> bool"""
|
|
return _io.GFArchive_hasLocalTravelTimes(self)
|
|
|
|
@staticmethod
|
|
def Create(service):
|
|
r"""Create(char const * service) -> GFArchive"""
|
|
return _io.GFArchive_Create(service)
|
|
|
|
@staticmethod
|
|
def Open(url):
|
|
r"""Open(char const * url) -> GFArchive"""
|
|
return _io.GFArchive_Open(url)
|
|
|
|
# Register GFArchive in _io:
|
|
_io.GFArchive_swigregister(GFArchive)
|
|
|
|
def GFArchive_ClassName():
|
|
r"""GFArchive_ClassName() -> char const *"""
|
|
return _io.GFArchive_ClassName()
|
|
|
|
def GFArchive_TypeInfo():
|
|
r"""GFArchive_TypeInfo() -> RTTI"""
|
|
return _io.GFArchive_TypeInfo()
|
|
|
|
def GFArchive_Cast(*args):
|
|
r"""
|
|
GFArchive_Cast(BaseObject o) -> GFArchive
|
|
GFArchive_Cast(Seiscomp::Core::BaseObjectPtr o) -> GFArchive
|
|
"""
|
|
return _io.GFArchive_Cast(*args)
|
|
|
|
def GFArchive_ConstCast(*args):
|
|
r"""
|
|
GFArchive_ConstCast(BaseObject o) -> GFArchive
|
|
GFArchive_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> GFArchive
|
|
"""
|
|
return _io.GFArchive_ConstCast(*args)
|
|
|
|
def GFArchive_Create(service):
|
|
r"""GFArchive_Create(char const * service) -> GFArchive"""
|
|
return _io.GFArchive_Create(service)
|
|
|
|
def GFArchive_Open(url):
|
|
r"""GFArchive_Open(char const * url) -> GFArchive"""
|
|
return _io.GFArchive_Open(url)
|
|
|
|
class RecordStream(object):
|
|
r"""Proxy of C++ Seiscomp::IO::RecordStream class."""
|
|
|
|
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
|
|
|
|
@staticmethod
|
|
def ClassName():
|
|
r"""ClassName() -> char const *"""
|
|
return _io.RecordStream_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _io.RecordStream_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(RecordStream self) -> char const *"""
|
|
return _io.RecordStream_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(RecordStream self) -> RTTI"""
|
|
return _io.RecordStream_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> RecordStream
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> RecordStream
|
|
"""
|
|
return _io.RecordStream_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> RecordStream
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RecordStream
|
|
"""
|
|
return _io.RecordStream_ConstCast(*args)
|
|
__swig_destroy__ = _io.delete_RecordStream
|
|
|
|
def setSource(self, source):
|
|
r"""setSource(RecordStream self, string source) -> bool"""
|
|
return _io.RecordStream_setSource(self, source)
|
|
|
|
def close(self):
|
|
r"""close(RecordStream self)"""
|
|
return _io.RecordStream_close(self)
|
|
|
|
def addStream(self, *args):
|
|
r"""
|
|
addStream(RecordStream self, string networkCode, string stationCode, string locationCode, string channelCode) -> bool
|
|
addStream(RecordStream self, string networkCode, string stationCode, string locationCode, string channelCode, Time startTime, Time endTime) -> bool
|
|
"""
|
|
return _io.RecordStream_addStream(self, *args)
|
|
|
|
def setStartTime(self, startTime):
|
|
r"""setStartTime(RecordStream self, Time startTime) -> bool"""
|
|
return _io.RecordStream_setStartTime(self, startTime)
|
|
|
|
def setEndTime(self, endTime):
|
|
r"""setEndTime(RecordStream self, Time endTime) -> bool"""
|
|
return _io.RecordStream_setEndTime(self, endTime)
|
|
|
|
def setTimeWindow(self, timeWindow):
|
|
r"""setTimeWindow(RecordStream self, Seiscomp::Core::TimeWindow const & timeWindow) -> bool"""
|
|
return _io.RecordStream_setTimeWindow(self, timeWindow)
|
|
|
|
def setTimeout(self, seconds):
|
|
r"""setTimeout(RecordStream self, int seconds) -> bool"""
|
|
return _io.RecordStream_setTimeout(self, seconds)
|
|
|
|
def setRecordType(self, type):
|
|
r"""setRecordType(RecordStream self, char const * type) -> bool"""
|
|
return _io.RecordStream_setRecordType(self, type)
|
|
|
|
def setDataType(self, dataType):
|
|
r"""setDataType(RecordStream self, Seiscomp::Array::DataType dataType)"""
|
|
return _io.RecordStream_setDataType(self, dataType)
|
|
|
|
def setDataHint(self, hint):
|
|
r"""setDataHint(RecordStream self, Seiscomp::Record::Hint hint)"""
|
|
return _io.RecordStream_setDataHint(self, hint)
|
|
|
|
def next(self):
|
|
r"""next(RecordStream self) -> Record"""
|
|
return _io.RecordStream_next(self)
|
|
|
|
@staticmethod
|
|
def Create(service):
|
|
r"""Create(char const * service) -> RecordStream"""
|
|
return _io.RecordStream_Create(service)
|
|
|
|
@staticmethod
|
|
def Open(url):
|
|
r"""Open(char const * url) -> RecordStream"""
|
|
return _io.RecordStream_Open(url)
|
|
|
|
# Register RecordStream in _io:
|
|
_io.RecordStream_swigregister(RecordStream)
|
|
|
|
def RecordStream_ClassName():
|
|
r"""RecordStream_ClassName() -> char const *"""
|
|
return _io.RecordStream_ClassName()
|
|
|
|
def RecordStream_TypeInfo():
|
|
r"""RecordStream_TypeInfo() -> RTTI"""
|
|
return _io.RecordStream_TypeInfo()
|
|
|
|
def RecordStream_Cast(*args):
|
|
r"""
|
|
RecordStream_Cast(BaseObject o) -> RecordStream
|
|
RecordStream_Cast(Seiscomp::Core::BaseObjectPtr o) -> RecordStream
|
|
"""
|
|
return _io.RecordStream_Cast(*args)
|
|
|
|
def RecordStream_ConstCast(*args):
|
|
r"""
|
|
RecordStream_ConstCast(BaseObject o) -> RecordStream
|
|
RecordStream_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RecordStream
|
|
"""
|
|
return _io.RecordStream_ConstCast(*args)
|
|
|
|
def RecordStream_Create(service):
|
|
r"""RecordStream_Create(char const * service) -> RecordStream"""
|
|
return _io.RecordStream_Create(service)
|
|
|
|
def RecordStream_Open(url):
|
|
r"""RecordStream_Open(char const * url) -> RecordStream"""
|
|
return _io.RecordStream_Open(url)
|
|
|
|
class RecordIterator(object):
|
|
r"""Proxy of C++ Seiscomp::IO::RecordIterator class."""
|
|
|
|
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):
|
|
r"""
|
|
__init__(RecordIterator self) -> RecordIterator
|
|
__init__(RecordIterator self, RecordIterator iter) -> RecordIterator
|
|
"""
|
|
_io.RecordIterator_swiginit(self, _io.new_RecordIterator(*args))
|
|
__swig_destroy__ = _io.delete_RecordIterator
|
|
|
|
def __ref__(self):
|
|
r"""__ref__(RecordIterator self) -> Record"""
|
|
return _io.RecordIterator___ref__(self)
|
|
|
|
def __ne__(self, iter):
|
|
r"""__ne__(RecordIterator self, RecordIterator iter) -> bool"""
|
|
return _io.RecordIterator___ne__(self, iter)
|
|
|
|
def __eq__(self, iter):
|
|
r"""__eq__(RecordIterator self, RecordIterator iter) -> bool"""
|
|
return _io.RecordIterator___eq__(self, iter)
|
|
|
|
def source(self):
|
|
r"""source(RecordIterator self) -> RecordInput"""
|
|
return _io.RecordIterator_source(self)
|
|
|
|
def current(self):
|
|
r"""current(RecordIterator self) -> Record"""
|
|
return _io.RecordIterator_current(self)
|
|
|
|
# Register RecordIterator in _io:
|
|
_io.RecordIterator_swigregister(RecordIterator)
|
|
|
|
class RecordInput(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::IO::RecordInput class."""
|
|
|
|
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):
|
|
r"""__init__(RecordInput self, RecordStream _in, Seiscomp::Array::DataType dt=DOUBLE, Seiscomp::Record::Hint h=SAVE_RAW) -> RecordInput"""
|
|
_io.RecordInput_swiginit(self, _io.new_RecordInput(*args))
|
|
|
|
def begin(self):
|
|
r"""begin(RecordInput self) -> RecordIterator"""
|
|
return _io.RecordInput_begin(self)
|
|
|
|
def end(self):
|
|
r"""end(RecordInput self) -> RecordIterator"""
|
|
return _io.RecordInput_end(self)
|
|
|
|
def next(self):
|
|
r"""next(RecordInput self) -> Record"""
|
|
return _io.RecordInput_next(self)
|
|
|
|
def __iter__(self):
|
|
while 1:
|
|
rec = self.next()
|
|
if not rec:
|
|
return
|
|
yield rec
|
|
|
|
def __next__(self):
|
|
rec = self.next()
|
|
if not rec:
|
|
return
|
|
return rec
|
|
|
|
## for Python 2 compatibility
|
|
#def next(self):
|
|
# return self.__next__()
|
|
|
|
__swig_destroy__ = _io.delete_RecordInput
|
|
|
|
# Register RecordInput in _io:
|
|
_io.RecordInput_swigregister(RecordInput)
|
|
|
|
class RecordFilterInterface(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::IO::RecordFilterInterface class."""
|
|
|
|
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__ = _io.delete_RecordFilterInterface
|
|
|
|
def feed(self, rec):
|
|
r"""feed(RecordFilterInterface self, Record rec) -> Record"""
|
|
return _io.RecordFilterInterface_feed(self, rec)
|
|
|
|
def flush(self):
|
|
r"""flush(RecordFilterInterface self) -> Record"""
|
|
return _io.RecordFilterInterface_flush(self)
|
|
|
|
def reset(self):
|
|
r"""reset(RecordFilterInterface self)"""
|
|
return _io.RecordFilterInterface_reset(self)
|
|
|
|
def clone(self):
|
|
r"""clone(RecordFilterInterface self) -> RecordFilterInterface"""
|
|
return _io.RecordFilterInterface_clone(self)
|
|
|
|
# Register RecordFilterInterface in _io:
|
|
_io.RecordFilterInterface_swigregister(RecordFilterInterface)
|
|
|
|
class RecordDemuxFilter(RecordFilterInterface):
|
|
r"""Proxy of C++ Seiscomp::IO::RecordDemuxFilter class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, recordFilter=None):
|
|
r"""__init__(RecordDemuxFilter self, RecordFilterInterface recordFilter=None) -> RecordDemuxFilter"""
|
|
_io.RecordDemuxFilter_swiginit(self, _io.new_RecordDemuxFilter(recordFilter))
|
|
__swig_destroy__ = _io.delete_RecordDemuxFilter
|
|
|
|
def setFilter(self, recordFilter):
|
|
r"""setFilter(RecordDemuxFilter self, RecordFilterInterface recordFilter)"""
|
|
return _io.RecordDemuxFilter_setFilter(self, recordFilter)
|
|
|
|
def feed(self, rec):
|
|
r"""feed(RecordDemuxFilter self, Record rec) -> Record"""
|
|
return _io.RecordDemuxFilter_feed(self, rec)
|
|
|
|
def flush(self):
|
|
r"""flush(RecordDemuxFilter self) -> Record"""
|
|
return _io.RecordDemuxFilter_flush(self)
|
|
|
|
def reset(self):
|
|
r"""reset(RecordDemuxFilter self)"""
|
|
return _io.RecordDemuxFilter_reset(self)
|
|
|
|
def clone(self):
|
|
r"""clone(RecordDemuxFilter self) -> RecordFilterInterface"""
|
|
return _io.RecordDemuxFilter_clone(self)
|
|
|
|
# Register RecordDemuxFilter in _io:
|
|
_io.RecordDemuxFilter_swigregister(RecordDemuxFilter)
|
|
|
|
class RecordResamplerBase(RecordFilterInterface):
|
|
r"""Proxy of C++ Seiscomp::IO::RecordResamplerBase class."""
|
|
|
|
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 flush(self):
|
|
r"""flush(RecordResamplerBase self) -> Record"""
|
|
return _io.RecordResamplerBase_flush(self)
|
|
|
|
def reset(self):
|
|
r"""reset(RecordResamplerBase self)"""
|
|
return _io.RecordResamplerBase_reset(self)
|
|
|
|
# Register RecordResamplerBase in _io:
|
|
_io.RecordResamplerBase_swigregister(RecordResamplerBase)
|
|
|
|
class RecordStreamException(seiscomp.core.StreamException):
|
|
r"""Proxy of C++ Seiscomp::IO::RecordStreamException class."""
|
|
|
|
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):
|
|
r"""
|
|
__init__(RecordStreamException self) -> RecordStreamException
|
|
__init__(RecordStreamException self, string what) -> RecordStreamException
|
|
"""
|
|
_io.RecordStreamException_swiginit(self, _io.new_RecordStreamException(*args))
|
|
__swig_destroy__ = _io.delete_RecordStreamException
|
|
|
|
# Register RecordStreamException in _io:
|
|
_io.RecordStreamException_swigregister(RecordStreamException)
|
|
|
|
class RecordStreamTimeout(RecordStreamException):
|
|
r"""Proxy of C++ Seiscomp::IO::RecordStreamTimeout class."""
|
|
|
|
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):
|
|
r"""
|
|
__init__(RecordStreamTimeout self) -> RecordStreamTimeout
|
|
__init__(RecordStreamTimeout self, string what) -> RecordStreamTimeout
|
|
"""
|
|
_io.RecordStreamTimeout_swiginit(self, _io.new_RecordStreamTimeout(*args))
|
|
__swig_destroy__ = _io.delete_RecordStreamTimeout
|
|
|
|
# Register RecordStreamTimeout in _io:
|
|
_io.RecordStreamTimeout_swigregister(RecordStreamTimeout)
|
|
|
|
class Importer(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::IO::Importer class."""
|
|
|
|
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
|
|
|
|
@staticmethod
|
|
def ClassName():
|
|
r"""ClassName() -> char const *"""
|
|
return _io.Importer_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _io.Importer_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Importer self) -> char const *"""
|
|
return _io.Importer_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Importer self) -> RTTI"""
|
|
return _io.Importer_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Importer
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Importer
|
|
"""
|
|
return _io.Importer_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Importer
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Importer
|
|
"""
|
|
return _io.Importer_ConstCast(*args)
|
|
__swig_destroy__ = _io.delete_Importer
|
|
|
|
@staticmethod
|
|
def Create(type):
|
|
r"""Create(char const * type) -> Importer"""
|
|
return _io.Importer_Create(type)
|
|
|
|
def read(self, *args):
|
|
r"""
|
|
read(Importer self, std::streambuf * buf) -> BaseObject
|
|
read(Importer self, string filename) -> BaseObject
|
|
"""
|
|
return _io.Importer_read(self, *args)
|
|
|
|
def withoutErrors(self):
|
|
r"""withoutErrors(Importer self) -> bool"""
|
|
return _io.Importer_withoutErrors(self)
|
|
|
|
# Register Importer in _io:
|
|
_io.Importer_swigregister(Importer)
|
|
|
|
def Importer_ClassName():
|
|
r"""Importer_ClassName() -> char const *"""
|
|
return _io.Importer_ClassName()
|
|
|
|
def Importer_TypeInfo():
|
|
r"""Importer_TypeInfo() -> RTTI"""
|
|
return _io.Importer_TypeInfo()
|
|
|
|
def Importer_Cast(*args):
|
|
r"""
|
|
Importer_Cast(BaseObject o) -> Importer
|
|
Importer_Cast(Seiscomp::Core::BaseObjectPtr o) -> Importer
|
|
"""
|
|
return _io.Importer_Cast(*args)
|
|
|
|
def Importer_ConstCast(*args):
|
|
r"""
|
|
Importer_ConstCast(BaseObject o) -> Importer
|
|
Importer_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Importer
|
|
"""
|
|
return _io.Importer_ConstCast(*args)
|
|
|
|
def Importer_Create(type):
|
|
r"""Importer_Create(char const * type) -> Importer"""
|
|
return _io.Importer_Create(type)
|
|
|
|
class ExportSink(object):
|
|
r"""Proxy of C++ Seiscomp::IO::ExportSink class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _io.delete_ExportSink
|
|
|
|
def write(self, data):
|
|
r"""write(ExportSink self, char const * data) -> int"""
|
|
return _io.ExportSink_write(self, data)
|
|
|
|
def __init__(self):
|
|
r"""__init__(ExportSink self) -> ExportSink"""
|
|
if self.__class__ == ExportSink:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_io.ExportSink_swiginit(self, _io.new_ExportSink(_self, ))
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_io.disown_ExportSink(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register ExportSink in _io:
|
|
_io.ExportSink_swigregister(ExportSink)
|
|
|
|
class Exporter(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::IO::Exporter class."""
|
|
|
|
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
|
|
|
|
@staticmethod
|
|
def ClassName():
|
|
r"""ClassName() -> char const *"""
|
|
return _io.Exporter_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _io.Exporter_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Exporter self) -> char const *"""
|
|
return _io.Exporter_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Exporter self) -> RTTI"""
|
|
return _io.Exporter_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Exporter
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Exporter
|
|
"""
|
|
return _io.Exporter_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Exporter
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Exporter
|
|
"""
|
|
return _io.Exporter_ConstCast(*args)
|
|
__swig_destroy__ = _io.delete_Exporter
|
|
|
|
@staticmethod
|
|
def Create(type):
|
|
r"""Create(char const * type) -> Exporter"""
|
|
return _io.Exporter_Create(type)
|
|
|
|
def setFormattedOutput(self, enable):
|
|
r"""setFormattedOutput(Exporter self, bool enable)"""
|
|
return _io.Exporter_setFormattedOutput(self, enable)
|
|
|
|
def setIndent(self, arg2):
|
|
r"""setIndent(Exporter self, int arg2)"""
|
|
return _io.Exporter_setIndent(self, arg2)
|
|
|
|
def write(self, *args):
|
|
r"""
|
|
write(Exporter self, std::streambuf * buf, BaseObject arg3) -> bool
|
|
write(Exporter self, string filename, BaseObject arg3) -> bool
|
|
write(Exporter self, ExportSink sink, BaseObject arg3) -> bool
|
|
write(Exporter self, std::streambuf * buf, ExportObjectList objects) -> bool
|
|
write(Exporter self, string filename, ExportObjectList objects) -> bool
|
|
write(Exporter self, ExportSink sink, ExportObjectList objects) -> bool
|
|
"""
|
|
return _io.Exporter_write(self, *args)
|
|
|
|
# Register Exporter in _io:
|
|
_io.Exporter_swigregister(Exporter)
|
|
|
|
def Exporter_ClassName():
|
|
r"""Exporter_ClassName() -> char const *"""
|
|
return _io.Exporter_ClassName()
|
|
|
|
def Exporter_TypeInfo():
|
|
r"""Exporter_TypeInfo() -> RTTI"""
|
|
return _io.Exporter_TypeInfo()
|
|
|
|
def Exporter_Cast(*args):
|
|
r"""
|
|
Exporter_Cast(BaseObject o) -> Exporter
|
|
Exporter_Cast(Seiscomp::Core::BaseObjectPtr o) -> Exporter
|
|
"""
|
|
return _io.Exporter_Cast(*args)
|
|
|
|
def Exporter_ConstCast(*args):
|
|
r"""
|
|
Exporter_ConstCast(BaseObject o) -> Exporter
|
|
Exporter_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Exporter
|
|
"""
|
|
return _io.Exporter_ConstCast(*args)
|
|
|
|
def Exporter_Create(type):
|
|
r"""Exporter_Create(char const * type) -> Exporter"""
|
|
return _io.Exporter_Create(type)
|
|
|
|
class XMLArchive(seiscomp.core.GenericArchive):
|
|
r"""Proxy of C++ Seiscomp::IO::XMLArchive class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
ZIP = _io.XMLArchive_ZIP
|
|
|
|
GZIP = _io.XMLArchive_GZIP
|
|
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(XMLArchive self) -> XMLArchive
|
|
__init__(XMLArchive self, std::streambuf * buf, bool isReading=True, int forceWriteVersion=-1) -> XMLArchive
|
|
"""
|
|
_io.XMLArchive_swiginit(self, _io.new_XMLArchive(*args))
|
|
__swig_destroy__ = _io.delete_XMLArchive
|
|
|
|
def open(self, *args):
|
|
r"""
|
|
open(XMLArchive self, std::streambuf * arg2) -> bool
|
|
open(XMLArchive self, char const * filename) -> bool
|
|
"""
|
|
return _io.XMLArchive_open(self, *args)
|
|
|
|
def create(self, *args):
|
|
r"""
|
|
create(XMLArchive self, std::streambuf * buf, bool writeVersion=True, bool headerNode=True) -> bool
|
|
create(XMLArchive self, char const * filename, bool writeVersion=True, bool headerNode=True) -> bool
|
|
"""
|
|
return _io.XMLArchive_create(self, *args)
|
|
|
|
def close(self):
|
|
r"""close(XMLArchive self)"""
|
|
return _io.XMLArchive_close(self)
|
|
|
|
def setRootName(self, name):
|
|
r"""setRootName(XMLArchive self, string name)"""
|
|
return _io.XMLArchive_setRootName(self, name)
|
|
|
|
def setFormattedOutput(self, enable):
|
|
r"""setFormattedOutput(XMLArchive self, bool enable)"""
|
|
return _io.XMLArchive_setFormattedOutput(self, enable)
|
|
|
|
def setCompression(self, enable):
|
|
r"""setCompression(XMLArchive self, bool enable)"""
|
|
return _io.XMLArchive_setCompression(self, enable)
|
|
|
|
def setCompressionMethod(self, method):
|
|
r"""setCompressionMethod(XMLArchive self, Seiscomp::IO::XMLArchive::CompressionMethod method)"""
|
|
return _io.XMLArchive_setCompressionMethod(self, method)
|
|
|
|
def rootNamespace(self):
|
|
r"""rootNamespace(XMLArchive self) -> string"""
|
|
return _io.XMLArchive_rootNamespace(self)
|
|
|
|
def rootNamespaceUri(self):
|
|
r"""rootNamespaceUri(XMLArchive self) -> string"""
|
|
return _io.XMLArchive_rootNamespaceUri(self)
|
|
|
|
def setRootNamespace(self, name, uri):
|
|
r"""setRootNamespace(XMLArchive self, string name, string uri)"""
|
|
return _io.XMLArchive_setRootNamespace(self, name, uri)
|
|
|
|
def read(self, *args):
|
|
r"""
|
|
read(XMLArchive self, std::int8_t & value)
|
|
read(XMLArchive self, std::int16_t & value)
|
|
read(XMLArchive self, std::int32_t & value)
|
|
read(XMLArchive self, std::int64_t & value)
|
|
read(XMLArchive self, float & value)
|
|
read(XMLArchive self, double & value)
|
|
read(XMLArchive self, std::vector< char,std::allocator< char > > & value)
|
|
read(XMLArchive self, std::vector< int8_t,std::allocator< int8_t > > & value)
|
|
read(XMLArchive self, std::vector< int16_t,std::allocator< int16_t > > & value)
|
|
read(XMLArchive self, std::vector< int32_t,std::allocator< int32_t > > & value)
|
|
read(XMLArchive self, std::vector< int64_t,std::allocator< int64_t > > & value)
|
|
read(XMLArchive self, vectorf value)
|
|
read(XMLArchive self, vectord value)
|
|
read(XMLArchive self, std::vector< std::string,std::allocator< std::string > > & value)
|
|
read(XMLArchive self, std::vector< Seiscomp::Core::Time,std::allocator< Seiscomp::Core::Time > > & value)
|
|
read(XMLArchive self, std::complex< float > & value)
|
|
read(XMLArchive self, std::complex< double > & value)
|
|
read(XMLArchive self, bool & value)
|
|
read(XMLArchive self, vectorc value)
|
|
read(XMLArchive self, string value)
|
|
read(XMLArchive self, Time value)
|
|
"""
|
|
return _io.XMLArchive_read(self, *args)
|
|
|
|
def write(self, *args):
|
|
r"""
|
|
write(XMLArchive self, std::int8_t value)
|
|
write(XMLArchive self, std::int16_t value)
|
|
write(XMLArchive self, std::int32_t value)
|
|
write(XMLArchive self, std::int64_t value)
|
|
write(XMLArchive self, float value)
|
|
write(XMLArchive self, double value)
|
|
write(XMLArchive self, std::vector< char,std::allocator< char > > & value)
|
|
write(XMLArchive self, std::vector< int8_t,std::allocator< int8_t > > & value)
|
|
write(XMLArchive self, std::vector< int16_t,std::allocator< int16_t > > & value)
|
|
write(XMLArchive self, std::vector< int32_t,std::allocator< int32_t > > & value)
|
|
write(XMLArchive self, std::vector< int64_t,std::allocator< int64_t > > & value)
|
|
write(XMLArchive self, vectorf value)
|
|
write(XMLArchive self, vectord value)
|
|
write(XMLArchive self, std::vector< std::string,std::allocator< std::string > > & value)
|
|
write(XMLArchive self, std::vector< Seiscomp::Core::Time,std::allocator< Seiscomp::Core::Time > > & value)
|
|
write(XMLArchive self, std::complex< float > & value)
|
|
write(XMLArchive self, std::complex< double > & value)
|
|
write(XMLArchive self, bool value)
|
|
write(XMLArchive self, vectorc value)
|
|
write(XMLArchive self, string value)
|
|
write(XMLArchive self, Time value)
|
|
"""
|
|
return _io.XMLArchive_write(self, *args)
|
|
|
|
# Register XMLArchive in _io:
|
|
_io.XMLArchive_swigregister(XMLArchive)
|
|
|
|
class BinaryArchive(seiscomp.core.GenericArchive):
|
|
r"""Proxy of C++ Seiscomp::IO::BinaryArchive class."""
|
|
|
|
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):
|
|
r"""
|
|
__init__(BinaryArchive self) -> BinaryArchive
|
|
__init__(BinaryArchive self, std::streambuf * buf, bool isReading=True) -> BinaryArchive
|
|
"""
|
|
_io.BinaryArchive_swiginit(self, _io.new_BinaryArchive(*args))
|
|
__swig_destroy__ = _io.delete_BinaryArchive
|
|
|
|
def open(self, *args):
|
|
r"""
|
|
open(BinaryArchive self, char const * file) -> bool
|
|
open(BinaryArchive self, std::streambuf * arg2) -> bool
|
|
"""
|
|
return _io.BinaryArchive_open(self, *args)
|
|
|
|
def create(self, *args):
|
|
r"""
|
|
create(BinaryArchive self, char const * file) -> bool
|
|
create(BinaryArchive self, std::streambuf * arg2) -> bool
|
|
"""
|
|
return _io.BinaryArchive_create(self, *args)
|
|
|
|
def close(self):
|
|
r"""close(BinaryArchive self)"""
|
|
return _io.BinaryArchive_close(self)
|
|
|
|
def read(self, *args):
|
|
r"""
|
|
read(BinaryArchive self, std::int8_t & value)
|
|
read(BinaryArchive self, std::int16_t & value)
|
|
read(BinaryArchive self, std::int32_t & value)
|
|
read(BinaryArchive self, std::int64_t & value)
|
|
read(BinaryArchive self, float & value)
|
|
read(BinaryArchive self, double & value)
|
|
read(BinaryArchive self, std::vector< char,std::allocator< char > > & value)
|
|
read(BinaryArchive self, std::vector< int8_t,std::allocator< int8_t > > & value)
|
|
read(BinaryArchive self, std::vector< int16_t,std::allocator< int16_t > > & value)
|
|
read(BinaryArchive self, std::vector< int32_t,std::allocator< int32_t > > & value)
|
|
read(BinaryArchive self, std::vector< int64_t,std::allocator< int64_t > > & value)
|
|
read(BinaryArchive self, vectorf value)
|
|
read(BinaryArchive self, vectord value)
|
|
read(BinaryArchive self, std::vector< std::string,std::allocator< std::string > > & value)
|
|
read(BinaryArchive self, std::vector< Seiscomp::Core::Time,std::allocator< Seiscomp::Core::Time > > & value)
|
|
read(BinaryArchive self, std::complex< float > & value)
|
|
read(BinaryArchive self, std::complex< double > & value)
|
|
read(BinaryArchive self, bool & value)
|
|
read(BinaryArchive self, vectorc value)
|
|
read(BinaryArchive self, string value)
|
|
read(BinaryArchive self, Time value)
|
|
"""
|
|
return _io.BinaryArchive_read(self, *args)
|
|
|
|
def write(self, *args):
|
|
r"""
|
|
write(BinaryArchive self, std::int8_t value)
|
|
write(BinaryArchive self, std::int16_t value)
|
|
write(BinaryArchive self, std::int32_t value)
|
|
write(BinaryArchive self, std::int64_t value)
|
|
write(BinaryArchive self, float value)
|
|
write(BinaryArchive self, double value)
|
|
write(BinaryArchive self, std::vector< char,std::allocator< char > > & value)
|
|
write(BinaryArchive self, std::vector< int8_t,std::allocator< int8_t > > & value)
|
|
write(BinaryArchive self, std::vector< int16_t,std::allocator< int16_t > > & value)
|
|
write(BinaryArchive self, std::vector< int32_t,std::allocator< int32_t > > & value)
|
|
write(BinaryArchive self, std::vector< int64_t,std::allocator< int64_t > > & value)
|
|
write(BinaryArchive self, vectorf value)
|
|
write(BinaryArchive self, vectord value)
|
|
write(BinaryArchive self, std::vector< std::string,std::allocator< std::string > > & value)
|
|
write(BinaryArchive self, std::vector< Seiscomp::Core::Time,std::allocator< Seiscomp::Core::Time > > & value)
|
|
write(BinaryArchive self, std::complex< float > & value)
|
|
write(BinaryArchive self, std::complex< double > & value)
|
|
write(BinaryArchive self, bool value)
|
|
write(BinaryArchive self, vectorc value)
|
|
write(BinaryArchive self, string value)
|
|
write(BinaryArchive self, Time value)
|
|
"""
|
|
return _io.BinaryArchive_write(self, *args)
|
|
|
|
# Register BinaryArchive in _io:
|
|
_io.BinaryArchive_swigregister(BinaryArchive)
|
|
|
|
class VBinaryArchive(BinaryArchive):
|
|
r"""Proxy of C++ Seiscomp::IO::VBinaryArchive class."""
|
|
|
|
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):
|
|
r"""
|
|
__init__(VBinaryArchive self, int forceWriteVersion=-1) -> VBinaryArchive
|
|
__init__(VBinaryArchive self, std::streambuf * buf, bool isReading=True, int forceWriteVersion=-1) -> VBinaryArchive
|
|
"""
|
|
_io.VBinaryArchive_swiginit(self, _io.new_VBinaryArchive(*args))
|
|
|
|
def setWriteVersion(self, version):
|
|
r"""setWriteVersion(VBinaryArchive self, int version)"""
|
|
return _io.VBinaryArchive_setWriteVersion(self, version)
|
|
|
|
def open(self, *args):
|
|
r"""
|
|
open(VBinaryArchive self, char const * file) -> bool
|
|
open(VBinaryArchive self, std::streambuf * arg2) -> bool
|
|
"""
|
|
return _io.VBinaryArchive_open(self, *args)
|
|
|
|
def create(self, *args):
|
|
r"""
|
|
create(VBinaryArchive self, char const * file) -> bool
|
|
create(VBinaryArchive self, std::streambuf * arg2) -> bool
|
|
"""
|
|
return _io.VBinaryArchive_create(self, *args)
|
|
|
|
def close(self):
|
|
r"""close(VBinaryArchive self)"""
|
|
return _io.VBinaryArchive_close(self)
|
|
|
|
def errorMsg(self):
|
|
r"""errorMsg(VBinaryArchive self) -> char const *"""
|
|
return _io.VBinaryArchive_errorMsg(self)
|
|
__swig_destroy__ = _io.delete_VBinaryArchive
|
|
|
|
# Register VBinaryArchive in _io:
|
|
_io.VBinaryArchive_swigregister(VBinaryArchive)
|
|
|
|
class LibmseedException(seiscomp.core.StreamException):
|
|
r"""Proxy of C++ Seiscomp::IO::LibmseedException class."""
|
|
|
|
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):
|
|
r"""
|
|
__init__(LibmseedException self) -> LibmseedException
|
|
__init__(LibmseedException self, string what) -> LibmseedException
|
|
"""
|
|
_io.LibmseedException_swiginit(self, _io.new_LibmseedException(*args))
|
|
__swig_destroy__ = _io.delete_LibmseedException
|
|
|
|
# Register LibmseedException in _io:
|
|
_io.LibmseedException_swigregister(LibmseedException)
|
|
|
|
class MSeedRecord(seiscomp.core.Record):
|
|
r"""Proxy of C++ Seiscomp::IO::MSeedRecord class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def ClassName():
|
|
r"""ClassName() -> char const *"""
|
|
return _io.MSeedRecord_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _io.MSeedRecord_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(MSeedRecord self) -> char const *"""
|
|
return _io.MSeedRecord_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(MSeedRecord self) -> RTTI"""
|
|
return _io.MSeedRecord_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> MSeedRecord
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> MSeedRecord
|
|
"""
|
|
return _io.MSeedRecord_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> MSeedRecord
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MSeedRecord
|
|
"""
|
|
return _io.MSeedRecord_ConstCast(*args)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(MSeedRecord self, Seiscomp::Array::DataType dt=DOUBLE, Seiscomp::Record::Hint h=SAVE_RAW) -> MSeedRecord
|
|
__init__(MSeedRecord self, MSRecord * msrec, Seiscomp::Array::DataType dt=DOUBLE, Seiscomp::Record::Hint h=SAVE_RAW) -> MSeedRecord
|
|
__init__(MSeedRecord self, MSeedRecord ms) -> MSeedRecord
|
|
__init__(MSeedRecord self, Record rec, int reclen=512) -> MSeedRecord
|
|
"""
|
|
_io.MSeedRecord_swiginit(self, _io.new_MSeedRecord(*args))
|
|
__swig_destroy__ = _io.delete_MSeedRecord
|
|
|
|
def setNetworkCode(self, net):
|
|
r"""setNetworkCode(MSeedRecord self, string net)"""
|
|
return _io.MSeedRecord_setNetworkCode(self, net)
|
|
|
|
def setStationCode(self, sta):
|
|
r"""setStationCode(MSeedRecord self, string sta)"""
|
|
return _io.MSeedRecord_setStationCode(self, sta)
|
|
|
|
def setLocationCode(self, loc):
|
|
r"""setLocationCode(MSeedRecord self, string loc)"""
|
|
return _io.MSeedRecord_setLocationCode(self, loc)
|
|
|
|
def setChannelCode(self, cha):
|
|
r"""setChannelCode(MSeedRecord self, string cha)"""
|
|
return _io.MSeedRecord_setChannelCode(self, cha)
|
|
|
|
def setStartTime(self, time):
|
|
r"""setStartTime(MSeedRecord self, Time time)"""
|
|
return _io.MSeedRecord_setStartTime(self, time)
|
|
|
|
def sequenceNumber(self):
|
|
r"""sequenceNumber(MSeedRecord self) -> int"""
|
|
return _io.MSeedRecord_sequenceNumber(self)
|
|
|
|
def setSequenceNumber(self, seqno):
|
|
r"""setSequenceNumber(MSeedRecord self, int seqno)"""
|
|
return _io.MSeedRecord_setSequenceNumber(self, seqno)
|
|
|
|
def dataQuality(self):
|
|
r"""dataQuality(MSeedRecord self) -> char"""
|
|
return _io.MSeedRecord_dataQuality(self)
|
|
|
|
def setDataQuality(self, qual):
|
|
r"""setDataQuality(MSeedRecord self, char qual)"""
|
|
return _io.MSeedRecord_setDataQuality(self, qual)
|
|
|
|
def sampleRateFactor(self):
|
|
r"""sampleRateFactor(MSeedRecord self) -> int"""
|
|
return _io.MSeedRecord_sampleRateFactor(self)
|
|
|
|
def setSampleRateFactor(self, srfact):
|
|
r"""setSampleRateFactor(MSeedRecord self, int srfact)"""
|
|
return _io.MSeedRecord_setSampleRateFactor(self, srfact)
|
|
|
|
def sampleRateMultiplier(self):
|
|
r"""sampleRateMultiplier(MSeedRecord self) -> int"""
|
|
return _io.MSeedRecord_sampleRateMultiplier(self)
|
|
|
|
def setSampleRateMultiplier(self, srmult):
|
|
r"""setSampleRateMultiplier(MSeedRecord self, int srmult)"""
|
|
return _io.MSeedRecord_setSampleRateMultiplier(self, srmult)
|
|
|
|
def byteOrder(self):
|
|
r"""byteOrder(MSeedRecord self) -> int8_t"""
|
|
return _io.MSeedRecord_byteOrder(self)
|
|
|
|
def encoding(self):
|
|
r"""encoding(MSeedRecord self) -> int8_t"""
|
|
return _io.MSeedRecord_encoding(self)
|
|
|
|
def sampleRateNumerator(self):
|
|
r"""sampleRateNumerator(MSeedRecord self) -> int"""
|
|
return _io.MSeedRecord_sampleRateNumerator(self)
|
|
|
|
def sampleRateDenominator(self):
|
|
r"""sampleRateDenominator(MSeedRecord self) -> int"""
|
|
return _io.MSeedRecord_sampleRateDenominator(self)
|
|
|
|
def frameNumber(self):
|
|
r"""frameNumber(MSeedRecord self) -> int"""
|
|
return _io.MSeedRecord_frameNumber(self)
|
|
|
|
def endTime(self):
|
|
r"""endTime(MSeedRecord self) -> Time"""
|
|
return _io.MSeedRecord_endTime(self)
|
|
|
|
def recordLength(self):
|
|
r"""recordLength(MSeedRecord self) -> int"""
|
|
return _io.MSeedRecord_recordLength(self)
|
|
|
|
def leapSeconds(self):
|
|
r"""leapSeconds(MSeedRecord self) -> int"""
|
|
return _io.MSeedRecord_leapSeconds(self)
|
|
|
|
def data(self):
|
|
r"""data(MSeedRecord self) -> Array"""
|
|
return _io.MSeedRecord_data(self)
|
|
|
|
def raw(self):
|
|
r"""raw(MSeedRecord self) -> Array"""
|
|
return _io.MSeedRecord_raw(self)
|
|
|
|
def saveSpace(self):
|
|
r"""saveSpace(MSeedRecord self)"""
|
|
return _io.MSeedRecord_saveSpace(self)
|
|
|
|
def copy(self):
|
|
r"""copy(MSeedRecord self) -> Record"""
|
|
return _io.MSeedRecord_copy(self)
|
|
|
|
def useEncoding(self, flag):
|
|
r"""useEncoding(MSeedRecord self, bool flag)"""
|
|
return _io.MSeedRecord_useEncoding(self, flag)
|
|
|
|
def setOutputRecordLength(self, reclen):
|
|
r"""setOutputRecordLength(MSeedRecord self, int reclen)"""
|
|
return _io.MSeedRecord_setOutputRecordLength(self, reclen)
|
|
|
|
def read(self, _in):
|
|
r"""read(MSeedRecord self, std::istream & _in)"""
|
|
return _io.MSeedRecord_read(self, _in)
|
|
|
|
def write(self, out):
|
|
r"""write(MSeedRecord self, std::ostream & out)"""
|
|
return _io.MSeedRecord_write(self, out)
|
|
|
|
# Register MSeedRecord in _io:
|
|
_io.MSeedRecord_swigregister(MSeedRecord)
|
|
|
|
def MSeedRecord_ClassName():
|
|
r"""MSeedRecord_ClassName() -> char const *"""
|
|
return _io.MSeedRecord_ClassName()
|
|
|
|
def MSeedRecord_TypeInfo():
|
|
r"""MSeedRecord_TypeInfo() -> RTTI"""
|
|
return _io.MSeedRecord_TypeInfo()
|
|
|
|
def MSeedRecord_Cast(*args):
|
|
r"""
|
|
MSeedRecord_Cast(BaseObject o) -> MSeedRecord
|
|
MSeedRecord_Cast(Seiscomp::Core::BaseObjectPtr o) -> MSeedRecord
|
|
"""
|
|
return _io.MSeedRecord_Cast(*args)
|
|
|
|
def MSeedRecord_ConstCast(*args):
|
|
r"""
|
|
MSeedRecord_ConstCast(BaseObject o) -> MSeedRecord
|
|
MSeedRecord_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MSeedRecord
|
|
"""
|
|
return _io.MSeedRecord_ConstCast(*args)
|
|
|
|
class FileRecordStream(RecordStream):
|
|
r"""Proxy of C++ Seiscomp::RecordStream::File class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
Begin = _io.FileRecordStream_Begin
|
|
|
|
Current = _io.FileRecordStream_Current
|
|
|
|
End = _io.FileRecordStream_End
|
|
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
File() -> FileRecordStream
|
|
File(string name) -> FileRecordStream
|
|
__init__(FileRecordStream self, FileRecordStream f) -> FileRecordStream
|
|
"""
|
|
_io.FileRecordStream_swiginit(self, _io.new_FileRecordStream(*args))
|
|
__swig_destroy__ = _io.delete_FileRecordStream
|
|
|
|
def setSource(self, filename):
|
|
r"""setSource(FileRecordStream self, string filename) -> bool"""
|
|
return _io.FileRecordStream_setSource(self, filename)
|
|
|
|
def addStream(self, *args):
|
|
r"""
|
|
addStream(FileRecordStream self, string networkCode, string stationCode, string locationCode, string channelCode) -> bool
|
|
addStream(FileRecordStream self, string networkCode, string stationCode, string locationCode, string channelCode, Time startTime, Time endTime) -> bool
|
|
"""
|
|
return _io.FileRecordStream_addStream(self, *args)
|
|
|
|
def setStartTime(self, startTime):
|
|
r"""setStartTime(FileRecordStream self, Time startTime) -> bool"""
|
|
return _io.FileRecordStream_setStartTime(self, startTime)
|
|
|
|
def setEndTime(self, endTime):
|
|
r"""setEndTime(FileRecordStream self, Time endTime) -> bool"""
|
|
return _io.FileRecordStream_setEndTime(self, endTime)
|
|
|
|
def close(self):
|
|
r"""close(FileRecordStream self)"""
|
|
return _io.FileRecordStream_close(self)
|
|
|
|
def setRecordType(self, type):
|
|
r"""setRecordType(FileRecordStream self, char const * type) -> bool"""
|
|
return _io.FileRecordStream_setRecordType(self, type)
|
|
|
|
def next(self):
|
|
r"""next(FileRecordStream self) -> Record"""
|
|
return _io.FileRecordStream_next(self)
|
|
|
|
def name(self):
|
|
r"""name(FileRecordStream self) -> string"""
|
|
return _io.FileRecordStream_name(self)
|
|
|
|
def tell(self):
|
|
r"""tell(FileRecordStream self) -> size_t"""
|
|
return _io.FileRecordStream_tell(self)
|
|
|
|
def seek(self, *args):
|
|
r"""
|
|
seek(FileRecordStream self, size_t pos) -> FileRecordStream
|
|
seek(FileRecordStream self, int off, Seiscomp::RecordStream::File::SeekDir dir) -> FileRecordStream
|
|
"""
|
|
return _io.FileRecordStream_seek(self, *args)
|
|
|
|
# Register FileRecordStream in _io:
|
|
_io.FileRecordStream_swigregister(FileRecordStream)
|
|
|
|
class SeedlinkException(RecordStreamException):
|
|
r"""Proxy of C++ Seiscomp::RecordStream::SeedlinkException class."""
|
|
|
|
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):
|
|
r"""
|
|
__init__(SeedlinkException self) -> SeedlinkException
|
|
__init__(SeedlinkException self, string what) -> SeedlinkException
|
|
"""
|
|
_io.SeedlinkException_swiginit(self, _io.new_SeedlinkException(*args))
|
|
__swig_destroy__ = _io.delete_SeedlinkException
|
|
|
|
# Register SeedlinkException in _io:
|
|
_io.SeedlinkException_swigregister(SeedlinkException)
|
|
|
|
class SeedlinkCommandException(SeedlinkException):
|
|
r"""Proxy of C++ Seiscomp::RecordStream::SeedlinkCommandException class."""
|
|
|
|
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):
|
|
r"""
|
|
__init__(SeedlinkCommandException self) -> SeedlinkCommandException
|
|
__init__(SeedlinkCommandException self, string what) -> SeedlinkCommandException
|
|
"""
|
|
_io.SeedlinkCommandException_swiginit(self, _io.new_SeedlinkCommandException(*args))
|
|
__swig_destroy__ = _io.delete_SeedlinkCommandException
|
|
|
|
# Register SeedlinkCommandException in _io:
|
|
_io.SeedlinkCommandException_swigregister(SeedlinkCommandException)
|
|
|
|
class SLStreamIdx(object):
|
|
r"""Proxy of C++ Seiscomp::RecordStream::SLStreamIdx class."""
|
|
|
|
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):
|
|
r"""
|
|
__init__(SLStreamIdx self) -> SLStreamIdx
|
|
__init__(SLStreamIdx self, string net, string sta, string loc, string cha) -> SLStreamIdx
|
|
__init__(SLStreamIdx self, string net, string sta, string loc, string cha, Time stime, Time etime) -> SLStreamIdx
|
|
"""
|
|
_io.SLStreamIdx_swiginit(self, _io.new_SLStreamIdx(*args))
|
|
|
|
def __lt__(self, other):
|
|
r"""__lt__(SLStreamIdx self, SLStreamIdx other) -> bool"""
|
|
return _io.SLStreamIdx___lt__(self, other)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(SLStreamIdx self, SLStreamIdx other) -> bool"""
|
|
return _io.SLStreamIdx___eq__(self, other)
|
|
|
|
def network(self):
|
|
r"""network(SLStreamIdx self) -> string"""
|
|
return _io.SLStreamIdx_network(self)
|
|
|
|
def station(self):
|
|
r"""station(SLStreamIdx self) -> string"""
|
|
return _io.SLStreamIdx_station(self)
|
|
|
|
def channel(self):
|
|
r"""channel(SLStreamIdx self) -> string"""
|
|
return _io.SLStreamIdx_channel(self)
|
|
|
|
def location(self):
|
|
r"""location(SLStreamIdx self) -> string"""
|
|
return _io.SLStreamIdx_location(self)
|
|
|
|
def selector(self):
|
|
r"""selector(SLStreamIdx self) -> string"""
|
|
return _io.SLStreamIdx_selector(self)
|
|
|
|
def startTime(self):
|
|
r"""startTime(SLStreamIdx self) -> Time"""
|
|
return _io.SLStreamIdx_startTime(self)
|
|
|
|
def endTime(self):
|
|
r"""endTime(SLStreamIdx self) -> Time"""
|
|
return _io.SLStreamIdx_endTime(self)
|
|
|
|
def timestamp(self):
|
|
r"""timestamp(SLStreamIdx self) -> Time"""
|
|
return _io.SLStreamIdx_timestamp(self)
|
|
|
|
def setTimestamp(self, rectime):
|
|
r"""setTimestamp(SLStreamIdx self, Time rectime)"""
|
|
return _io.SLStreamIdx_setTimestamp(self, rectime)
|
|
__swig_destroy__ = _io.delete_SLStreamIdx
|
|
|
|
# Register SLStreamIdx in _io:
|
|
_io.SLStreamIdx_swigregister(SLStreamIdx)
|
|
|
|
class SLConnection(RecordStream):
|
|
r"""Proxy of C++ Seiscomp::RecordStream::SLConnection class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def ClassName():
|
|
r"""ClassName() -> char const *"""
|
|
return _io.SLConnection_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _io.SLConnection_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(SLConnection self) -> char const *"""
|
|
return _io.SLConnection_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(SLConnection self) -> RTTI"""
|
|
return _io.SLConnection_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> SLConnection
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> SLConnection
|
|
"""
|
|
return _io.SLConnection_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> SLConnection
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SLConnection
|
|
"""
|
|
return _io.SLConnection_ConstCast(*args)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(SLConnection self) -> SLConnection
|
|
__init__(SLConnection self, string serverloc) -> SLConnection
|
|
"""
|
|
_io.SLConnection_swiginit(self, _io.new_SLConnection(*args))
|
|
__swig_destroy__ = _io.delete_SLConnection
|
|
|
|
def setRecordType(self, arg2):
|
|
r"""setRecordType(SLConnection self, char const * arg2) -> bool"""
|
|
return _io.SLConnection_setRecordType(self, arg2)
|
|
|
|
def setSource(self, source):
|
|
r"""setSource(SLConnection self, string source) -> bool"""
|
|
return _io.SLConnection_setSource(self, source)
|
|
|
|
def addStream(self, *args):
|
|
r"""
|
|
addStream(SLConnection self, string networkCode, string stationCode, string locationCode, string channelCode) -> bool
|
|
addStream(SLConnection self, string networkCode, string stationCode, string locationCode, string channelCode, Time startTime, Time endTime) -> bool
|
|
"""
|
|
return _io.SLConnection_addStream(self, *args)
|
|
|
|
def setStartTime(self, startTime):
|
|
r"""setStartTime(SLConnection self, Time startTime) -> bool"""
|
|
return _io.SLConnection_setStartTime(self, startTime)
|
|
|
|
def setEndTime(self, endTime):
|
|
r"""setEndTime(SLConnection self, Time endTime) -> bool"""
|
|
return _io.SLConnection_setEndTime(self, endTime)
|
|
|
|
def setTimeout(self, seconds):
|
|
r"""setTimeout(SLConnection self, int seconds) -> bool"""
|
|
return _io.SLConnection_setTimeout(self, seconds)
|
|
|
|
def close(self):
|
|
r"""close(SLConnection self)"""
|
|
return _io.SLConnection_close(self)
|
|
|
|
def next(self):
|
|
r"""next(SLConnection self) -> Record"""
|
|
return _io.SLConnection_next(self)
|
|
|
|
def clear(self):
|
|
r"""clear(SLConnection self) -> bool"""
|
|
return _io.SLConnection_clear(self)
|
|
|
|
def reconnect(self):
|
|
r"""reconnect(SLConnection self) -> bool"""
|
|
return _io.SLConnection_reconnect(self)
|
|
|
|
# Register SLConnection in _io:
|
|
_io.SLConnection_swigregister(SLConnection)
|
|
|
|
def SLConnection_ClassName():
|
|
r"""SLConnection_ClassName() -> char const *"""
|
|
return _io.SLConnection_ClassName()
|
|
|
|
def SLConnection_TypeInfo():
|
|
r"""SLConnection_TypeInfo() -> RTTI"""
|
|
return _io.SLConnection_TypeInfo()
|
|
|
|
def SLConnection_Cast(*args):
|
|
r"""
|
|
SLConnection_Cast(BaseObject o) -> SLConnection
|
|
SLConnection_Cast(Seiscomp::Core::BaseObjectPtr o) -> SLConnection
|
|
"""
|
|
return _io.SLConnection_Cast(*args)
|
|
|
|
def SLConnection_ConstCast(*args):
|
|
r"""
|
|
SLConnection_ConstCast(BaseObject o) -> SLConnection
|
|
SLConnection_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SLConnection
|
|
"""
|
|
return _io.SLConnection_ConstCast(*args)
|
|
|
|
class ArclinkException(RecordStreamException):
|
|
r"""Proxy of C++ Seiscomp::RecordStream::Arclink::_private::ArclinkException class."""
|
|
|
|
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):
|
|
r"""
|
|
__init__(ArclinkException self) -> ArclinkException
|
|
__init__(ArclinkException self, string what) -> ArclinkException
|
|
"""
|
|
_io.ArclinkException_swiginit(self, _io.new_ArclinkException(*args))
|
|
__swig_destroy__ = _io.delete_ArclinkException
|
|
|
|
# Register ArclinkException in _io:
|
|
_io.ArclinkException_swigregister(ArclinkException)
|
|
|
|
class ArclinkCommandException(ArclinkException):
|
|
r"""Proxy of C++ Seiscomp::RecordStream::Arclink::_private::ArclinkCommandException class."""
|
|
|
|
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):
|
|
r"""
|
|
__init__(ArclinkCommandException self) -> ArclinkCommandException
|
|
__init__(ArclinkCommandException self, string what) -> ArclinkCommandException
|
|
"""
|
|
_io.ArclinkCommandException_swiginit(self, _io.new_ArclinkCommandException(*args))
|
|
__swig_destroy__ = _io.delete_ArclinkCommandException
|
|
|
|
# Register ArclinkCommandException in _io:
|
|
_io.ArclinkCommandException_swigregister(ArclinkCommandException)
|
|
|
|
class ArclinkConnection(RecordStream):
|
|
r"""Proxy of C++ Seiscomp::RecordStream::Arclink::_private::ArclinkConnection class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def ClassName():
|
|
r"""ClassName() -> char const *"""
|
|
return _io.ArclinkConnection_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _io.ArclinkConnection_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ArclinkConnection self) -> char const *"""
|
|
return _io.ArclinkConnection_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ArclinkConnection self) -> RTTI"""
|
|
return _io.ArclinkConnection_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ArclinkConnection
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkConnection
|
|
"""
|
|
return _io.ArclinkConnection_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ArclinkConnection
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkConnection
|
|
"""
|
|
return _io.ArclinkConnection_ConstCast(*args)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ArclinkConnection self) -> ArclinkConnection
|
|
__init__(ArclinkConnection self, string serverloc) -> ArclinkConnection
|
|
"""
|
|
_io.ArclinkConnection_swiginit(self, _io.new_ArclinkConnection(*args))
|
|
__swig_destroy__ = _io.delete_ArclinkConnection
|
|
|
|
def setRecordType(self, arg2):
|
|
r"""setRecordType(ArclinkConnection self, char const * arg2) -> bool"""
|
|
return _io.ArclinkConnection_setRecordType(self, arg2)
|
|
|
|
def setSource(self, serverloc):
|
|
r"""setSource(ArclinkConnection self, string serverloc) -> bool"""
|
|
return _io.ArclinkConnection_setSource(self, serverloc)
|
|
|
|
def setUser(self, name, password):
|
|
r"""setUser(ArclinkConnection self, string name, string password) -> bool"""
|
|
return _io.ArclinkConnection_setUser(self, name, password)
|
|
|
|
def addStream(self, *args):
|
|
r"""
|
|
addStream(ArclinkConnection self, string networkCode, string stationCode, string locationCode, string channelCode) -> bool
|
|
addStream(ArclinkConnection self, string networkCode, string stationCode, string locationCode, string channelCode, Time stime, Time etime) -> bool
|
|
"""
|
|
return _io.ArclinkConnection_addStream(self, *args)
|
|
|
|
def setStartTime(self, stime):
|
|
r"""setStartTime(ArclinkConnection self, Time stime) -> bool"""
|
|
return _io.ArclinkConnection_setStartTime(self, stime)
|
|
|
|
def setEndTime(self, etime):
|
|
r"""setEndTime(ArclinkConnection self, Time etime) -> bool"""
|
|
return _io.ArclinkConnection_setEndTime(self, etime)
|
|
|
|
def setTimeout(self, seconds):
|
|
r"""setTimeout(ArclinkConnection self, int seconds) -> bool"""
|
|
return _io.ArclinkConnection_setTimeout(self, seconds)
|
|
|
|
def close(self):
|
|
r"""close(ArclinkConnection self)"""
|
|
return _io.ArclinkConnection_close(self)
|
|
|
|
def next(self):
|
|
r"""next(ArclinkConnection self) -> Record"""
|
|
return _io.ArclinkConnection_next(self)
|
|
|
|
def clear(self):
|
|
r"""clear(ArclinkConnection self) -> bool"""
|
|
return _io.ArclinkConnection_clear(self)
|
|
|
|
def reconnect(self):
|
|
r"""reconnect(ArclinkConnection self) -> bool"""
|
|
return _io.ArclinkConnection_reconnect(self)
|
|
|
|
# Register ArclinkConnection in _io:
|
|
_io.ArclinkConnection_swigregister(ArclinkConnection)
|
|
|
|
def ArclinkConnection_ClassName():
|
|
r"""ArclinkConnection_ClassName() -> char const *"""
|
|
return _io.ArclinkConnection_ClassName()
|
|
|
|
def ArclinkConnection_TypeInfo():
|
|
r"""ArclinkConnection_TypeInfo() -> RTTI"""
|
|
return _io.ArclinkConnection_TypeInfo()
|
|
|
|
def ArclinkConnection_Cast(*args):
|
|
r"""
|
|
ArclinkConnection_Cast(BaseObject o) -> ArclinkConnection
|
|
ArclinkConnection_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkConnection
|
|
"""
|
|
return _io.ArclinkConnection_Cast(*args)
|
|
|
|
def ArclinkConnection_ConstCast(*args):
|
|
r"""
|
|
ArclinkConnection_ConstCast(BaseObject o) -> ArclinkConnection
|
|
ArclinkConnection_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkConnection
|
|
"""
|
|
return _io.ArclinkConnection_ConstCast(*args)
|
|
|
|
class CombinedConnection(RecordStream):
|
|
r"""Proxy of C++ Seiscomp::RecordStream::CombinedConnection class."""
|
|
|
|
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):
|
|
r"""
|
|
__init__(CombinedConnection self) -> CombinedConnection
|
|
__init__(CombinedConnection self, string serverloc) -> CombinedConnection
|
|
"""
|
|
_io.CombinedConnection_swiginit(self, _io.new_CombinedConnection(*args))
|
|
__swig_destroy__ = _io.delete_CombinedConnection
|
|
|
|
def setRecordType(self, arg2):
|
|
r"""setRecordType(CombinedConnection self, char const * arg2) -> bool"""
|
|
return _io.CombinedConnection_setRecordType(self, arg2)
|
|
|
|
def setSource(self, serverloc):
|
|
r"""setSource(CombinedConnection self, string serverloc) -> bool"""
|
|
return _io.CombinedConnection_setSource(self, serverloc)
|
|
|
|
def addStream(self, *args):
|
|
r"""
|
|
addStream(CombinedConnection self, string networkCode, string stationCode, string locationCode, string channelCode) -> bool
|
|
addStream(CombinedConnection self, string networkCode, string stationCode, string locationCode, string channelCode, Time startTime, Time endTime) -> bool
|
|
"""
|
|
return _io.CombinedConnection_addStream(self, *args)
|
|
|
|
def setStartTime(self, stime):
|
|
r"""setStartTime(CombinedConnection self, Time stime) -> bool"""
|
|
return _io.CombinedConnection_setStartTime(self, stime)
|
|
|
|
def setEndTime(self, etime):
|
|
r"""setEndTime(CombinedConnection self, Time etime) -> bool"""
|
|
return _io.CombinedConnection_setEndTime(self, etime)
|
|
|
|
def setTimeout(self, seconds):
|
|
r"""setTimeout(CombinedConnection self, int seconds) -> bool"""
|
|
return _io.CombinedConnection_setTimeout(self, seconds)
|
|
|
|
def close(self):
|
|
r"""close(CombinedConnection self)"""
|
|
return _io.CombinedConnection_close(self)
|
|
|
|
def next(self):
|
|
r"""next(CombinedConnection self) -> Record"""
|
|
return _io.CombinedConnection_next(self)
|
|
|
|
# Register CombinedConnection in _io:
|
|
_io.CombinedConnection_swigregister(CombinedConnection)
|
|
|
|
class RecordIIRFilterF(RecordFilterInterface):
|
|
r"""Proxy of C++ Seiscomp::IO::RecordIIRFilter< float > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, filter=None):
|
|
r"""__init__(RecordIIRFilterF self, InPlaceFilterF filter=None) -> RecordIIRFilterF"""
|
|
_io.RecordIIRFilterF_swiginit(self, _io.new_RecordIIRFilterF(filter))
|
|
__swig_destroy__ = _io.delete_RecordIIRFilterF
|
|
|
|
def setIIR(self, f):
|
|
r"""setIIR(RecordIIRFilterF self, InPlaceFilterF f)"""
|
|
return _io.RecordIIRFilterF_setIIR(self, f)
|
|
|
|
def filter(self, *args):
|
|
r"""
|
|
filter(RecordIIRFilterF self) -> InPlaceFilterF
|
|
filter(RecordIIRFilterF self) -> InPlaceFilterF
|
|
"""
|
|
return _io.RecordIIRFilterF_filter(self, *args)
|
|
|
|
def apply(self, rec):
|
|
r"""apply(RecordIIRFilterF self, GenericRecord rec) -> bool"""
|
|
return _io.RecordIIRFilterF_apply(self, rec)
|
|
|
|
def __nonzero__(self):
|
|
return _io.RecordIIRFilterF___nonzero__(self)
|
|
__bool__ = __nonzero__
|
|
|
|
|
|
|
|
def lastError(self):
|
|
r"""lastError(RecordIIRFilterF self) -> string"""
|
|
return _io.RecordIIRFilterF_lastError(self)
|
|
|
|
def feed(self, rec):
|
|
r"""feed(RecordIIRFilterF self, Record rec) -> Record"""
|
|
return _io.RecordIIRFilterF_feed(self, rec)
|
|
|
|
def flush(self):
|
|
r"""flush(RecordIIRFilterF self) -> Record"""
|
|
return _io.RecordIIRFilterF_flush(self)
|
|
|
|
def reset(self):
|
|
r"""reset(RecordIIRFilterF self)"""
|
|
return _io.RecordIIRFilterF_reset(self)
|
|
|
|
def clone(self):
|
|
r"""clone(RecordIIRFilterF self) -> RecordFilterInterface"""
|
|
return _io.RecordIIRFilterF_clone(self)
|
|
|
|
# Register RecordIIRFilterF in _io:
|
|
_io.RecordIIRFilterF_swigregister(RecordIIRFilterF)
|
|
|
|
class RecordIIRFilterD(RecordFilterInterface):
|
|
r"""Proxy of C++ Seiscomp::IO::RecordIIRFilter< double > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, filter=None):
|
|
r"""__init__(RecordIIRFilterD self, InPlaceFilterD filter=None) -> RecordIIRFilterD"""
|
|
_io.RecordIIRFilterD_swiginit(self, _io.new_RecordIIRFilterD(filter))
|
|
__swig_destroy__ = _io.delete_RecordIIRFilterD
|
|
|
|
def setIIR(self, f):
|
|
r"""setIIR(RecordIIRFilterD self, InPlaceFilterD f)"""
|
|
return _io.RecordIIRFilterD_setIIR(self, f)
|
|
|
|
def filter(self, *args):
|
|
r"""
|
|
filter(RecordIIRFilterD self) -> InPlaceFilterD
|
|
filter(RecordIIRFilterD self) -> InPlaceFilterD
|
|
"""
|
|
return _io.RecordIIRFilterD_filter(self, *args)
|
|
|
|
def apply(self, rec):
|
|
r"""apply(RecordIIRFilterD self, GenericRecord rec) -> bool"""
|
|
return _io.RecordIIRFilterD_apply(self, rec)
|
|
|
|
def __nonzero__(self):
|
|
return _io.RecordIIRFilterD___nonzero__(self)
|
|
__bool__ = __nonzero__
|
|
|
|
|
|
|
|
def lastError(self):
|
|
r"""lastError(RecordIIRFilterD self) -> string"""
|
|
return _io.RecordIIRFilterD_lastError(self)
|
|
|
|
def feed(self, rec):
|
|
r"""feed(RecordIIRFilterD self, Record rec) -> Record"""
|
|
return _io.RecordIIRFilterD_feed(self, rec)
|
|
|
|
def flush(self):
|
|
r"""flush(RecordIIRFilterD self) -> Record"""
|
|
return _io.RecordIIRFilterD_flush(self)
|
|
|
|
def reset(self):
|
|
r"""reset(RecordIIRFilterD self)"""
|
|
return _io.RecordIIRFilterD_reset(self)
|
|
|
|
def clone(self):
|
|
r"""clone(RecordIIRFilterD self) -> RecordFilterInterface"""
|
|
return _io.RecordIIRFilterD_clone(self)
|
|
|
|
# Register RecordIIRFilterD in _io:
|
|
_io.RecordIIRFilterD_swigregister(RecordIIRFilterD)
|
|
|
|
class RecordResamplerF(RecordResamplerBase):
|
|
r"""Proxy of C++ Seiscomp::IO::RecordResampler< float > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, targetFrequency, fp=0.7, fs=0.9, coeffScale=10, lanczosWidth=3):
|
|
r"""__init__(RecordResamplerF self, double targetFrequency, double fp=0.7, double fs=0.9, double coeffScale=10, int lanczosWidth=3) -> RecordResamplerF"""
|
|
_io.RecordResamplerF_swiginit(self, _io.new_RecordResamplerF(targetFrequency, fp, fs, coeffScale, lanczosWidth))
|
|
__swig_destroy__ = _io.delete_RecordResamplerF
|
|
|
|
def feed(self, record):
|
|
r"""feed(RecordResamplerF self, Record record) -> Record"""
|
|
return _io.RecordResamplerF_feed(self, record)
|
|
|
|
def reset(self):
|
|
r"""reset(RecordResamplerF self)"""
|
|
return _io.RecordResamplerF_reset(self)
|
|
|
|
def clone(self):
|
|
r"""clone(RecordResamplerF self) -> RecordFilterInterface"""
|
|
return _io.RecordResamplerF_clone(self)
|
|
|
|
# Register RecordResamplerF in _io:
|
|
_io.RecordResamplerF_swigregister(RecordResamplerF)
|
|
|
|
class RecordResamplerD(RecordResamplerBase):
|
|
r"""Proxy of C++ Seiscomp::IO::RecordResampler< double > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, targetFrequency, fp=0.7, fs=0.9, coeffScale=10, lanczosWidth=3):
|
|
r"""__init__(RecordResamplerD self, double targetFrequency, double fp=0.7, double fs=0.9, double coeffScale=10, int lanczosWidth=3) -> RecordResamplerD"""
|
|
_io.RecordResamplerD_swiginit(self, _io.new_RecordResamplerD(targetFrequency, fp, fs, coeffScale, lanczosWidth))
|
|
__swig_destroy__ = _io.delete_RecordResamplerD
|
|
|
|
def feed(self, record):
|
|
r"""feed(RecordResamplerD self, Record record) -> Record"""
|
|
return _io.RecordResamplerD_feed(self, record)
|
|
|
|
def reset(self):
|
|
r"""reset(RecordResamplerD self)"""
|
|
return _io.RecordResamplerD_reset(self)
|
|
|
|
def clone(self):
|
|
r"""clone(RecordResamplerD self) -> RecordFilterInterface"""
|
|
return _io.RecordResamplerD_clone(self)
|
|
|
|
# Register RecordResamplerD in _io:
|
|
_io.RecordResamplerD_swigregister(RecordResamplerD)
|
|
|
|
class RecordResamplerI(RecordResamplerBase):
|
|
r"""Proxy of C++ Seiscomp::IO::RecordResampler< int > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, targetFrequency, fp=0.7, fs=0.9, coeffScale=10, lanczosWidth=3):
|
|
r"""__init__(RecordResamplerI self, double targetFrequency, double fp=0.7, double fs=0.9, double coeffScale=10, int lanczosWidth=3) -> RecordResamplerI"""
|
|
_io.RecordResamplerI_swiginit(self, _io.new_RecordResamplerI(targetFrequency, fp, fs, coeffScale, lanczosWidth))
|
|
__swig_destroy__ = _io.delete_RecordResamplerI
|
|
|
|
def feed(self, record):
|
|
r"""feed(RecordResamplerI self, Record record) -> Record"""
|
|
return _io.RecordResamplerI_feed(self, record)
|
|
|
|
def reset(self):
|
|
r"""reset(RecordResamplerI self)"""
|
|
return _io.RecordResamplerI_reset(self)
|
|
|
|
def clone(self):
|
|
r"""clone(RecordResamplerI self) -> RecordFilterInterface"""
|
|
return _io.RecordResamplerI_clone(self)
|
|
|
|
# Register RecordResamplerI in _io:
|
|
_io.RecordResamplerI_swigregister(RecordResamplerI)
|
|
|
|
class ExportObjectList(object):
|
|
r"""Proxy of C++ std::vector< Seiscomp::Core::BaseObject * > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
r"""iterator(ExportObjectList self) -> SwigPyIterator"""
|
|
return _io.ExportObjectList_iterator(self)
|
|
def __iter__(self):
|
|
return self.iterator()
|
|
|
|
def __nonzero__(self):
|
|
r"""__nonzero__(ExportObjectList self) -> bool"""
|
|
return _io.ExportObjectList___nonzero__(self)
|
|
|
|
def __bool__(self):
|
|
r"""__bool__(ExportObjectList self) -> bool"""
|
|
return _io.ExportObjectList___bool__(self)
|
|
|
|
def __len__(self):
|
|
r"""__len__(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::size_type"""
|
|
return _io.ExportObjectList___len__(self)
|
|
|
|
def __getslice__(self, i, j):
|
|
r"""__getslice__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::difference_type i, std::vector< Seiscomp::Core::BaseObject * >::difference_type j) -> ExportObjectList"""
|
|
return _io.ExportObjectList___getslice__(self, i, j)
|
|
|
|
def __setslice__(self, *args):
|
|
r"""
|
|
__setslice__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::difference_type i, std::vector< Seiscomp::Core::BaseObject * >::difference_type j)
|
|
__setslice__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::difference_type i, std::vector< Seiscomp::Core::BaseObject * >::difference_type j, ExportObjectList v)
|
|
"""
|
|
return _io.ExportObjectList___setslice__(self, *args)
|
|
|
|
def __delslice__(self, i, j):
|
|
r"""__delslice__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::difference_type i, std::vector< Seiscomp::Core::BaseObject * >::difference_type j)"""
|
|
return _io.ExportObjectList___delslice__(self, i, j)
|
|
|
|
def __delitem__(self, *args):
|
|
r"""
|
|
__delitem__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::difference_type i)
|
|
__delitem__(ExportObjectList self, PySliceObject * slice)
|
|
"""
|
|
return _io.ExportObjectList___delitem__(self, *args)
|
|
|
|
def __getitem__(self, *args):
|
|
r"""
|
|
__getitem__(ExportObjectList self, PySliceObject * slice) -> ExportObjectList
|
|
__getitem__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::difference_type i) -> BaseObject
|
|
"""
|
|
return _io.ExportObjectList___getitem__(self, *args)
|
|
|
|
def __setitem__(self, *args):
|
|
r"""
|
|
__setitem__(ExportObjectList self, PySliceObject * slice, ExportObjectList v)
|
|
__setitem__(ExportObjectList self, PySliceObject * slice)
|
|
__setitem__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::difference_type i, BaseObject x)
|
|
"""
|
|
return _io.ExportObjectList___setitem__(self, *args)
|
|
|
|
def pop(self):
|
|
r"""pop(ExportObjectList self) -> BaseObject"""
|
|
return _io.ExportObjectList_pop(self)
|
|
|
|
def append(self, x):
|
|
r"""append(ExportObjectList self, BaseObject x)"""
|
|
return _io.ExportObjectList_append(self, x)
|
|
|
|
def empty(self):
|
|
r"""empty(ExportObjectList self) -> bool"""
|
|
return _io.ExportObjectList_empty(self)
|
|
|
|
def size(self):
|
|
r"""size(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::size_type"""
|
|
return _io.ExportObjectList_size(self)
|
|
|
|
def swap(self, v):
|
|
r"""swap(ExportObjectList self, ExportObjectList v)"""
|
|
return _io.ExportObjectList_swap(self, v)
|
|
|
|
def begin(self):
|
|
r"""begin(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::iterator"""
|
|
return _io.ExportObjectList_begin(self)
|
|
|
|
def end(self):
|
|
r"""end(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::iterator"""
|
|
return _io.ExportObjectList_end(self)
|
|
|
|
def rbegin(self):
|
|
r"""rbegin(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::reverse_iterator"""
|
|
return _io.ExportObjectList_rbegin(self)
|
|
|
|
def rend(self):
|
|
r"""rend(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::reverse_iterator"""
|
|
return _io.ExportObjectList_rend(self)
|
|
|
|
def clear(self):
|
|
r"""clear(ExportObjectList self)"""
|
|
return _io.ExportObjectList_clear(self)
|
|
|
|
def get_allocator(self):
|
|
r"""get_allocator(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::allocator_type"""
|
|
return _io.ExportObjectList_get_allocator(self)
|
|
|
|
def pop_back(self):
|
|
r"""pop_back(ExportObjectList self)"""
|
|
return _io.ExportObjectList_pop_back(self)
|
|
|
|
def erase(self, *args):
|
|
r"""
|
|
erase(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::iterator pos) -> std::vector< Seiscomp::Core::BaseObject * >::iterator
|
|
erase(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::iterator first, std::vector< Seiscomp::Core::BaseObject * >::iterator last) -> std::vector< Seiscomp::Core::BaseObject * >::iterator
|
|
"""
|
|
return _io.ExportObjectList_erase(self, *args)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ExportObjectList self) -> ExportObjectList
|
|
__init__(ExportObjectList self, ExportObjectList other) -> ExportObjectList
|
|
__init__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::size_type size) -> ExportObjectList
|
|
__init__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::size_type size, BaseObject value) -> ExportObjectList
|
|
"""
|
|
_io.ExportObjectList_swiginit(self, _io.new_ExportObjectList(*args))
|
|
|
|
def push_back(self, x):
|
|
r"""push_back(ExportObjectList self, BaseObject x)"""
|
|
return _io.ExportObjectList_push_back(self, x)
|
|
|
|
def front(self):
|
|
r"""front(ExportObjectList self) -> BaseObject"""
|
|
return _io.ExportObjectList_front(self)
|
|
|
|
def back(self):
|
|
r"""back(ExportObjectList self) -> BaseObject"""
|
|
return _io.ExportObjectList_back(self)
|
|
|
|
def assign(self, n, x):
|
|
r"""assign(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::size_type n, BaseObject x)"""
|
|
return _io.ExportObjectList_assign(self, n, x)
|
|
|
|
def resize(self, *args):
|
|
r"""
|
|
resize(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::size_type new_size)
|
|
resize(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::size_type new_size, BaseObject x)
|
|
"""
|
|
return _io.ExportObjectList_resize(self, *args)
|
|
|
|
def insert(self, *args):
|
|
r"""
|
|
insert(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::iterator pos, BaseObject x) -> std::vector< Seiscomp::Core::BaseObject * >::iterator
|
|
insert(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::iterator pos, std::vector< Seiscomp::Core::BaseObject * >::size_type n, BaseObject x)
|
|
"""
|
|
return _io.ExportObjectList_insert(self, *args)
|
|
|
|
def reserve(self, n):
|
|
r"""reserve(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::size_type n)"""
|
|
return _io.ExportObjectList_reserve(self, n)
|
|
|
|
def capacity(self):
|
|
r"""capacity(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::size_type"""
|
|
return _io.ExportObjectList_capacity(self)
|
|
__swig_destroy__ = _io.delete_ExportObjectList
|
|
|
|
# Register ExportObjectList in _io:
|
|
_io.ExportObjectList_swigregister(ExportObjectList)
|
|
|
|
|
|
|