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.
1971 lines
76 KiB
Python
1971 lines
76 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 _client
|
|
else:
|
|
import _client
|
|
|
|
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__ = _client.delete_SwigPyIterator
|
|
|
|
def value(self):
|
|
return _client.SwigPyIterator_value(self)
|
|
|
|
def incr(self, n=1):
|
|
return _client.SwigPyIterator_incr(self, n)
|
|
|
|
def decr(self, n=1):
|
|
return _client.SwigPyIterator_decr(self, n)
|
|
|
|
def distance(self, x):
|
|
return _client.SwigPyIterator_distance(self, x)
|
|
|
|
def equal(self, x):
|
|
return _client.SwigPyIterator_equal(self, x)
|
|
|
|
def copy(self):
|
|
return _client.SwigPyIterator_copy(self)
|
|
|
|
def next(self):
|
|
return _client.SwigPyIterator_next(self)
|
|
|
|
def __next__(self):
|
|
return _client.SwigPyIterator___next__(self)
|
|
|
|
def previous(self):
|
|
return _client.SwigPyIterator_previous(self)
|
|
|
|
def advance(self, n):
|
|
return _client.SwigPyIterator_advance(self, n)
|
|
|
|
def __eq__(self, x):
|
|
return _client.SwigPyIterator___eq__(self, x)
|
|
|
|
def __ne__(self, x):
|
|
return _client.SwigPyIterator___ne__(self, x)
|
|
|
|
def __iadd__(self, n):
|
|
return _client.SwigPyIterator___iadd__(self, n)
|
|
|
|
def __isub__(self, n):
|
|
return _client.SwigPyIterator___isub__(self, n)
|
|
|
|
def __add__(self, n):
|
|
return _client.SwigPyIterator___add__(self, n)
|
|
|
|
def __sub__(self, *args):
|
|
return _client.SwigPyIterator___sub__(self, *args)
|
|
def __iter__(self):
|
|
return self
|
|
|
|
# Register SwigPyIterator in _client:
|
|
_client.SwigPyIterator_swigregister(SwigPyIterator)
|
|
|
|
import seiscomp.system
|
|
import seiscomp.core
|
|
import seiscomp.logging
|
|
import seiscomp.config
|
|
import seiscomp.datamodel
|
|
import seiscomp.io
|
|
import seiscomp.math
|
|
import seiscomp.geo
|
|
import seiscomp.utils
|
|
class Packet(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::Client::Packet class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Packet
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Packet
|
|
"""
|
|
return _client.Packet_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Packet
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Packet
|
|
"""
|
|
return _client.Packet_ConstCast(*args)
|
|
|
|
def __init__(self):
|
|
r"""__init__(Packet self) -> Packet"""
|
|
_client.Packet_swiginit(self, _client.new_Packet())
|
|
Undefined = _client.Packet_Undefined
|
|
|
|
Data = _client.Packet_Data
|
|
|
|
Enter = _client.Packet_Enter
|
|
|
|
Leave = _client.Packet_Leave
|
|
|
|
Status = _client.Packet_Status
|
|
|
|
Disconnected = _client.Packet_Disconnected
|
|
|
|
type = property(_client.Packet_type_get, _client.Packet_type_set, doc=r"""type : Seiscomp::Client::Packet::Type""")
|
|
headerContentEncoding = property(_client.Packet_headerContentEncoding_get, _client.Packet_headerContentEncoding_set, doc=r"""headerContentEncoding : std::string""")
|
|
headerContentType = property(_client.Packet_headerContentType_get, _client.Packet_headerContentType_set, doc=r"""headerContentType : std::string""")
|
|
sender = property(_client.Packet_sender_get, _client.Packet_sender_set, doc=r"""sender : std::string""")
|
|
target = property(_client.Packet_target_get, _client.Packet_target_set, doc=r"""target : std::string""")
|
|
subject = property(_client.Packet_subject_get, _client.Packet_subject_set, doc=r"""subject : std::string""")
|
|
seqNo = property(_client.Packet_seqNo_get, _client.Packet_seqNo_set, doc=r"""seqNo : uint64_t""")
|
|
payload = property(_client.Packet_payload_get, _client.Packet_payload_set, doc=r"""payload : std::string""")
|
|
|
|
def swap(self, other):
|
|
r"""swap(Packet self, Packet other) -> Packet"""
|
|
return _client.Packet_swap(self, other)
|
|
__swig_destroy__ = _client.delete_Packet
|
|
|
|
# Register Packet in _client:
|
|
_client.Packet_swigregister(Packet)
|
|
|
|
def Packet_Cast(*args):
|
|
r"""
|
|
Packet_Cast(BaseObject o) -> Packet
|
|
Packet_Cast(Seiscomp::Core::BaseObjectPtr o) -> Packet
|
|
"""
|
|
return _client.Packet_Cast(*args)
|
|
|
|
def Packet_ConstCast(*args):
|
|
r"""
|
|
Packet_ConstCast(BaseObject o) -> Packet
|
|
Packet_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Packet
|
|
"""
|
|
return _client.Packet_ConstCast(*args)
|
|
|
|
OK = _client.OK
|
|
|
|
InvalidURL = _client.InvalidURL
|
|
|
|
InvalidURLParameters = _client.InvalidURLParameters
|
|
|
|
InvalidProtocol = _client.InvalidProtocol
|
|
|
|
ContentEncodingRequired = _client.ContentEncodingRequired
|
|
|
|
ContentTypeRequired = _client.ContentTypeRequired
|
|
|
|
ContentEncodingUnknown = _client.ContentEncodingUnknown
|
|
|
|
ContentTypeUnknown = _client.ContentTypeUnknown
|
|
|
|
AlreadyConnected = _client.AlreadyConnected
|
|
|
|
NotConnected = _client.NotConnected
|
|
|
|
ConnectionClosedByPeer = _client.ConnectionClosedByPeer
|
|
|
|
SystemError = _client.SystemError
|
|
|
|
TimeoutError = _client.TimeoutError
|
|
|
|
NetworkError = _client.NetworkError
|
|
|
|
NetworkProtocolError = _client.NetworkProtocolError
|
|
|
|
DuplicateUsername = _client.DuplicateUsername
|
|
|
|
GroupDoesNotExist = _client.GroupDoesNotExist
|
|
|
|
InboxUnderflow = _client.InboxUnderflow
|
|
|
|
InboxOverflow = _client.InboxOverflow
|
|
|
|
OutboxOverflow = _client.OutboxOverflow
|
|
|
|
AlreadySubscribed = _client.AlreadySubscribed
|
|
|
|
NotSubscribed = _client.NotSubscribed
|
|
|
|
EncodingError = _client.EncodingError
|
|
|
|
DecodingError = _client.DecodingError
|
|
|
|
MissingGroup = _client.MissingGroup
|
|
|
|
InvalidMessageType = _client.InvalidMessageType
|
|
|
|
MessageTooLarge = _client.MessageTooLarge
|
|
|
|
Error = _client.Error
|
|
|
|
EResultQuantity = _client.EResultQuantity
|
|
|
|
class EResultNames(object):
|
|
r"""Proxy of C++ Seiscomp::Client::EResultNames 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):
|
|
r"""__init__(EResultNames self) -> EResultNames"""
|
|
_client.EResultNames_swiginit(self, _client.new_EResultNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _client.EResultNames_name(i)
|
|
__swig_destroy__ = _client.delete_EResultNames
|
|
|
|
# Register EResultNames in _client:
|
|
_client.EResultNames_swigregister(EResultNames)
|
|
|
|
def EResultNames_name(i):
|
|
r"""EResultNames_name(int i) -> char const *"""
|
|
return _client.EResultNames_name(i)
|
|
|
|
class Protocol(object):
|
|
r"""Proxy of C++ Seiscomp::Client::Protocol 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
|
|
Identity = _client.Protocol_Identity
|
|
|
|
Deflate = _client.Protocol_Deflate
|
|
|
|
GZip = _client.Protocol_GZip
|
|
|
|
LZ4 = _client.Protocol_LZ4
|
|
|
|
EContentEncodingQuantity = _client.Protocol_EContentEncodingQuantity
|
|
|
|
Binary = _client.Protocol_Binary
|
|
|
|
JSON = _client.Protocol_JSON
|
|
|
|
BSON = _client.Protocol_BSON
|
|
|
|
XML = _client.Protocol_XML
|
|
|
|
IMPORTED_XML = _client.Protocol_IMPORTED_XML
|
|
|
|
Text = _client.Protocol_Text
|
|
|
|
EContentTypeQuantity = _client.Protocol_EContentTypeQuantity
|
|
|
|
Regular = _client.Protocol_Regular
|
|
|
|
Transient = _client.Protocol_Transient
|
|
|
|
Status = _client.Protocol_Status
|
|
|
|
EMessageTypeQuantity = _client.Protocol_EMessageTypeQuantity
|
|
|
|
__swig_destroy__ = _client.delete_Protocol
|
|
|
|
def setMembershipInfo(self, enable):
|
|
r"""setMembershipInfo(Protocol self, bool enable)"""
|
|
return _client.Protocol_setMembershipInfo(self, enable)
|
|
|
|
def connect(self, *args):
|
|
r"""
|
|
connect(Protocol self, char const * address, unsigned int timeoutMs, char const * clientName=None) -> Seiscomp::Client::Result
|
|
connect(Protocol self, std::string const & address, unsigned int timeoutMs, std::string const & clientName=std::string()) -> Seiscomp::Client::Result
|
|
"""
|
|
return _client.Protocol_connect(self, *args)
|
|
|
|
def schemaVersion(self):
|
|
r"""schemaVersion(Protocol self) -> Version"""
|
|
return _client.Protocol_schemaVersion(self)
|
|
|
|
def extendedParameters(self):
|
|
r"""extendedParameters(Protocol self) -> Seiscomp::Client::Protocol::KeyValueStore const &"""
|
|
return _client.Protocol_extendedParameters(self)
|
|
|
|
def clientName(self):
|
|
r"""clientName(Protocol self) -> std::string const &"""
|
|
return _client.Protocol_clientName(self)
|
|
|
|
def subscribe(self, group):
|
|
r"""subscribe(Protocol self, std::string const & group) -> Seiscomp::Client::Result"""
|
|
return _client.Protocol_subscribe(self, group)
|
|
|
|
def unsubscribe(self, group):
|
|
r"""unsubscribe(Protocol self, std::string const & group) -> Seiscomp::Client::Result"""
|
|
return _client.Protocol_unsubscribe(self, group)
|
|
|
|
def sendData(self, targetGroup, data, len, type, contentEncoding, contentType):
|
|
r"""sendData(Protocol self, std::string const & targetGroup, char const * data, size_t len, Seiscomp::Client::Protocol::MessageType type, Seiscomp::Client::Protocol::ContentEncoding contentEncoding, Seiscomp::Client::Protocol::ContentType contentType) -> Seiscomp::Client::Result"""
|
|
return _client.Protocol_sendData(self, targetGroup, data, len, type, contentEncoding, contentType)
|
|
|
|
def sendMessage(self, *args):
|
|
r"""sendMessage(Protocol self, std::string const & targetGroup, Message msg, Seiscomp::Client::Protocol::MessageType type=Regular, Seiscomp::Core::Optional< Seiscomp::Client::Protocol::ContentEncoding >::Impl contentEncoding=Unset, Seiscomp::Core::Optional< Seiscomp::Client::Protocol::ContentType >::Impl contentType=Unset) -> Seiscomp::Client::Result"""
|
|
return _client.Protocol_sendMessage(self, *args)
|
|
|
|
def recv(self):
|
|
r"""recv(Protocol self) -> Packet"""
|
|
return _client.Protocol_recv(self)
|
|
|
|
def fetchInbox(self):
|
|
r"""fetchInbox(Protocol self) -> Seiscomp::Client::Result"""
|
|
return _client.Protocol_fetchInbox(self)
|
|
|
|
def syncOutbox(self):
|
|
r"""syncOutbox(Protocol self) -> Seiscomp::Client::Result"""
|
|
return _client.Protocol_syncOutbox(self)
|
|
|
|
def disconnect(self):
|
|
r"""disconnect(Protocol self) -> Seiscomp::Client::Result"""
|
|
return _client.Protocol_disconnect(self)
|
|
|
|
def isConnected(self):
|
|
r"""isConnected(Protocol self) -> bool"""
|
|
return _client.Protocol_isConnected(self)
|
|
|
|
def close(self):
|
|
r"""close(Protocol self) -> Seiscomp::Client::Result"""
|
|
return _client.Protocol_close(self)
|
|
|
|
def setTimeout(self, milliseconds):
|
|
r"""setTimeout(Protocol self, int milliseconds) -> Seiscomp::Client::Result"""
|
|
return _client.Protocol_setTimeout(self, milliseconds)
|
|
|
|
def groups(self):
|
|
r"""groups(Protocol self) -> Seiscomp::Client::Protocol::Groups const &"""
|
|
return _client.Protocol_groups(self)
|
|
|
|
def erroneous(self):
|
|
r"""erroneous(Protocol self) -> bool"""
|
|
return _client.Protocol_erroneous(self)
|
|
|
|
def lastErrorMessage(self):
|
|
r"""lastErrorMessage(Protocol self) -> std::string const &"""
|
|
return _client.Protocol_lastErrorMessage(self)
|
|
|
|
def state(self):
|
|
r"""state(Protocol self) -> Seiscomp::Client::Protocol::State const &"""
|
|
return _client.Protocol_state(self)
|
|
|
|
def inboxSize(self):
|
|
r"""inboxSize(Protocol self) -> size_t"""
|
|
return _client.Protocol_inboxSize(self)
|
|
|
|
def outboxSize(self):
|
|
r"""outboxSize(Protocol self) -> size_t"""
|
|
return _client.Protocol_outboxSize(self)
|
|
|
|
def setCertificate(self, cert):
|
|
r"""setCertificate(Protocol self, std::string const & cert)"""
|
|
return _client.Protocol_setCertificate(self, cert)
|
|
|
|
@staticmethod
|
|
def decode(*args):
|
|
r"""
|
|
decode(std::string const & blob, Seiscomp::Client::Protocol::ContentEncoding encoding, Seiscomp::Client::Protocol::ContentType type) -> Message
|
|
decode(char const * blob, size_t blob_length, Seiscomp::Client::Protocol::ContentEncoding encoding, Seiscomp::Client::Protocol::ContentType type) -> Message
|
|
"""
|
|
return _client.Protocol_decode(*args)
|
|
|
|
@staticmethod
|
|
def encode(blob, msg, encoding, type, schemaVersion):
|
|
r"""encode(std::string & blob, Message msg, Seiscomp::Client::Protocol::ContentEncoding encoding, Seiscomp::Client::Protocol::ContentType type, int schemaVersion) -> bool"""
|
|
return _client.Protocol_encode(blob, msg, encoding, type, schemaVersion)
|
|
|
|
# Register Protocol in _client:
|
|
_client.Protocol_swigregister(Protocol)
|
|
cvar = _client.cvar
|
|
Protocol.STATUS_GROUP = _client.cvar.Protocol_STATUS_GROUP
|
|
Protocol.LISTENER_GROUP = _client.cvar.Protocol_LISTENER_GROUP
|
|
Protocol.IMPORT_GROUP = _client.cvar.Protocol_IMPORT_GROUP
|
|
|
|
def Protocol_decode(*args):
|
|
r"""
|
|
Protocol_decode(std::string const & blob, Seiscomp::Client::Protocol::ContentEncoding encoding, Seiscomp::Client::Protocol::ContentType type) -> Message
|
|
Protocol_decode(char const * blob, size_t blob_length, Seiscomp::Client::Protocol::ContentEncoding encoding, Seiscomp::Client::Protocol::ContentType type) -> Message
|
|
"""
|
|
return _client.Protocol_decode(*args)
|
|
|
|
def Protocol_encode(blob, msg, encoding, type, schemaVersion):
|
|
r"""Protocol_encode(std::string & blob, Message msg, Seiscomp::Client::Protocol::ContentEncoding encoding, Seiscomp::Client::Protocol::ContentType type, int schemaVersion) -> bool"""
|
|
return _client.Protocol_encode(blob, msg, encoding, type, schemaVersion)
|
|
|
|
class Connection(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::Client::Connection 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, proto=None):
|
|
r"""__init__(Connection self, Protocol proto=None) -> Connection"""
|
|
_client.Connection_swiginit(self, _client.new_Connection(proto))
|
|
__swig_destroy__ = _client.delete_Connection
|
|
|
|
def setContentEncoding(self, enc):
|
|
r"""setContentEncoding(Connection self, Seiscomp::Client::Protocol::ContentEncoding enc)"""
|
|
return _client.Connection_setContentEncoding(self, enc)
|
|
|
|
def setContentType(self, type):
|
|
r"""setContentType(Connection self, Seiscomp::Client::Protocol::ContentType type)"""
|
|
return _client.Connection_setContentType(self, type)
|
|
|
|
def setSource(self, *args):
|
|
r"""
|
|
setSource(Connection self, char const * URL) -> Seiscomp::Client::Result
|
|
setSource(Connection self, std::string const & URL) -> Seiscomp::Client::Result
|
|
"""
|
|
return _client.Connection_setSource(self, *args)
|
|
|
|
def source(self):
|
|
r"""source(Connection self) -> std::string const &"""
|
|
return _client.Connection_source(self)
|
|
|
|
def setMembershipInfo(self, enable):
|
|
r"""setMembershipInfo(Connection self, bool enable) -> Seiscomp::Client::Result"""
|
|
return _client.Connection_setMembershipInfo(self, enable)
|
|
|
|
def connect(self, clientName, primaryGroup, timeoutMs=3000):
|
|
r"""connect(Connection self, std::string const & clientName, std::string const & primaryGroup, unsigned int timeoutMs=3000) -> Seiscomp::Client::Result"""
|
|
return _client.Connection_connect(self, clientName, primaryGroup, timeoutMs)
|
|
|
|
def disconnect(self):
|
|
r"""disconnect(Connection self) -> Seiscomp::Client::Result"""
|
|
return _client.Connection_disconnect(self)
|
|
|
|
def isConnected(self):
|
|
r"""isConnected(Connection self) -> bool"""
|
|
return _client.Connection_isConnected(self)
|
|
|
|
def reconnect(self):
|
|
r"""reconnect(Connection self) -> Seiscomp::Client::Result"""
|
|
return _client.Connection_reconnect(self)
|
|
|
|
def close(self):
|
|
r"""close(Connection self) -> Seiscomp::Client::Result"""
|
|
return _client.Connection_close(self)
|
|
|
|
def setTimeout(self, milliseconds):
|
|
r"""setTimeout(Connection self, int milliseconds) -> Seiscomp::Client::Result"""
|
|
return _client.Connection_setTimeout(self, milliseconds)
|
|
|
|
def subscribe(self, *args):
|
|
r"""
|
|
subscribe(Connection self, char const * group) -> Seiscomp::Client::Result
|
|
subscribe(Connection self, std::string const & group) -> Seiscomp::Client::Result
|
|
"""
|
|
return _client.Connection_subscribe(self, *args)
|
|
|
|
def unsubscribe(self, *args):
|
|
r"""
|
|
unsubscribe(Connection self, char const * group) -> Seiscomp::Client::Result
|
|
unsubscribe(Connection self, std::string const & group) -> Seiscomp::Client::Result
|
|
"""
|
|
return _client.Connection_unsubscribe(self, *args)
|
|
|
|
def fetchInbox(self):
|
|
r"""fetchInbox(Connection self) -> Seiscomp::Client::Result"""
|
|
return _client.Connection_fetchInbox(self)
|
|
|
|
def syncOutbox(self):
|
|
r"""syncOutbox(Connection self) -> Seiscomp::Client::Result"""
|
|
return _client.Connection_syncOutbox(self)
|
|
|
|
def recv(self):
|
|
r"""recv(Connection self) -> Message"""
|
|
return _client.Connection_recv(self)
|
|
|
|
def sendMessage(self, *args):
|
|
r"""
|
|
sendMessage(Connection self, Message msg) -> Seiscomp::Client::Result
|
|
sendMessage(Connection self, std::string const & targetGroup, Message msg) -> Seiscomp::Client::Result
|
|
"""
|
|
return _client.Connection_sendMessage(self, *args)
|
|
|
|
def send(self, *args):
|
|
r"""
|
|
send(Connection self, Message msg) -> bool
|
|
send(Connection self, std::string const & targetGroup, Message msg) -> bool
|
|
"""
|
|
return _client.Connection_send(self, *args)
|
|
|
|
def inboxSize(self):
|
|
r"""inboxSize(Connection self) -> size_t"""
|
|
return _client.Connection_inboxSize(self)
|
|
|
|
def state(self):
|
|
r"""state(Connection self) -> Seiscomp::Client::Protocol::State const *"""
|
|
return _client.Connection_state(self)
|
|
|
|
def lastError(self):
|
|
r"""lastError(Connection self) -> Seiscomp::Client::Result"""
|
|
return _client.Connection_lastError(self)
|
|
|
|
def lastErrorMessage(self):
|
|
r"""lastErrorMessage(Connection self) -> std::string const"""
|
|
return _client.Connection_lastErrorMessage(self)
|
|
|
|
def protocol(self):
|
|
r"""protocol(Connection self) -> Protocol"""
|
|
return _client.Connection_protocol(self)
|
|
|
|
def setInfoCallback(self, arg2):
|
|
r"""setInfoCallback(Connection self, Seiscomp::Client::Connection::InfoCallback arg2)"""
|
|
return _client.Connection_setInfoCallback(self, arg2)
|
|
|
|
def getInfo(self, timestamp, os):
|
|
r"""getInfo(Connection self, Time timestamp, std::ostream & os)"""
|
|
return _client.Connection_getInfo(self, timestamp, os)
|
|
|
|
def setCertificate(self, cert):
|
|
r"""setCertificate(Connection self, std::string const & cert) -> Seiscomp::Client::Result"""
|
|
return _client.Connection_setCertificate(self, cert)
|
|
|
|
def clientName(self):
|
|
r"""clientName(Connection self) -> std::string const &"""
|
|
return _client.Connection_clientName(self)
|
|
|
|
def schemaVersion(self):
|
|
r"""schemaVersion(Connection self) -> Version"""
|
|
return _client.Connection_schemaVersion(self)
|
|
|
|
def extendedParameters(self):
|
|
r"""extendedParameters(Connection self) -> Seiscomp::Client::Protocol::KeyValueStore const *"""
|
|
return _client.Connection_extendedParameters(self)
|
|
|
|
# Register Connection in _client:
|
|
_client.Connection_swigregister(Connection)
|
|
|
|
class ServiceRequestMessage(seiscomp.core.Message):
|
|
r"""Proxy of C++ Seiscomp::Client::ServiceRequestMessage 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")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def ClassName():
|
|
r"""ClassName() -> char const *"""
|
|
return _client.ServiceRequestMessage_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _client.ServiceRequestMessage_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ServiceRequestMessage self) -> char const *"""
|
|
return _client.ServiceRequestMessage_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ServiceRequestMessage self) -> RTTI"""
|
|
return _client.ServiceRequestMessage_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ServiceRequestMessage
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ServiceRequestMessage
|
|
"""
|
|
return _client.ServiceRequestMessage_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ServiceRequestMessage
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ServiceRequestMessage
|
|
"""
|
|
return _client.ServiceRequestMessage_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ServiceRequestMessage self, GenericArchive ar)"""
|
|
return _client.ServiceRequestMessage_serialize(self, ar)
|
|
|
|
def service(self):
|
|
r"""service(ServiceRequestMessage self) -> char const *"""
|
|
return _client.ServiceRequestMessage_service(self)
|
|
__swig_destroy__ = _client.delete_ServiceRequestMessage
|
|
|
|
# Register ServiceRequestMessage in _client:
|
|
_client.ServiceRequestMessage_swigregister(ServiceRequestMessage)
|
|
|
|
def ServiceRequestMessage_ClassName():
|
|
r"""ServiceRequestMessage_ClassName() -> char const *"""
|
|
return _client.ServiceRequestMessage_ClassName()
|
|
|
|
def ServiceRequestMessage_TypeInfo():
|
|
r"""ServiceRequestMessage_TypeInfo() -> RTTI"""
|
|
return _client.ServiceRequestMessage_TypeInfo()
|
|
|
|
def ServiceRequestMessage_Cast(*args):
|
|
r"""
|
|
ServiceRequestMessage_Cast(BaseObject o) -> ServiceRequestMessage
|
|
ServiceRequestMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> ServiceRequestMessage
|
|
"""
|
|
return _client.ServiceRequestMessage_Cast(*args)
|
|
|
|
def ServiceRequestMessage_ConstCast(*args):
|
|
r"""
|
|
ServiceRequestMessage_ConstCast(BaseObject o) -> ServiceRequestMessage
|
|
ServiceRequestMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ServiceRequestMessage
|
|
"""
|
|
return _client.ServiceRequestMessage_ConstCast(*args)
|
|
|
|
class ServiceProvideMessage(seiscomp.core.Message):
|
|
r"""Proxy of C++ Seiscomp::Client::ServiceProvideMessage 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")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def ClassName():
|
|
r"""ClassName() -> char const *"""
|
|
return _client.ServiceProvideMessage_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _client.ServiceProvideMessage_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ServiceProvideMessage self) -> char const *"""
|
|
return _client.ServiceProvideMessage_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ServiceProvideMessage self) -> RTTI"""
|
|
return _client.ServiceProvideMessage_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ServiceProvideMessage
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ServiceProvideMessage
|
|
"""
|
|
return _client.ServiceProvideMessage_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ServiceProvideMessage
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ServiceProvideMessage
|
|
"""
|
|
return _client.ServiceProvideMessage_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ServiceProvideMessage self, GenericArchive ar)"""
|
|
return _client.ServiceProvideMessage_serialize(self, ar)
|
|
|
|
def service(self):
|
|
r"""service(ServiceProvideMessage self) -> char const *"""
|
|
return _client.ServiceProvideMessage_service(self)
|
|
|
|
def parameters(self):
|
|
r"""parameters(ServiceProvideMessage self) -> char const *"""
|
|
return _client.ServiceProvideMessage_parameters(self)
|
|
|
|
def empty(self):
|
|
r"""empty(ServiceProvideMessage self) -> bool"""
|
|
return _client.ServiceProvideMessage_empty(self)
|
|
__swig_destroy__ = _client.delete_ServiceProvideMessage
|
|
|
|
# Register ServiceProvideMessage in _client:
|
|
_client.ServiceProvideMessage_swigregister(ServiceProvideMessage)
|
|
|
|
def ServiceProvideMessage_ClassName():
|
|
r"""ServiceProvideMessage_ClassName() -> char const *"""
|
|
return _client.ServiceProvideMessage_ClassName()
|
|
|
|
def ServiceProvideMessage_TypeInfo():
|
|
r"""ServiceProvideMessage_TypeInfo() -> RTTI"""
|
|
return _client.ServiceProvideMessage_TypeInfo()
|
|
|
|
def ServiceProvideMessage_Cast(*args):
|
|
r"""
|
|
ServiceProvideMessage_Cast(BaseObject o) -> ServiceProvideMessage
|
|
ServiceProvideMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> ServiceProvideMessage
|
|
"""
|
|
return _client.ServiceProvideMessage_Cast(*args)
|
|
|
|
def ServiceProvideMessage_ConstCast(*args):
|
|
r"""
|
|
ServiceProvideMessage_ConstCast(BaseObject o) -> ServiceProvideMessage
|
|
ServiceProvideMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ServiceProvideMessage
|
|
"""
|
|
return _client.ServiceProvideMessage_ConstCast(*args)
|
|
|
|
class DatabaseRequestMessage(ServiceRequestMessage):
|
|
r"""Proxy of C++ Seiscomp::Client::DatabaseRequestMessage 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 _client.DatabaseRequestMessage_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _client.DatabaseRequestMessage_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(DatabaseRequestMessage self) -> char const *"""
|
|
return _client.DatabaseRequestMessage_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(DatabaseRequestMessage self) -> RTTI"""
|
|
return _client.DatabaseRequestMessage_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> DatabaseRequestMessage
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> DatabaseRequestMessage
|
|
"""
|
|
return _client.DatabaseRequestMessage_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> DatabaseRequestMessage
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DatabaseRequestMessage
|
|
"""
|
|
return _client.DatabaseRequestMessage_ConstCast(*args)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(DatabaseRequestMessage self) -> DatabaseRequestMessage
|
|
__init__(DatabaseRequestMessage self, char const * service) -> DatabaseRequestMessage
|
|
"""
|
|
_client.DatabaseRequestMessage_swiginit(self, _client.new_DatabaseRequestMessage(*args))
|
|
__swig_destroy__ = _client.delete_DatabaseRequestMessage
|
|
|
|
# Register DatabaseRequestMessage in _client:
|
|
_client.DatabaseRequestMessage_swigregister(DatabaseRequestMessage)
|
|
|
|
def DatabaseRequestMessage_ClassName():
|
|
r"""DatabaseRequestMessage_ClassName() -> char const *"""
|
|
return _client.DatabaseRequestMessage_ClassName()
|
|
|
|
def DatabaseRequestMessage_TypeInfo():
|
|
r"""DatabaseRequestMessage_TypeInfo() -> RTTI"""
|
|
return _client.DatabaseRequestMessage_TypeInfo()
|
|
|
|
def DatabaseRequestMessage_Cast(*args):
|
|
r"""
|
|
DatabaseRequestMessage_Cast(BaseObject o) -> DatabaseRequestMessage
|
|
DatabaseRequestMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> DatabaseRequestMessage
|
|
"""
|
|
return _client.DatabaseRequestMessage_Cast(*args)
|
|
|
|
def DatabaseRequestMessage_ConstCast(*args):
|
|
r"""
|
|
DatabaseRequestMessage_ConstCast(BaseObject o) -> DatabaseRequestMessage
|
|
DatabaseRequestMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DatabaseRequestMessage
|
|
"""
|
|
return _client.DatabaseRequestMessage_ConstCast(*args)
|
|
|
|
class DatabaseProvideMessage(ServiceProvideMessage):
|
|
r"""Proxy of C++ Seiscomp::Client::DatabaseProvideMessage 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 _client.DatabaseProvideMessage_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _client.DatabaseProvideMessage_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(DatabaseProvideMessage self) -> char const *"""
|
|
return _client.DatabaseProvideMessage_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(DatabaseProvideMessage self) -> RTTI"""
|
|
return _client.DatabaseProvideMessage_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> DatabaseProvideMessage
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> DatabaseProvideMessage
|
|
"""
|
|
return _client.DatabaseProvideMessage_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> DatabaseProvideMessage
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DatabaseProvideMessage
|
|
"""
|
|
return _client.DatabaseProvideMessage_ConstCast(*args)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(DatabaseProvideMessage self) -> DatabaseProvideMessage
|
|
__init__(DatabaseProvideMessage self, char const * service, char const * params) -> DatabaseProvideMessage
|
|
"""
|
|
_client.DatabaseProvideMessage_swiginit(self, _client.new_DatabaseProvideMessage(*args))
|
|
|
|
def database(self):
|
|
r"""database(DatabaseProvideMessage self) -> DatabaseInterface"""
|
|
return _client.DatabaseProvideMessage_database(self)
|
|
__swig_destroy__ = _client.delete_DatabaseProvideMessage
|
|
|
|
# Register DatabaseProvideMessage in _client:
|
|
_client.DatabaseProvideMessage_swigregister(DatabaseProvideMessage)
|
|
|
|
def DatabaseProvideMessage_ClassName():
|
|
r"""DatabaseProvideMessage_ClassName() -> char const *"""
|
|
return _client.DatabaseProvideMessage_ClassName()
|
|
|
|
def DatabaseProvideMessage_TypeInfo():
|
|
r"""DatabaseProvideMessage_TypeInfo() -> RTTI"""
|
|
return _client.DatabaseProvideMessage_TypeInfo()
|
|
|
|
def DatabaseProvideMessage_Cast(*args):
|
|
r"""
|
|
DatabaseProvideMessage_Cast(BaseObject o) -> DatabaseProvideMessage
|
|
DatabaseProvideMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> DatabaseProvideMessage
|
|
"""
|
|
return _client.DatabaseProvideMessage_Cast(*args)
|
|
|
|
def DatabaseProvideMessage_ConstCast(*args):
|
|
r"""
|
|
DatabaseProvideMessage_ConstCast(BaseObject o) -> DatabaseProvideMessage
|
|
DatabaseProvideMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DatabaseProvideMessage
|
|
"""
|
|
return _client.DatabaseProvideMessage_ConstCast(*args)
|
|
|
|
class RunningAverage(object):
|
|
r"""Proxy of C++ Seiscomp::Client::RunningAverage 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, timeSpanInSeconds):
|
|
r"""__init__(RunningAverage self, int timeSpanInSeconds) -> RunningAverage"""
|
|
_client.RunningAverage_swiginit(self, _client.new_RunningAverage(timeSpanInSeconds))
|
|
|
|
def timeSpan(self):
|
|
r"""timeSpan(RunningAverage self) -> int"""
|
|
return _client.RunningAverage_timeSpan(self)
|
|
|
|
def push(self, time, count=1):
|
|
r"""push(RunningAverage self, Time time, size_t count=1)"""
|
|
return _client.RunningAverage_push(self, time, count)
|
|
|
|
def count(self, time):
|
|
r"""count(RunningAverage self, Time time) -> int"""
|
|
return _client.RunningAverage_count(self, time)
|
|
|
|
def value(self, time):
|
|
r"""value(RunningAverage self, Time time) -> double"""
|
|
return _client.RunningAverage_value(self, time)
|
|
|
|
def last(self):
|
|
r"""last(RunningAverage self) -> Time"""
|
|
return _client.RunningAverage_last(self)
|
|
|
|
def dumpBins(self):
|
|
r"""dumpBins(RunningAverage self)"""
|
|
return _client.RunningAverage_dumpBins(self)
|
|
__swig_destroy__ = _client.delete_RunningAverage
|
|
|
|
# Register RunningAverage in _client:
|
|
_client.RunningAverage_swigregister(RunningAverage)
|
|
|
|
class ObjectMonitor(object):
|
|
r"""Proxy of C++ Seiscomp::Client::ObjectMonitor 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, timeSpanInSeconds):
|
|
r"""__init__(ObjectMonitor self, int timeSpanInSeconds) -> ObjectMonitor"""
|
|
_client.ObjectMonitor_swiginit(self, _client.new_ObjectMonitor(timeSpanInSeconds))
|
|
__swig_destroy__ = _client.delete_ObjectMonitor
|
|
|
|
def add(self, *args):
|
|
r"""add(ObjectMonitor self, std::string const & name, std::string const & channel="") -> RunningAverage"""
|
|
return _client.ObjectMonitor_add(self, *args)
|
|
|
|
def update(self, time):
|
|
r"""update(ObjectMonitor self, Time time)"""
|
|
return _client.ObjectMonitor_update(self, time)
|
|
|
|
def begin(self):
|
|
r"""begin(ObjectMonitor self) -> Seiscomp::Client::ObjectMonitor::const_iterator"""
|
|
return _client.ObjectMonitor_begin(self)
|
|
|
|
def end(self):
|
|
r"""end(ObjectMonitor self) -> Seiscomp::Client::ObjectMonitor::const_iterator"""
|
|
return _client.ObjectMonitor_end(self)
|
|
|
|
def size(self):
|
|
r"""size(ObjectMonitor self) -> size_t"""
|
|
return _client.ObjectMonitor_size(self)
|
|
|
|
# Register ObjectMonitor in _client:
|
|
_client.ObjectMonitor_swigregister(ObjectMonitor)
|
|
|
|
STARTED = _client.STARTED
|
|
|
|
FINISHED = _client.FINISHED
|
|
|
|
EApplicationStatusQuantity = _client.EApplicationStatusQuantity
|
|
|
|
class EApplicationStatusNames(object):
|
|
r"""Proxy of C++ Seiscomp::Client::EApplicationStatusNames 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):
|
|
r"""__init__(EApplicationStatusNames self) -> EApplicationStatusNames"""
|
|
_client.EApplicationStatusNames_swiginit(self, _client.new_EApplicationStatusNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _client.EApplicationStatusNames_name(i)
|
|
__swig_destroy__ = _client.delete_EApplicationStatusNames
|
|
|
|
# Register EApplicationStatusNames in _client:
|
|
_client.EApplicationStatusNames_swigregister(EApplicationStatusNames)
|
|
|
|
def EApplicationStatusNames_name(i):
|
|
r"""EApplicationStatusNames_name(int i) -> char const *"""
|
|
return _client.EApplicationStatusNames_name(i)
|
|
|
|
class ApplicationStatusMessage(seiscomp.core.Message):
|
|
r"""Proxy of C++ Seiscomp::Client::ApplicationStatusMessage 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 _client.ApplicationStatusMessage_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _client.ApplicationStatusMessage_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ApplicationStatusMessage self) -> char const *"""
|
|
return _client.ApplicationStatusMessage_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ApplicationStatusMessage self) -> RTTI"""
|
|
return _client.ApplicationStatusMessage_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ApplicationStatusMessage
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ApplicationStatusMessage
|
|
"""
|
|
return _client.ApplicationStatusMessage_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ApplicationStatusMessage
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ApplicationStatusMessage
|
|
"""
|
|
return _client.ApplicationStatusMessage_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ApplicationStatusMessage self, GenericArchive ar)"""
|
|
return _client.ApplicationStatusMessage_serialize(self, ar)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ApplicationStatusMessage self) -> ApplicationStatusMessage
|
|
__init__(ApplicationStatusMessage self, std::string const & module, Seiscomp::Client::ApplicationStatus status) -> ApplicationStatusMessage
|
|
__init__(ApplicationStatusMessage self, std::string const & module, std::string const & username, Seiscomp::Client::ApplicationStatus status) -> ApplicationStatusMessage
|
|
"""
|
|
_client.ApplicationStatusMessage_swiginit(self, _client.new_ApplicationStatusMessage(*args))
|
|
|
|
def empty(self):
|
|
r"""empty(ApplicationStatusMessage self) -> bool"""
|
|
return _client.ApplicationStatusMessage_empty(self)
|
|
|
|
def module(self):
|
|
r"""module(ApplicationStatusMessage self) -> std::string const &"""
|
|
return _client.ApplicationStatusMessage_module(self)
|
|
|
|
def username(self):
|
|
r"""username(ApplicationStatusMessage self) -> std::string const &"""
|
|
return _client.ApplicationStatusMessage_username(self)
|
|
|
|
def status(self):
|
|
r"""status(ApplicationStatusMessage self) -> Seiscomp::Client::ApplicationStatus"""
|
|
return _client.ApplicationStatusMessage_status(self)
|
|
__swig_destroy__ = _client.delete_ApplicationStatusMessage
|
|
|
|
# Register ApplicationStatusMessage in _client:
|
|
_client.ApplicationStatusMessage_swigregister(ApplicationStatusMessage)
|
|
|
|
def ApplicationStatusMessage_ClassName():
|
|
r"""ApplicationStatusMessage_ClassName() -> char const *"""
|
|
return _client.ApplicationStatusMessage_ClassName()
|
|
|
|
def ApplicationStatusMessage_TypeInfo():
|
|
r"""ApplicationStatusMessage_TypeInfo() -> RTTI"""
|
|
return _client.ApplicationStatusMessage_TypeInfo()
|
|
|
|
def ApplicationStatusMessage_Cast(*args):
|
|
r"""
|
|
ApplicationStatusMessage_Cast(BaseObject o) -> ApplicationStatusMessage
|
|
ApplicationStatusMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> ApplicationStatusMessage
|
|
"""
|
|
return _client.ApplicationStatusMessage_Cast(*args)
|
|
|
|
def ApplicationStatusMessage_ConstCast(*args):
|
|
r"""
|
|
ApplicationStatusMessage_ConstCast(BaseObject o) -> ApplicationStatusMessage
|
|
ApplicationStatusMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ApplicationStatusMessage
|
|
"""
|
|
return _client.ApplicationStatusMessage_ConstCast(*args)
|
|
|
|
class Notification(object):
|
|
r"""Proxy of C++ Seiscomp::Client::Notification class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
Object = _client.Notification_Object
|
|
|
|
Disconnect = _client.Notification_Disconnect
|
|
|
|
Reconnect = _client.Notification_Reconnect
|
|
|
|
Close = _client.Notification_Close
|
|
|
|
Timeout = _client.Notification_Timeout
|
|
|
|
AcquisitionFinished = _client.Notification_AcquisitionFinished
|
|
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Notification self) -> Notification
|
|
__init__(Notification self, BaseObject o) -> Notification
|
|
__init__(Notification self, int t) -> Notification
|
|
__init__(Notification self, int t, BaseObject o) -> Notification
|
|
"""
|
|
_client.Notification_swiginit(self, _client.new_Notification(*args))
|
|
object = property(_client.Notification_object_get, _client.Notification_object_set, doc=r"""object : p.Seiscomp::Core::BaseObject""")
|
|
type = property(_client.Notification_type_get, _client.Notification_type_set, doc=r"""type : int""")
|
|
__swig_destroy__ = _client.delete_Notification
|
|
|
|
# Register Notification in _client:
|
|
_client.Notification_swigregister(Notification)
|
|
|
|
class Application(seiscomp.system.SystemApplication):
|
|
r"""Proxy of C++ Seiscomp::Client::Application class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
MESSAGING = _client.Application_MESSAGING
|
|
|
|
DATABASE = _client.Application_DATABASE
|
|
|
|
CST_QUANTITY = _client.Application_CST_QUANTITY
|
|
|
|
|
|
def __init__(self, argc, argv):
|
|
r"""__init__(Application self, int argc, char ** argv) -> Application"""
|
|
|
|
argv = [ bytes(a.encode()) for a in argv ]
|
|
|
|
|
|
if self.__class__ == Application:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_client.Application_swiginit(self, _client.new_Application(_self, argc, argv))
|
|
__swig_destroy__ = _client.delete_Application
|
|
|
|
def agencyID(self):
|
|
r"""agencyID(Application self) -> std::string const &"""
|
|
return _client.Application_agencyID(self)
|
|
|
|
def author(self):
|
|
r"""author(Application self) -> std::string const &"""
|
|
return _client.Application_author(self)
|
|
|
|
def isAgencyIDAllowed(self, agencyID):
|
|
r"""isAgencyIDAllowed(Application self, std::string const & agencyID) -> bool"""
|
|
return _client.Application_isAgencyIDAllowed(self, agencyID)
|
|
|
|
def isAgencyIDBlocked(self, agencyID):
|
|
r"""isAgencyIDBlocked(Application self, std::string const & agencyID) -> bool"""
|
|
return _client.Application_isAgencyIDBlocked(self, agencyID)
|
|
|
|
def exit(self, returnCode):
|
|
r"""exit(Application self, int returnCode)"""
|
|
return _client.Application_exit(self, returnCode)
|
|
|
|
def connection(self):
|
|
r"""connection(Application self) -> Connection"""
|
|
return _client.Application_connection(self)
|
|
|
|
def databaseType(self):
|
|
r"""databaseType(Application self) -> std::string const &"""
|
|
return _client.Application_databaseType(self)
|
|
|
|
def databaseParameters(self):
|
|
r"""databaseParameters(Application self) -> std::string const &"""
|
|
return _client.Application_databaseParameters(self)
|
|
|
|
def database(self):
|
|
r"""database(Application self) -> DatabaseInterface"""
|
|
return _client.Application_database(self)
|
|
|
|
def databaseURI(self):
|
|
r"""databaseURI(Application self) -> std::string const &"""
|
|
return _client.Application_databaseURI(self)
|
|
|
|
def query(self):
|
|
r"""query(Application self) -> DatabaseQuery"""
|
|
return _client.Application_query(self)
|
|
|
|
def recordStreamURL(self):
|
|
r"""recordStreamURL(Application self) -> std::string const &"""
|
|
return _client.Application_recordStreamURL(self)
|
|
|
|
def cities(self):
|
|
r"""cities(Application self) -> CityListD"""
|
|
return _client.Application_cities(self)
|
|
|
|
def nearestCity(self, lat, lon, maxDist, minPopulation):
|
|
r"""nearestCity(Application self, double lat, double lon, double maxDist, double minPopulation) -> CityD"""
|
|
return _client.Application_nearestCity(self, lat, lon, maxDist, minPopulation)
|
|
|
|
def configModule(self):
|
|
r"""configModule(Application self) -> ConfigModule"""
|
|
return _client.Application_configModule(self)
|
|
|
|
def isStationEnabled(self, networkCode, stationCode):
|
|
r"""isStationEnabled(Application self, std::string const & networkCode, std::string const & stationCode) -> bool"""
|
|
return _client.Application_isStationEnabled(self, networkCode, stationCode)
|
|
|
|
def messagingURL(self):
|
|
r"""messagingURL(Application self) -> std::string const &"""
|
|
return _client.Application_messagingURL(self)
|
|
|
|
def messagingCertificate(self):
|
|
r"""messagingCertificate(Application self) -> std::string const &"""
|
|
return _client.Application_messagingCertificate(self)
|
|
|
|
def enableTimer(self, seconds):
|
|
r"""enableTimer(Application self, unsigned int seconds)"""
|
|
return _client.Application_enableTimer(self, seconds)
|
|
|
|
def disableTimer(self):
|
|
r"""disableTimer(Application self)"""
|
|
return _client.Application_disableTimer(self)
|
|
|
|
def sendNotification(self, arg2):
|
|
r"""sendNotification(Application self, Notification arg2)"""
|
|
return _client.Application_sendNotification(self, arg2)
|
|
|
|
def waitEvent(self):
|
|
r"""waitEvent(Application self) -> bool"""
|
|
return _client.Application_waitEvent(self)
|
|
|
|
def setPrimaryMessagingGroup(self, arg2):
|
|
r"""setPrimaryMessagingGroup(Application self, std::string const & arg2)"""
|
|
return _client.Application_setPrimaryMessagingGroup(self, arg2)
|
|
|
|
def primaryMessagingGroup(self):
|
|
r"""primaryMessagingGroup(Application self) -> std::string const &"""
|
|
return _client.Application_primaryMessagingGroup(self)
|
|
|
|
def setMessagingUsername(self, arg2):
|
|
r"""setMessagingUsername(Application self, std::string const & arg2)"""
|
|
return _client.Application_setMessagingUsername(self, arg2)
|
|
|
|
def addMessagingSubscription(self, arg2):
|
|
r"""addMessagingSubscription(Application self, std::string const & arg2)"""
|
|
return _client.Application_addMessagingSubscription(self, arg2)
|
|
|
|
def setDatabaseEnabled(self, enable, tryToFetch):
|
|
r"""setDatabaseEnabled(Application self, bool enable, bool tryToFetch)"""
|
|
return _client.Application_setDatabaseEnabled(self, enable, tryToFetch)
|
|
|
|
def isDatabaseEnabled(self):
|
|
r"""isDatabaseEnabled(Application self) -> bool"""
|
|
return _client.Application_isDatabaseEnabled(self)
|
|
|
|
def isInventoryDatabaseEnabled(self):
|
|
r"""isInventoryDatabaseEnabled(Application self) -> bool"""
|
|
return _client.Application_isInventoryDatabaseEnabled(self)
|
|
|
|
def isConfigDatabaseEnabled(self):
|
|
r"""isConfigDatabaseEnabled(Application self) -> bool"""
|
|
return _client.Application_isConfigDatabaseEnabled(self)
|
|
|
|
def setMessagingEnabled(self, enable):
|
|
r"""setMessagingEnabled(Application self, bool enable)"""
|
|
return _client.Application_setMessagingEnabled(self, enable)
|
|
|
|
def isMessagingEnabled(self):
|
|
r"""isMessagingEnabled(Application self) -> bool"""
|
|
return _client.Application_isMessagingEnabled(self)
|
|
|
|
def setMembershipMessagesEnabled(self, enable):
|
|
r"""setMembershipMessagesEnabled(Application self, bool enable)"""
|
|
return _client.Application_setMembershipMessagesEnabled(self, enable)
|
|
|
|
def areMembershipMessagesEnabled(self):
|
|
r"""areMembershipMessagesEnabled(Application self) -> bool"""
|
|
return _client.Application_areMembershipMessagesEnabled(self)
|
|
|
|
def setStartStopMessagesEnabled(self, enable):
|
|
r"""setStartStopMessagesEnabled(Application self, bool enable)"""
|
|
return _client.Application_setStartStopMessagesEnabled(self, enable)
|
|
|
|
def areStartStopMessagesEnabled(self):
|
|
r"""areStartStopMessagesEnabled(Application self) -> bool"""
|
|
return _client.Application_areStartStopMessagesEnabled(self)
|
|
|
|
def setAutoShutdownEnabled(self, enable):
|
|
r"""setAutoShutdownEnabled(Application self, bool enable)"""
|
|
return _client.Application_setAutoShutdownEnabled(self, enable)
|
|
|
|
def isAutoShutdownEnabled(self):
|
|
r"""isAutoShutdownEnabled(Application self) -> bool"""
|
|
return _client.Application_isAutoShutdownEnabled(self)
|
|
|
|
def setRecordStreamEnabled(self, enable):
|
|
r"""setRecordStreamEnabled(Application self, bool enable)"""
|
|
return _client.Application_setRecordStreamEnabled(self, enable)
|
|
|
|
def isRecordStreamEnabled(self):
|
|
r"""isRecordStreamEnabled(Application self) -> bool"""
|
|
return _client.Application_isRecordStreamEnabled(self)
|
|
|
|
def setLoadStationsEnabled(self, enable):
|
|
r"""setLoadStationsEnabled(Application self, bool enable)"""
|
|
return _client.Application_setLoadStationsEnabled(self, enable)
|
|
|
|
def isLoadStationsEnabled(self):
|
|
r"""isLoadStationsEnabled(Application self) -> bool"""
|
|
return _client.Application_isLoadStationsEnabled(self)
|
|
|
|
def setLoadInventoryEnabled(self, enable):
|
|
r"""setLoadInventoryEnabled(Application self, bool enable)"""
|
|
return _client.Application_setLoadInventoryEnabled(self, enable)
|
|
|
|
def isLoadInventoryEnabled(self):
|
|
r"""isLoadInventoryEnabled(Application self) -> bool"""
|
|
return _client.Application_isLoadInventoryEnabled(self)
|
|
|
|
def setLoadConfigModuleEnabled(self, enable):
|
|
r"""setLoadConfigModuleEnabled(Application self, bool enable)"""
|
|
return _client.Application_setLoadConfigModuleEnabled(self, enable)
|
|
|
|
def isLoadConfigModuleEnabled(self):
|
|
r"""isLoadConfigModuleEnabled(Application self) -> bool"""
|
|
return _client.Application_isLoadConfigModuleEnabled(self)
|
|
|
|
def setLoadCitiesEnabled(self, enable):
|
|
r"""setLoadCitiesEnabled(Application self, bool enable)"""
|
|
return _client.Application_setLoadCitiesEnabled(self, enable)
|
|
|
|
def isLoadCitiesEnabled(self):
|
|
r"""isLoadCitiesEnabled(Application self) -> bool"""
|
|
return _client.Application_isLoadCitiesEnabled(self)
|
|
|
|
def setLoadRegionsEnabled(self, enable):
|
|
r"""setLoadRegionsEnabled(Application self, bool enable)"""
|
|
return _client.Application_setLoadRegionsEnabled(self, enable)
|
|
|
|
def isLoadRegionsEnabled(self):
|
|
r"""isLoadRegionsEnabled(Application self) -> bool"""
|
|
return _client.Application_isLoadRegionsEnabled(self)
|
|
|
|
def setAutoApplyNotifierEnabled(self, enable):
|
|
r"""setAutoApplyNotifierEnabled(Application self, bool enable)"""
|
|
return _client.Application_setAutoApplyNotifierEnabled(self, enable)
|
|
|
|
def isAutoApplyNotifierEnabled(self):
|
|
r"""isAutoApplyNotifierEnabled(Application self) -> bool"""
|
|
return _client.Application_isAutoApplyNotifierEnabled(self)
|
|
|
|
def setInterpretNotifierEnabled(self, enable):
|
|
r"""setInterpretNotifierEnabled(Application self, bool enable)"""
|
|
return _client.Application_setInterpretNotifierEnabled(self, enable)
|
|
|
|
def isInterpretNotifierEnabled(self):
|
|
r"""isInterpretNotifierEnabled(Application self) -> bool"""
|
|
return _client.Application_isInterpretNotifierEnabled(self)
|
|
|
|
def hasCustomPublicIDPattern(self):
|
|
r"""hasCustomPublicIDPattern(Application self) -> bool"""
|
|
return _client.Application_hasCustomPublicIDPattern(self)
|
|
|
|
def setConnectionRetries(self, arg2):
|
|
r"""setConnectionRetries(Application self, unsigned int arg2)"""
|
|
return _client.Application_setConnectionRetries(self, arg2)
|
|
|
|
def setConfigModuleName(self, module):
|
|
r"""setConfigModuleName(Application self, std::string const & module)"""
|
|
return _client.Application_setConfigModuleName(self, module)
|
|
|
|
def configModuleName(self):
|
|
r"""configModuleName(Application self) -> std::string const &"""
|
|
return _client.Application_configModuleName(self)
|
|
|
|
def setShutdownMasterModule(self, module):
|
|
r"""setShutdownMasterModule(Application self, std::string const & module)"""
|
|
return _client.Application_setShutdownMasterModule(self, module)
|
|
|
|
def setShutdownMasterUsername(self, username):
|
|
r"""setShutdownMasterUsername(Application self, std::string const & username)"""
|
|
return _client.Application_setShutdownMasterUsername(self, username)
|
|
|
|
def addInputObjectLog(self, *args):
|
|
r"""addInputObjectLog(Application self, std::string const & name, std::string const & channel="") -> RunningAverage"""
|
|
return _client.Application_addInputObjectLog(self, *args)
|
|
|
|
def addOutputObjectLog(self, *args):
|
|
r"""addOutputObjectLog(Application self, std::string const & name, std::string const & channel="") -> RunningAverage"""
|
|
return _client.Application_addOutputObjectLog(self, *args)
|
|
|
|
def logObject(self, log, timestamp, count=1):
|
|
r"""logObject(Application self, RunningAverage log, Time timestamp, size_t count=1)"""
|
|
return _client.Application_logObject(self, log, timestamp, count)
|
|
|
|
def reloadInventory(self):
|
|
r"""reloadInventory(Application self) -> bool"""
|
|
return _client.Application_reloadInventory(self)
|
|
|
|
def reloadBindings(self):
|
|
r"""reloadBindings(Application self) -> bool"""
|
|
return _client.Application_reloadBindings(self)
|
|
|
|
def injectMessage(self, msg, pkt=None):
|
|
r"""injectMessage(Application self, Message msg, Packet pkt=None)"""
|
|
return _client.Application_injectMessage(self, msg, pkt)
|
|
|
|
def handleNotifier(self, notifier):
|
|
r"""handleNotifier(Application self, Notifier notifier)"""
|
|
return _client.Application_handleNotifier(self, notifier)
|
|
|
|
@staticmethod
|
|
def Instance():
|
|
r"""Instance() -> Application"""
|
|
return _client.Application_Instance()
|
|
|
|
def validateParameters(self):
|
|
r"""validateParameters(Application self) -> bool"""
|
|
return _client.Application_validateParameters(self)
|
|
|
|
def handlePreFork(self):
|
|
r"""handlePreFork(Application self) -> bool"""
|
|
return _client.Application_handlePreFork(self)
|
|
|
|
def init(self):
|
|
r"""init(Application self) -> bool"""
|
|
return _client.Application_init(self)
|
|
|
|
def run(self):
|
|
r"""run(Application self) -> bool"""
|
|
return _client.Application_run(self)
|
|
|
|
def idle(self):
|
|
r"""idle(Application self)"""
|
|
return _client.Application_idle(self)
|
|
|
|
def done(self):
|
|
r"""done(Application self)"""
|
|
return _client.Application_done(self)
|
|
|
|
def initConfiguration(self):
|
|
r"""initConfiguration(Application self) -> bool"""
|
|
return _client.Application_initConfiguration(self)
|
|
|
|
def initDatabase(self):
|
|
r"""initDatabase(Application self) -> bool"""
|
|
return _client.Application_initDatabase(self)
|
|
|
|
def initSubscriptions(self):
|
|
r"""initSubscriptions(Application self) -> bool"""
|
|
return _client.Application_initSubscriptions(self)
|
|
|
|
def handleEndAcquisition(self):
|
|
r"""handleEndAcquisition(Application self)"""
|
|
return _client.Application_handleEndAcquisition(self)
|
|
|
|
def dispatch(self, arg0):
|
|
r"""dispatch(Application self, BaseObject arg0) -> bool"""
|
|
return _client.Application_dispatch(self, arg0)
|
|
|
|
def dispatchNotification(self, type, arg0):
|
|
r"""dispatchNotification(Application self, int type, BaseObject arg0) -> bool"""
|
|
return _client.Application_dispatchNotification(self, type, arg0)
|
|
|
|
def handleTimeout(self):
|
|
r"""handleTimeout(Application self)"""
|
|
return _client.Application_handleTimeout(self)
|
|
|
|
def handleClose(self):
|
|
r"""handleClose(Application self) -> bool"""
|
|
return _client.Application_handleClose(self)
|
|
|
|
def handleAutoShutdown(self):
|
|
r"""handleAutoShutdown(Application self)"""
|
|
return _client.Application_handleAutoShutdown(self)
|
|
|
|
def handleDisconnect(self):
|
|
r"""handleDisconnect(Application self)"""
|
|
return _client.Application_handleDisconnect(self)
|
|
|
|
def handleReconnect(self):
|
|
r"""handleReconnect(Application self)"""
|
|
return _client.Application_handleReconnect(self)
|
|
|
|
def handleNetworkMessage(self, msg):
|
|
r"""handleNetworkMessage(Application self, Packet msg)"""
|
|
return _client.Application_handleNetworkMessage(self, msg)
|
|
|
|
def handleMessage(self, msg):
|
|
r"""handleMessage(Application self, Message msg)"""
|
|
return _client.Application_handleMessage(self, msg)
|
|
|
|
def addObject(self, parentID, arg0):
|
|
r"""addObject(Application self, std::string const & parentID, Object arg0)"""
|
|
return _client.Application_addObject(self, parentID, arg0)
|
|
|
|
def removeObject(self, parentID, arg0):
|
|
r"""removeObject(Application self, std::string const & parentID, Object arg0)"""
|
|
return _client.Application_removeObject(self, parentID, arg0)
|
|
|
|
def updateObject(self, parentID, arg0):
|
|
r"""updateObject(Application self, std::string const & parentID, Object arg0)"""
|
|
return _client.Application_updateObject(self, parentID, arg0)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_client.disown_Application(self)
|
|
return weakref.proxy(self)
|
|
|
|
def createBaseCommandLineDescription(self):
|
|
r"""createBaseCommandLineDescription(Application self)"""
|
|
return _client.Application_createBaseCommandLineDescription(self)
|
|
|
|
def createCommandLineDescription(self):
|
|
r"""createCommandLineDescription(Application self)"""
|
|
return _client.Application_createCommandLineDescription(self)
|
|
|
|
def handleCommandLineOptions(self):
|
|
r"""handleCommandLineOptions(Application self) -> bool"""
|
|
return _client.Application_handleCommandLineOptions(self)
|
|
|
|
def forkProcess(self):
|
|
r"""forkProcess(Application self) -> bool"""
|
|
return _client.Application_forkProcess(self)
|
|
|
|
def initPlugins(self):
|
|
r"""initPlugins(Application self) -> bool"""
|
|
return _client.Application_initPlugins(self)
|
|
|
|
def printVersion(self):
|
|
r"""printVersion(Application self)"""
|
|
return _client.Application_printVersion(self)
|
|
|
|
def printConfigVariables(self):
|
|
r"""printConfigVariables(Application self)"""
|
|
return _client.Application_printConfigVariables(self)
|
|
|
|
def schemaValidationNames(self, modules, plugins):
|
|
r"""schemaValidationNames(Application self, VectorStr modules, VectorStr plugins)"""
|
|
return _client.Application_schemaValidationNames(self, modules, plugins)
|
|
|
|
def validateSchemaParameters(self):
|
|
r"""validateSchemaParameters(Application self) -> bool"""
|
|
return _client.Application_validateSchemaParameters(self)
|
|
|
|
def handleInitializationError(self, stage):
|
|
r"""handleInitializationError(Application self, int stage) -> bool"""
|
|
return _client.Application_handleInitializationError(self, stage)
|
|
|
|
def showMessage(self, arg0):
|
|
r"""showMessage(Application self, char const * arg0)"""
|
|
return _client.Application_showMessage(self, arg0)
|
|
|
|
def showWarning(self, arg0):
|
|
r"""showWarning(Application self, char const * arg0)"""
|
|
return _client.Application_showWarning(self, arg0)
|
|
|
|
# Register Application in _client:
|
|
_client.Application_swigregister(Application)
|
|
|
|
def Application_Instance():
|
|
r"""Application_Instance() -> Application"""
|
|
return _client.Application_Instance()
|
|
|
|
class StreamApplication(Application):
|
|
r"""Proxy of C++ Seiscomp::Client::StreamApplication 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, argc, argv):
|
|
r"""__init__(StreamApplication self, int argc, char ** argv) -> StreamApplication"""
|
|
|
|
argv = [ bytes(a.encode()) for a in argv ]
|
|
|
|
|
|
if self.__class__ == StreamApplication:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_client.StreamApplication_swiginit(self, _client.new_StreamApplication(_self, argc, argv))
|
|
__swig_destroy__ = _client.delete_StreamApplication
|
|
|
|
def openStream(self):
|
|
r"""openStream(StreamApplication self) -> bool"""
|
|
return _client.StreamApplication_openStream(self)
|
|
|
|
def closeStream(self):
|
|
r"""closeStream(StreamApplication self)"""
|
|
return _client.StreamApplication_closeStream(self)
|
|
|
|
def recordStream(self):
|
|
r"""recordStream(StreamApplication self) -> RecordStream"""
|
|
return _client.StreamApplication_recordStream(self)
|
|
|
|
def addStation(self, networkCode, stationCode):
|
|
r"""addStation(StreamApplication self, std::string const & networkCode, std::string const & stationCode) -> bool"""
|
|
return _client.StreamApplication_addStation(self, networkCode, stationCode)
|
|
|
|
def addStream(self, networkCode, stationCode, locationCode, channelCode):
|
|
r"""addStream(StreamApplication self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode) -> bool"""
|
|
return _client.StreamApplication_addStream(self, networkCode, stationCode, locationCode, channelCode)
|
|
|
|
def setStartTime(self, arg2):
|
|
r"""setStartTime(StreamApplication self, Time arg2)"""
|
|
return _client.StreamApplication_setStartTime(self, arg2)
|
|
|
|
def setEndTime(self, arg2):
|
|
r"""setEndTime(StreamApplication self, Time arg2)"""
|
|
return _client.StreamApplication_setEndTime(self, arg2)
|
|
|
|
def setTimeWindow(self, arg2):
|
|
r"""setTimeWindow(StreamApplication self, Seiscomp::Core::TimeWindow const & arg2) -> bool"""
|
|
return _client.StreamApplication_setTimeWindow(self, arg2)
|
|
|
|
def setAutoAcquisitionStart(self, arg2):
|
|
r"""setAutoAcquisitionStart(StreamApplication self, bool arg2)"""
|
|
return _client.StreamApplication_setAutoAcquisitionStart(self, arg2)
|
|
|
|
def setAutoCloseOnAcquisitionFinished(self, arg2):
|
|
r"""setAutoCloseOnAcquisitionFinished(StreamApplication self, bool arg2)"""
|
|
return _client.StreamApplication_setAutoCloseOnAcquisitionFinished(self, arg2)
|
|
|
|
def setRecordInputHint(self, hint):
|
|
r"""setRecordInputHint(StreamApplication self, Seiscomp::Record::Hint hint)"""
|
|
return _client.StreamApplication_setRecordInputHint(self, hint)
|
|
|
|
def setRecordDatatype(self, datatype):
|
|
r"""setRecordDatatype(StreamApplication self, Seiscomp::Array::DataType datatype)"""
|
|
return _client.StreamApplication_setRecordDatatype(self, datatype)
|
|
|
|
def recordDataType(self):
|
|
r"""recordDataType(StreamApplication self) -> Seiscomp::Array::DataType"""
|
|
return _client.StreamApplication_recordDataType(self)
|
|
|
|
def startRecordThread(self):
|
|
r"""startRecordThread(StreamApplication self)"""
|
|
return _client.StreamApplication_startRecordThread(self)
|
|
|
|
def waitForRecordThread(self):
|
|
r"""waitForRecordThread(StreamApplication self)"""
|
|
return _client.StreamApplication_waitForRecordThread(self)
|
|
|
|
def isRecordThreadActive(self):
|
|
r"""isRecordThreadActive(StreamApplication self) -> bool"""
|
|
return _client.StreamApplication_isRecordThreadActive(self)
|
|
|
|
def init(self):
|
|
r"""init(StreamApplication self) -> bool"""
|
|
return _client.StreamApplication_init(self)
|
|
|
|
def run(self):
|
|
r"""run(StreamApplication self) -> bool"""
|
|
return _client.StreamApplication_run(self)
|
|
|
|
def done(self):
|
|
r"""done(StreamApplication self)"""
|
|
return _client.StreamApplication_done(self)
|
|
|
|
def dispatch(self, obj):
|
|
r"""dispatch(StreamApplication self, BaseObject obj) -> bool"""
|
|
return _client.StreamApplication_dispatch(self, obj)
|
|
|
|
def handleRecord(self, rec):
|
|
r"""handleRecord(StreamApplication self, Record rec)"""
|
|
return _client.StreamApplication_handleRecord(self, rec)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_client.disown_StreamApplication(self)
|
|
return weakref.proxy(self)
|
|
|
|
def createBaseCommandLineDescription(self):
|
|
r"""createBaseCommandLineDescription(StreamApplication self)"""
|
|
return _client.StreamApplication_createBaseCommandLineDescription(self)
|
|
|
|
def createCommandLineDescription(self):
|
|
r"""createCommandLineDescription(StreamApplication self)"""
|
|
return _client.StreamApplication_createCommandLineDescription(self)
|
|
|
|
def handleCommandLineOptions(self):
|
|
r"""handleCommandLineOptions(StreamApplication self) -> bool"""
|
|
return _client.StreamApplication_handleCommandLineOptions(self)
|
|
|
|
def handlePreFork(self):
|
|
r"""handlePreFork(StreamApplication self) -> bool"""
|
|
return _client.StreamApplication_handlePreFork(self)
|
|
|
|
def validateParameters(self):
|
|
r"""validateParameters(StreamApplication self) -> bool"""
|
|
return _client.StreamApplication_validateParameters(self)
|
|
|
|
def forkProcess(self):
|
|
r"""forkProcess(StreamApplication self) -> bool"""
|
|
return _client.StreamApplication_forkProcess(self)
|
|
|
|
def initConfiguration(self):
|
|
r"""initConfiguration(StreamApplication self) -> bool"""
|
|
return _client.StreamApplication_initConfiguration(self)
|
|
|
|
def initPlugins(self):
|
|
r"""initPlugins(StreamApplication self) -> bool"""
|
|
return _client.StreamApplication_initPlugins(self)
|
|
|
|
def printVersion(self):
|
|
r"""printVersion(StreamApplication self)"""
|
|
return _client.StreamApplication_printVersion(self)
|
|
|
|
def printConfigVariables(self):
|
|
r"""printConfigVariables(StreamApplication self)"""
|
|
return _client.StreamApplication_printConfigVariables(self)
|
|
|
|
def schemaValidationNames(self, modules, plugins):
|
|
r"""schemaValidationNames(StreamApplication self, VectorStr modules, VectorStr plugins)"""
|
|
return _client.StreamApplication_schemaValidationNames(self, modules, plugins)
|
|
|
|
def validateSchemaParameters(self):
|
|
r"""validateSchemaParameters(StreamApplication self) -> bool"""
|
|
return _client.StreamApplication_validateSchemaParameters(self)
|
|
|
|
def handleInitializationError(self, stage):
|
|
r"""handleInitializationError(StreamApplication self, int stage) -> bool"""
|
|
return _client.StreamApplication_handleInitializationError(self, stage)
|
|
|
|
def showMessage(self, arg0):
|
|
r"""showMessage(StreamApplication self, char const * arg0)"""
|
|
return _client.StreamApplication_showMessage(self, arg0)
|
|
|
|
def showWarning(self, arg0):
|
|
r"""showWarning(StreamApplication self, char const * arg0)"""
|
|
return _client.StreamApplication_showWarning(self, arg0)
|
|
|
|
def idle(self):
|
|
r"""idle(StreamApplication self)"""
|
|
return _client.StreamApplication_idle(self)
|
|
|
|
def initDatabase(self):
|
|
r"""initDatabase(StreamApplication self) -> bool"""
|
|
return _client.StreamApplication_initDatabase(self)
|
|
|
|
def initSubscriptions(self):
|
|
r"""initSubscriptions(StreamApplication self) -> bool"""
|
|
return _client.StreamApplication_initSubscriptions(self)
|
|
|
|
def handleEndAcquisition(self):
|
|
r"""handleEndAcquisition(StreamApplication self)"""
|
|
return _client.StreamApplication_handleEndAcquisition(self)
|
|
|
|
def dispatchNotification(self, type, arg0):
|
|
r"""dispatchNotification(StreamApplication self, int type, BaseObject arg0) -> bool"""
|
|
return _client.StreamApplication_dispatchNotification(self, type, arg0)
|
|
|
|
def handleTimeout(self):
|
|
r"""handleTimeout(StreamApplication self)"""
|
|
return _client.StreamApplication_handleTimeout(self)
|
|
|
|
def handleClose(self):
|
|
r"""handleClose(StreamApplication self) -> bool"""
|
|
return _client.StreamApplication_handleClose(self)
|
|
|
|
def handleAutoShutdown(self):
|
|
r"""handleAutoShutdown(StreamApplication self)"""
|
|
return _client.StreamApplication_handleAutoShutdown(self)
|
|
|
|
def handleDisconnect(self):
|
|
r"""handleDisconnect(StreamApplication self)"""
|
|
return _client.StreamApplication_handleDisconnect(self)
|
|
|
|
def handleReconnect(self):
|
|
r"""handleReconnect(StreamApplication self)"""
|
|
return _client.StreamApplication_handleReconnect(self)
|
|
|
|
def handleNetworkMessage(self, msg):
|
|
r"""handleNetworkMessage(StreamApplication self, Packet msg)"""
|
|
return _client.StreamApplication_handleNetworkMessage(self, msg)
|
|
|
|
def handleMessage(self, msg):
|
|
r"""handleMessage(StreamApplication self, Message msg)"""
|
|
return _client.StreamApplication_handleMessage(self, msg)
|
|
|
|
def addObject(self, parentID, arg0):
|
|
r"""addObject(StreamApplication self, std::string const & parentID, Object arg0)"""
|
|
return _client.StreamApplication_addObject(self, parentID, arg0)
|
|
|
|
def removeObject(self, parentID, arg0):
|
|
r"""removeObject(StreamApplication self, std::string const & parentID, Object arg0)"""
|
|
return _client.StreamApplication_removeObject(self, parentID, arg0)
|
|
|
|
def updateObject(self, parentID, arg0):
|
|
r"""updateObject(StreamApplication self, std::string const & parentID, Object arg0)"""
|
|
return _client.StreamApplication_updateObject(self, parentID, arg0)
|
|
|
|
# Register StreamApplication in _client:
|
|
_client.StreamApplication_swigregister(StreamApplication)
|
|
|
|
class StationLocation(object):
|
|
r"""Proxy of C++ Seiscomp::Client::StationLocation 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__(StationLocation self) -> StationLocation
|
|
__init__(StationLocation self, double lat, double lon, double elevation) -> StationLocation
|
|
"""
|
|
_client.StationLocation_swiginit(self, _client.new_StationLocation(*args))
|
|
latitude = property(_client.StationLocation_latitude_get, _client.StationLocation_latitude_set, doc=r"""latitude : double""")
|
|
longitude = property(_client.StationLocation_longitude_get, _client.StationLocation_longitude_set, doc=r"""longitude : double""")
|
|
elevation = property(_client.StationLocation_elevation_get, _client.StationLocation_elevation_set, doc=r"""elevation : double""")
|
|
__swig_destroy__ = _client.delete_StationLocation
|
|
|
|
# Register StationLocation in _client:
|
|
_client.StationLocation_swigregister(StationLocation)
|
|
|
|
class Inventory(object):
|
|
r"""Proxy of C++ Seiscomp::Client::Inventory 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")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def Instance():
|
|
r"""Instance() -> Inventory"""
|
|
return _client.Inventory_Instance()
|
|
|
|
@staticmethod
|
|
def Reset():
|
|
r"""Reset()"""
|
|
return _client.Inventory_Reset()
|
|
|
|
def load(self, *args):
|
|
r"""
|
|
load(Inventory self, char const * filename)
|
|
load(Inventory self, DatabaseReader arg2)
|
|
"""
|
|
return _client.Inventory_load(self, *args)
|
|
|
|
def setInventory(self, arg2):
|
|
r"""setInventory(Inventory self, Inventory arg2)"""
|
|
return _client.Inventory_setInventory(self, arg2)
|
|
|
|
def filter(self, networkTypeFW, stationTypeFW):
|
|
r"""filter(Inventory self, Seiscomp::Util::StringFirewall const * networkTypeFW, Seiscomp::Util::StringFirewall const * stationTypeFW) -> int"""
|
|
return _client.Inventory_filter(self, networkTypeFW, stationTypeFW)
|
|
|
|
def loadStations(self, arg2):
|
|
r"""loadStations(Inventory self, DatabaseReader arg2)"""
|
|
return _client.Inventory_loadStations(self, arg2)
|
|
|
|
def stationLocation(self, networkCode, stationCode, arg4):
|
|
r"""stationLocation(Inventory self, std::string const & networkCode, std::string const & stationCode, Time arg4) -> StationLocation"""
|
|
return _client.Inventory_stationLocation(self, networkCode, stationCode, arg4)
|
|
|
|
def getStation(self, *args):
|
|
r"""
|
|
getStation(Inventory self, std::string const & networkCode, std::string const & stationCode, Time arg4, Seiscomp::DataModel::InventoryError * error=None) -> Station
|
|
getStation(Inventory self, Pick arg2) -> Station
|
|
"""
|
|
return _client.Inventory_getStation(self, *args)
|
|
|
|
def getSensorLocation(self, *args):
|
|
r"""
|
|
getSensorLocation(Inventory self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, Time arg5, Seiscomp::DataModel::InventoryError * error=None) -> SensorLocation
|
|
getSensorLocation(Inventory self, Pick arg2) -> SensorLocation
|
|
"""
|
|
return _client.Inventory_getSensorLocation(self, *args)
|
|
|
|
def getStream(self, *args):
|
|
r"""
|
|
getStream(Inventory self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode, Time arg6, Seiscomp::DataModel::InventoryError * error=None) -> Stream
|
|
getStream(Inventory self, Pick arg2) -> Stream
|
|
"""
|
|
return _client.Inventory_getStream(self, *args)
|
|
|
|
def getThreeComponents(self, *args):
|
|
r"""
|
|
getThreeComponents(Inventory self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode, Time arg6) -> ThreeComponents
|
|
getThreeComponents(Inventory self, Pick arg2) -> ThreeComponents
|
|
"""
|
|
return _client.Inventory_getThreeComponents(self, *args)
|
|
|
|
def getGain(self, networkCode, stationCode, locationCode, channelCode, arg6):
|
|
r"""getGain(Inventory self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode, Time arg6) -> double"""
|
|
return _client.Inventory_getGain(self, networkCode, stationCode, locationCode, channelCode, arg6)
|
|
|
|
def getAllStations(self, arg2, arg3):
|
|
r"""getAllStations(Inventory self, Seiscomp::Client::StationList & arg2, Time arg3) -> int"""
|
|
return _client.Inventory_getAllStations(self, arg2, arg3)
|
|
|
|
def inventory(self):
|
|
r"""inventory(Inventory self) -> Inventory"""
|
|
return _client.Inventory_inventory(self)
|
|
__swig_destroy__ = _client.delete_Inventory
|
|
|
|
# Register Inventory in _client:
|
|
_client.Inventory_swigregister(Inventory)
|
|
|
|
def Inventory_Instance():
|
|
r"""Inventory_Instance() -> Inventory"""
|
|
return _client.Inventory_Instance()
|
|
|
|
def Inventory_Reset():
|
|
r"""Inventory_Reset()"""
|
|
return _client.Inventory_Reset()
|
|
|
|
class ConfigDB(object):
|
|
r"""Proxy of C++ Seiscomp::Client::ConfigDB 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")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def Instance():
|
|
r"""Instance() -> ConfigDB"""
|
|
return _client.ConfigDB_Instance()
|
|
|
|
@staticmethod
|
|
def Reset():
|
|
r"""Reset()"""
|
|
return _client.ConfigDB_Reset()
|
|
|
|
def load(self, *args):
|
|
r"""
|
|
load(ConfigDB self, DatabaseReader reader, Seiscomp::Core::Optional< std::string >::Impl const & moduleName=Unset, Seiscomp::Core::Optional< std::string >::Impl const & networkCode=Unset, Seiscomp::Core::Optional< std::string >::Impl const & stationCode=Unset, Seiscomp::Core::Optional< std::string >::Impl const & setupName=Unset, std::set< std::string,std::less< std::string >,std::allocator< std::string > > const & parameterNames=std::set< std::string >())
|
|
load(ConfigDB self, char const * xml)
|
|
"""
|
|
return _client.ConfigDB_load(self, *args)
|
|
|
|
def config(self):
|
|
r"""config(ConfigDB self) -> Config"""
|
|
return _client.ConfigDB_config(self)
|
|
__swig_destroy__ = _client.delete_ConfigDB
|
|
|
|
# Register ConfigDB in _client:
|
|
_client.ConfigDB_swigregister(ConfigDB)
|
|
|
|
def ConfigDB_Instance():
|
|
r"""ConfigDB_Instance() -> ConfigDB"""
|
|
return _client.ConfigDB_Instance()
|
|
|
|
def ConfigDB_Reset():
|
|
r"""ConfigDB_Reset()"""
|
|
return _client.ConfigDB_Reset()
|
|
|
|
|
|
|