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.
23413 lines
854 KiB
Python
23413 lines
854 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 _datamodel
|
|
else:
|
|
import _datamodel
|
|
|
|
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__ = _datamodel.delete_SwigPyIterator
|
|
|
|
def value(self):
|
|
return _datamodel.SwigPyIterator_value(self)
|
|
|
|
def incr(self, n=1):
|
|
return _datamodel.SwigPyIterator_incr(self, n)
|
|
|
|
def decr(self, n=1):
|
|
return _datamodel.SwigPyIterator_decr(self, n)
|
|
|
|
def distance(self, x):
|
|
return _datamodel.SwigPyIterator_distance(self, x)
|
|
|
|
def equal(self, x):
|
|
return _datamodel.SwigPyIterator_equal(self, x)
|
|
|
|
def copy(self):
|
|
return _datamodel.SwigPyIterator_copy(self)
|
|
|
|
def next(self):
|
|
return _datamodel.SwigPyIterator_next(self)
|
|
|
|
def __next__(self):
|
|
return _datamodel.SwigPyIterator___next__(self)
|
|
|
|
def previous(self):
|
|
return _datamodel.SwigPyIterator_previous(self)
|
|
|
|
def advance(self, n):
|
|
return _datamodel.SwigPyIterator_advance(self, n)
|
|
|
|
def __eq__(self, x):
|
|
return _datamodel.SwigPyIterator___eq__(self, x)
|
|
|
|
def __ne__(self, x):
|
|
return _datamodel.SwigPyIterator___ne__(self, x)
|
|
|
|
def __iadd__(self, n):
|
|
return _datamodel.SwigPyIterator___iadd__(self, n)
|
|
|
|
def __isub__(self, n):
|
|
return _datamodel.SwigPyIterator___isub__(self, n)
|
|
|
|
def __add__(self, n):
|
|
return _datamodel.SwigPyIterator___add__(self, n)
|
|
|
|
def __sub__(self, *args):
|
|
return _datamodel.SwigPyIterator___sub__(self, *args)
|
|
def __iter__(self):
|
|
return self
|
|
|
|
# Register SwigPyIterator in _datamodel:
|
|
_datamodel.SwigPyIterator_swigregister(SwigPyIterator)
|
|
|
|
import seiscomp.io
|
|
import seiscomp.math
|
|
import seiscomp.core
|
|
import seiscomp.geo
|
|
class NotifierMessageBase(seiscomp.core.Message):
|
|
r"""Proxy of C++ Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(NotifierMessageBase self, GenericArchive ar)"""
|
|
return _datamodel.NotifierMessageBase_serialize(self, ar)
|
|
|
|
def __init__(self):
|
|
r"""__init__(NotifierMessageBase self) -> NotifierMessageBase"""
|
|
_datamodel.NotifierMessageBase_swiginit(self, _datamodel.new_NotifierMessageBase())
|
|
__swig_destroy__ = _datamodel.delete_NotifierMessageBase
|
|
|
|
def attach(self, *args):
|
|
r"""
|
|
attach(NotifierMessageBase self, Notifier attachment) -> bool
|
|
attach(NotifierMessageBase self, Seiscomp::Core::SmartPointer< Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::AttachementType >::Impl & attachment) -> bool
|
|
"""
|
|
return _datamodel.NotifierMessageBase_attach(self, *args)
|
|
|
|
def detach(self, *args):
|
|
r"""
|
|
detach(NotifierMessageBase self, Notifier attachment) -> bool
|
|
detach(NotifierMessageBase self, Seiscomp::Core::SmartPointer< Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::AttachementType >::Impl & attachment) -> bool
|
|
detach(NotifierMessageBase self, Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::iterator it) -> Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::iterator
|
|
"""
|
|
return _datamodel.NotifierMessageBase_detach(self, *args)
|
|
|
|
def clear(self):
|
|
r"""clear(NotifierMessageBase self)"""
|
|
return _datamodel.NotifierMessageBase_clear(self)
|
|
|
|
def begin(self, *args):
|
|
r"""
|
|
begin(NotifierMessageBase self) -> Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::iterator
|
|
begin(NotifierMessageBase self) -> Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::const_iterator
|
|
"""
|
|
return _datamodel.NotifierMessageBase_begin(self, *args)
|
|
|
|
def end(self, *args):
|
|
r"""
|
|
end(NotifierMessageBase self) -> Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::iterator
|
|
end(NotifierMessageBase self) -> Seiscomp::Core::GenericMessage< Seiscomp::DataModel::Notifier >::const_iterator
|
|
"""
|
|
return _datamodel.NotifierMessageBase_end(self, *args)
|
|
|
|
def empty(self):
|
|
r"""empty(NotifierMessageBase self) -> bool"""
|
|
return _datamodel.NotifierMessageBase_empty(self)
|
|
|
|
def size(self):
|
|
r"""size(NotifierMessageBase self) -> int"""
|
|
return _datamodel.NotifierMessageBase_size(self)
|
|
|
|
# Register NotifierMessageBase in _datamodel:
|
|
_datamodel.NotifierMessageBase_swigregister(NotifierMessageBase)
|
|
|
|
class Observer(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Observer 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 _datamodel.Observer_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Observer_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Observer self) -> char const *"""
|
|
return _datamodel.Observer_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Observer self) -> RTTI"""
|
|
return _datamodel.Observer_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Observer
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Observer
|
|
"""
|
|
return _datamodel.Observer_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Observer
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Observer
|
|
"""
|
|
return _datamodel.Observer_ConstCast(*args)
|
|
__swig_destroy__ = _datamodel.delete_Observer
|
|
|
|
def onObjectAdded(self, parent, newChild):
|
|
r"""onObjectAdded(Observer self, Object parent, Object newChild)"""
|
|
return _datamodel.Observer_onObjectAdded(self, parent, newChild)
|
|
|
|
def onObjectRemoved(self, parent, oldChild):
|
|
r"""onObjectRemoved(Observer self, Object parent, Object oldChild)"""
|
|
return _datamodel.Observer_onObjectRemoved(self, parent, oldChild)
|
|
|
|
def onObjectModified(self, object):
|
|
r"""onObjectModified(Observer self, Object object)"""
|
|
return _datamodel.Observer_onObjectModified(self, object)
|
|
|
|
def onObjectDestroyed(self, object):
|
|
r"""onObjectDestroyed(Observer self, Object object)"""
|
|
return _datamodel.Observer_onObjectDestroyed(self, object)
|
|
|
|
# Register Observer in _datamodel:
|
|
_datamodel.Observer_swigregister(Observer)
|
|
|
|
def Observer_ClassName():
|
|
r"""Observer_ClassName() -> char const *"""
|
|
return _datamodel.Observer_ClassName()
|
|
|
|
def Observer_TypeInfo():
|
|
r"""Observer_TypeInfo() -> RTTI"""
|
|
return _datamodel.Observer_TypeInfo()
|
|
|
|
def Observer_Cast(*args):
|
|
r"""
|
|
Observer_Cast(BaseObject o) -> Observer
|
|
Observer_Cast(Seiscomp::Core::BaseObjectPtr o) -> Observer
|
|
"""
|
|
return _datamodel.Observer_Cast(*args)
|
|
|
|
def Observer_ConstCast(*args):
|
|
r"""
|
|
Observer_ConstCast(BaseObject o) -> Observer
|
|
Observer_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Observer
|
|
"""
|
|
return _datamodel.Observer_ConstCast(*args)
|
|
|
|
class Visitor(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Visitor 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
|
|
TM_TOPDOWN = _datamodel.Visitor_TM_TOPDOWN
|
|
|
|
TM_BOTTOMUP = _datamodel.Visitor_TM_BOTTOMUP
|
|
|
|
TM_QUANTITY = _datamodel.Visitor_TM_QUANTITY
|
|
|
|
__swig_destroy__ = _datamodel.delete_Visitor
|
|
|
|
def traversal(self):
|
|
r"""traversal(Visitor self) -> Seiscomp::DataModel::Visitor::TraversalMode"""
|
|
return _datamodel.Visitor_traversal(self)
|
|
|
|
def visit(self, *args):
|
|
r"""
|
|
visit(Visitor self, PublicObject arg2) -> bool
|
|
visit(Visitor self, Object arg2)
|
|
"""
|
|
return _datamodel.Visitor_visit(self, *args)
|
|
|
|
def finished(self):
|
|
r"""finished(Visitor self)"""
|
|
return _datamodel.Visitor_finished(self)
|
|
|
|
# Register Visitor in _datamodel:
|
|
_datamodel.Visitor_swigregister(Visitor)
|
|
|
|
OP_UNDEFINED = _datamodel.OP_UNDEFINED
|
|
|
|
OP_ADD = _datamodel.OP_ADD
|
|
|
|
OP_REMOVE = _datamodel.OP_REMOVE
|
|
|
|
OP_UPDATE = _datamodel.OP_UPDATE
|
|
|
|
EOperationQuantity = _datamodel.EOperationQuantity
|
|
|
|
class EOperationNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EOperationNames 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__(EOperationNames self) -> EOperationNames"""
|
|
_datamodel.EOperationNames_swiginit(self, _datamodel.new_EOperationNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EOperationNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EOperationNames
|
|
|
|
# Register EOperationNames in _datamodel:
|
|
_datamodel.EOperationNames_swigregister(EOperationNames)
|
|
|
|
def EOperationNames_name(i):
|
|
r"""EOperationNames_name(int i) -> char const *"""
|
|
return _datamodel.EOperationNames_name(i)
|
|
|
|
class Object(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Object 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 _datamodel.Object_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Object_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Object self) -> char const *"""
|
|
return _datamodel.Object_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Object self) -> RTTI"""
|
|
return _datamodel.Object_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Object
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Object
|
|
"""
|
|
return _datamodel.Object_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Object
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Object
|
|
"""
|
|
return _datamodel.Object_ConstCast(*args)
|
|
__swig_destroy__ = _datamodel.delete_Object
|
|
|
|
def parent(self):
|
|
r"""parent(Object self) -> PublicObject"""
|
|
return _datamodel.Object_parent(self)
|
|
|
|
def setParent(self, parent):
|
|
r"""setParent(Object self, PublicObject parent) -> bool"""
|
|
return _datamodel.Object_setParent(self, parent)
|
|
|
|
@staticmethod
|
|
def RegisterObserver(arg1):
|
|
r"""RegisterObserver(Observer arg1) -> bool"""
|
|
return _datamodel.Object_RegisterObserver(arg1)
|
|
|
|
@staticmethod
|
|
def UnregisterObserver(arg1):
|
|
r"""UnregisterObserver(Observer arg1) -> bool"""
|
|
return _datamodel.Object_UnregisterObserver(arg1)
|
|
|
|
def update(self):
|
|
r"""update(Object self)"""
|
|
return _datamodel.Object_update(self)
|
|
|
|
def setLastModifiedInArchive(self, t):
|
|
r"""setLastModifiedInArchive(Object self, Time t)"""
|
|
return _datamodel.Object_setLastModifiedInArchive(self, t)
|
|
|
|
def lastModifiedInArchive(self):
|
|
r"""lastModifiedInArchive(Object self) -> Time"""
|
|
return _datamodel.Object_lastModifiedInArchive(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Object self, Object other) -> bool"""
|
|
return _datamodel.Object_assign(self, other)
|
|
|
|
def clone(self):
|
|
r"""clone(Object self) -> Object"""
|
|
return _datamodel.Object_clone(self)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Object self, PublicObject parent) -> bool"""
|
|
return _datamodel.Object_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Object self, PublicObject parent) -> bool"""
|
|
return _datamodel.Object_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Object self) -> bool"""
|
|
return _datamodel.Object_detach(self)
|
|
|
|
def accept(self, arg2):
|
|
r"""accept(Object self, Visitor arg2)"""
|
|
return _datamodel.Object_accept(self, arg2)
|
|
|
|
# Register Object in _datamodel:
|
|
_datamodel.Object_swigregister(Object)
|
|
|
|
def Object_ClassName():
|
|
r"""Object_ClassName() -> char const *"""
|
|
return _datamodel.Object_ClassName()
|
|
|
|
def Object_TypeInfo():
|
|
r"""Object_TypeInfo() -> RTTI"""
|
|
return _datamodel.Object_TypeInfo()
|
|
|
|
def Object_Cast(*args):
|
|
r"""
|
|
Object_Cast(BaseObject o) -> Object
|
|
Object_Cast(Seiscomp::Core::BaseObjectPtr o) -> Object
|
|
"""
|
|
return _datamodel.Object_Cast(*args)
|
|
|
|
def Object_ConstCast(*args):
|
|
r"""
|
|
Object_ConstCast(BaseObject o) -> Object
|
|
Object_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Object
|
|
"""
|
|
return _datamodel.Object_ConstCast(*args)
|
|
|
|
def Object_RegisterObserver(arg1):
|
|
r"""Object_RegisterObserver(Observer arg1) -> bool"""
|
|
return _datamodel.Object_RegisterObserver(arg1)
|
|
|
|
def Object_UnregisterObserver(arg1):
|
|
r"""Object_UnregisterObserver(Observer arg1) -> bool"""
|
|
return _datamodel.Object_UnregisterObserver(arg1)
|
|
|
|
class PublicObject(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::PublicObject 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 _datamodel.PublicObject_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.PublicObject_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(PublicObject self) -> char const *"""
|
|
return _datamodel.PublicObject_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(PublicObject self) -> RTTI"""
|
|
return _datamodel.PublicObject_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> PublicObject
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> PublicObject
|
|
"""
|
|
return _datamodel.PublicObject_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> PublicObject
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> PublicObject
|
|
"""
|
|
return _datamodel.PublicObject_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(PublicObject self, GenericArchive ar)"""
|
|
return _datamodel.PublicObject_serialize(self, ar)
|
|
__swig_destroy__ = _datamodel.delete_PublicObject
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(PublicObject self, PublicObject arg2) -> bool"""
|
|
return _datamodel.PublicObject___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(PublicObject self, PublicObject arg2) -> bool"""
|
|
return _datamodel.PublicObject___ne__(self, arg2)
|
|
|
|
def publicID(self):
|
|
r"""publicID(PublicObject self) -> std::string const &"""
|
|
return _datamodel.PublicObject_publicID(self)
|
|
|
|
def setPublicID(self, arg2):
|
|
r"""setPublicID(PublicObject self, std::string const & arg2) -> bool"""
|
|
return _datamodel.PublicObject_setPublicID(self, arg2)
|
|
|
|
def registered(self):
|
|
r"""registered(PublicObject self) -> bool"""
|
|
return _datamodel.PublicObject_registered(self)
|
|
|
|
def registerMe(self):
|
|
r"""registerMe(PublicObject self) -> bool"""
|
|
return _datamodel.PublicObject_registerMe(self)
|
|
|
|
def deregisterMe(self):
|
|
r"""deregisterMe(PublicObject self) -> bool"""
|
|
return _datamodel.PublicObject_deregisterMe(self)
|
|
|
|
def validId(self):
|
|
r"""validId(PublicObject self) -> bool"""
|
|
return _datamodel.PublicObject_validId(self)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> PublicObject"""
|
|
return _datamodel.PublicObject_Find(publicID)
|
|
|
|
@staticmethod
|
|
def ObjectCount():
|
|
r"""ObjectCount() -> size_t"""
|
|
return _datamodel.PublicObject_ObjectCount()
|
|
|
|
@staticmethod
|
|
def Begin():
|
|
r"""Begin() -> Seiscomp::DataModel::PublicObject::Iterator"""
|
|
return _datamodel.PublicObject_Begin()
|
|
|
|
@staticmethod
|
|
def End():
|
|
r"""End() -> Seiscomp::DataModel::PublicObject::Iterator"""
|
|
return _datamodel.PublicObject_End()
|
|
|
|
@staticmethod
|
|
def SetIdGeneration(arg1):
|
|
r"""SetIdGeneration(bool arg1)"""
|
|
return _datamodel.PublicObject_SetIdGeneration(arg1)
|
|
|
|
@staticmethod
|
|
def SetIdPattern(pattern):
|
|
r"""SetIdPattern(std::string const & pattern)"""
|
|
return _datamodel.PublicObject_SetIdPattern(pattern)
|
|
|
|
@staticmethod
|
|
def GenerateId(*args):
|
|
r"""
|
|
GenerateId(PublicObject object) -> PublicObject
|
|
GenerateId(PublicObject object, std::string const & pattern) -> PublicObject
|
|
"""
|
|
return _datamodel.PublicObject_GenerateId(*args)
|
|
|
|
@staticmethod
|
|
def SetRegistrationEnabled(enable):
|
|
r"""SetRegistrationEnabled(bool enable)"""
|
|
return _datamodel.PublicObject_SetRegistrationEnabled(enable)
|
|
|
|
@staticmethod
|
|
def IsRegistrationEnabled():
|
|
r"""IsRegistrationEnabled() -> bool"""
|
|
return _datamodel.PublicObject_IsRegistrationEnabled()
|
|
|
|
def updateChild(self, arg2):
|
|
r"""updateChild(PublicObject self, Object arg2) -> bool"""
|
|
return _datamodel.PublicObject_updateChild(self, arg2)
|
|
|
|
def accept(self, arg2):
|
|
r"""accept(PublicObject self, Visitor arg2)"""
|
|
return _datamodel.PublicObject_accept(self, arg2)
|
|
|
|
# Register PublicObject in _datamodel:
|
|
_datamodel.PublicObject_swigregister(PublicObject)
|
|
|
|
def PublicObject_ClassName():
|
|
r"""PublicObject_ClassName() -> char const *"""
|
|
return _datamodel.PublicObject_ClassName()
|
|
|
|
def PublicObject_TypeInfo():
|
|
r"""PublicObject_TypeInfo() -> RTTI"""
|
|
return _datamodel.PublicObject_TypeInfo()
|
|
|
|
def PublicObject_Cast(*args):
|
|
r"""
|
|
PublicObject_Cast(BaseObject o) -> PublicObject
|
|
PublicObject_Cast(Seiscomp::Core::BaseObjectPtr o) -> PublicObject
|
|
"""
|
|
return _datamodel.PublicObject_Cast(*args)
|
|
|
|
def PublicObject_ConstCast(*args):
|
|
r"""
|
|
PublicObject_ConstCast(BaseObject o) -> PublicObject
|
|
PublicObject_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> PublicObject
|
|
"""
|
|
return _datamodel.PublicObject_ConstCast(*args)
|
|
|
|
def PublicObject_Find(publicID):
|
|
r"""PublicObject_Find(std::string const & publicID) -> PublicObject"""
|
|
return _datamodel.PublicObject_Find(publicID)
|
|
|
|
def PublicObject_ObjectCount():
|
|
r"""PublicObject_ObjectCount() -> size_t"""
|
|
return _datamodel.PublicObject_ObjectCount()
|
|
|
|
def PublicObject_Begin():
|
|
r"""PublicObject_Begin() -> Seiscomp::DataModel::PublicObject::Iterator"""
|
|
return _datamodel.PublicObject_Begin()
|
|
|
|
def PublicObject_End():
|
|
r"""PublicObject_End() -> Seiscomp::DataModel::PublicObject::Iterator"""
|
|
return _datamodel.PublicObject_End()
|
|
|
|
def PublicObject_SetIdGeneration(arg1):
|
|
r"""PublicObject_SetIdGeneration(bool arg1)"""
|
|
return _datamodel.PublicObject_SetIdGeneration(arg1)
|
|
|
|
def PublicObject_SetIdPattern(pattern):
|
|
r"""PublicObject_SetIdPattern(std::string const & pattern)"""
|
|
return _datamodel.PublicObject_SetIdPattern(pattern)
|
|
|
|
def PublicObject_GenerateId(*args):
|
|
r"""
|
|
PublicObject_GenerateId(PublicObject object) -> PublicObject
|
|
PublicObject_GenerateId(PublicObject object, std::string const & pattern) -> PublicObject
|
|
"""
|
|
return _datamodel.PublicObject_GenerateId(*args)
|
|
|
|
def PublicObject_SetRegistrationEnabled(enable):
|
|
r"""PublicObject_SetRegistrationEnabled(bool enable)"""
|
|
return _datamodel.PublicObject_SetRegistrationEnabled(enable)
|
|
|
|
def PublicObject_IsRegistrationEnabled():
|
|
r"""PublicObject_IsRegistrationEnabled() -> bool"""
|
|
return _datamodel.PublicObject_IsRegistrationEnabled()
|
|
|
|
class DatabaseIterator(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DatabaseIterator 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__(DatabaseIterator self) -> DatabaseIterator
|
|
__init__(DatabaseIterator self, DatabaseIterator iter) -> DatabaseIterator
|
|
"""
|
|
_datamodel.DatabaseIterator_swiginit(self, _datamodel.new_DatabaseIterator(*args))
|
|
__swig_destroy__ = _datamodel.delete_DatabaseIterator
|
|
|
|
def get(self):
|
|
r"""get(DatabaseIterator self) -> Object"""
|
|
return _datamodel.DatabaseIterator_get(self)
|
|
|
|
def fieldCount(self):
|
|
r"""fieldCount(DatabaseIterator self) -> size_t"""
|
|
return _datamodel.DatabaseIterator_fieldCount(self)
|
|
|
|
def field(self, index):
|
|
r"""field(DatabaseIterator self, size_t index) -> char const *"""
|
|
return _datamodel.DatabaseIterator_field(self, index)
|
|
|
|
def __ref__(self):
|
|
r"""__ref__(DatabaseIterator self) -> Object"""
|
|
return _datamodel.DatabaseIterator___ref__(self)
|
|
|
|
def valid(self):
|
|
r"""valid(DatabaseIterator self) -> bool"""
|
|
return _datamodel.DatabaseIterator_valid(self)
|
|
|
|
def close(self):
|
|
r"""close(DatabaseIterator self)"""
|
|
return _datamodel.DatabaseIterator_close(self)
|
|
|
|
def count(self):
|
|
r"""count(DatabaseIterator self) -> size_t"""
|
|
return _datamodel.DatabaseIterator_count(self)
|
|
|
|
def lastModified(self):
|
|
r"""lastModified(DatabaseIterator self) -> Time"""
|
|
return _datamodel.DatabaseIterator_lastModified(self)
|
|
|
|
def oid(self):
|
|
r"""oid(DatabaseIterator self) -> Seiscomp::DataModel::DatabaseIterator::OID"""
|
|
return _datamodel.DatabaseIterator_oid(self)
|
|
|
|
def parentOid(self):
|
|
r"""parentOid(DatabaseIterator self) -> Seiscomp::DataModel::DatabaseIterator::OID"""
|
|
return _datamodel.DatabaseIterator_parentOid(self)
|
|
|
|
def cached(self):
|
|
r"""cached(DatabaseIterator self) -> bool"""
|
|
return _datamodel.DatabaseIterator_cached(self)
|
|
|
|
def step(self):
|
|
r"""step(DatabaseIterator self)"""
|
|
return _datamodel.DatabaseIterator_step(self)
|
|
|
|
def __iter__(self):
|
|
return self
|
|
|
|
def __next__(self):
|
|
o = self.get()
|
|
if not o:
|
|
raise StopIteration
|
|
|
|
self.step()
|
|
return o
|
|
|
|
# for Python 2 compatibility
|
|
def next(self):
|
|
return self.__next__()
|
|
|
|
|
|
# Register DatabaseIterator in _datamodel:
|
|
_datamodel.DatabaseIterator_swigregister(DatabaseIterator)
|
|
|
|
class DatabaseObjectWriter(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DatabaseObjectWriter 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, archive, addToDatabase=True, batchSize=1):
|
|
r"""__init__(DatabaseObjectWriter self, DatabaseArchive archive, bool addToDatabase=True, int batchSize=1) -> DatabaseObjectWriter"""
|
|
_datamodel.DatabaseObjectWriter_swiginit(self, _datamodel.new_DatabaseObjectWriter(archive, addToDatabase, batchSize))
|
|
|
|
def __call__(self, *args):
|
|
r"""
|
|
__call__(DatabaseObjectWriter self, Object object) -> bool
|
|
__call__(DatabaseObjectWriter self, Object object, std::string const & parentID) -> bool
|
|
"""
|
|
return _datamodel.DatabaseObjectWriter___call__(self, *args)
|
|
|
|
def count(self):
|
|
r"""count(DatabaseObjectWriter self) -> int"""
|
|
return _datamodel.DatabaseObjectWriter_count(self)
|
|
|
|
def errors(self):
|
|
r"""errors(DatabaseObjectWriter self) -> int"""
|
|
return _datamodel.DatabaseObjectWriter_errors(self)
|
|
__swig_destroy__ = _datamodel.delete_DatabaseObjectWriter
|
|
|
|
# Register DatabaseObjectWriter in _datamodel:
|
|
_datamodel.DatabaseObjectWriter_swigregister(DatabaseObjectWriter)
|
|
|
|
class DatabaseArchive(Observer):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DatabaseArchive 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, dbDriver):
|
|
r"""__init__(DatabaseArchive self, DatabaseInterface dbDriver) -> DatabaseArchive"""
|
|
_datamodel.DatabaseArchive_swiginit(self, _datamodel.new_DatabaseArchive(dbDriver))
|
|
__swig_destroy__ = _datamodel.delete_DatabaseArchive
|
|
|
|
def open(self, dataSource):
|
|
r"""open(DatabaseArchive self, char const * dataSource) -> bool"""
|
|
return _datamodel.DatabaseArchive_open(self, dataSource)
|
|
|
|
def close(self):
|
|
r"""close(DatabaseArchive self)"""
|
|
return _datamodel.DatabaseArchive_close(self)
|
|
|
|
def driver(self):
|
|
r"""driver(DatabaseArchive self) -> DatabaseInterface"""
|
|
return _datamodel.DatabaseArchive_driver(self)
|
|
|
|
def setDriver(self, arg2):
|
|
r"""setDriver(DatabaseArchive self, DatabaseInterface arg2)"""
|
|
return _datamodel.DatabaseArchive_setDriver(self, arg2)
|
|
|
|
def hasError(self):
|
|
r"""hasError(DatabaseArchive self) -> bool"""
|
|
return _datamodel.DatabaseArchive_hasError(self)
|
|
|
|
def errorMsg(self):
|
|
r"""errorMsg(DatabaseArchive self) -> std::string const"""
|
|
return _datamodel.DatabaseArchive_errorMsg(self)
|
|
|
|
def benchmarkQueries(self, count):
|
|
r"""benchmarkQueries(DatabaseArchive self, int count)"""
|
|
return _datamodel.DatabaseArchive_benchmarkQueries(self, count)
|
|
|
|
def getObject(self, classType, publicID):
|
|
r"""getObject(DatabaseArchive self, RTTI classType, std::string const & publicID) -> PublicObject"""
|
|
return _datamodel.DatabaseArchive_getObject(self, classType, publicID)
|
|
|
|
def getObjects(self, *args):
|
|
r"""
|
|
getObjects(DatabaseArchive self, std::string const & parentID, RTTI classType, bool ignorePublicObject=False) -> DatabaseIterator
|
|
getObjects(DatabaseArchive self, PublicObject parent, RTTI classType, bool ignorePublicObject=False) -> DatabaseIterator
|
|
"""
|
|
return _datamodel.DatabaseArchive_getObjects(self, *args)
|
|
|
|
def getObjectCount(self, *args):
|
|
r"""
|
|
getObjectCount(DatabaseArchive self, std::string const & parentID, RTTI classType) -> size_t
|
|
getObjectCount(DatabaseArchive self, PublicObject parent, RTTI classType) -> size_t
|
|
"""
|
|
return _datamodel.DatabaseArchive_getObjectCount(self, *args)
|
|
|
|
def getCachedId(self, arg2):
|
|
r"""getCachedId(DatabaseArchive self, Object arg2) -> Seiscomp::DataModel::DatabaseArchive::OID"""
|
|
return _datamodel.DatabaseArchive_getCachedId(self, arg2)
|
|
|
|
def parentPublicID(self, object):
|
|
r"""parentPublicID(DatabaseArchive self, PublicObject object) -> std::string"""
|
|
return _datamodel.DatabaseArchive_parentPublicID(self, object)
|
|
|
|
def write(self, *args):
|
|
r"""write(DatabaseArchive self, Object object, std::string const & parentID="") -> bool"""
|
|
return _datamodel.DatabaseArchive_write(self, *args)
|
|
|
|
def update(self, *args):
|
|
r"""update(DatabaseArchive self, Object object, std::string const & parentID="") -> bool"""
|
|
return _datamodel.DatabaseArchive_update(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""remove(DatabaseArchive self, Object object, std::string const & parentID="") -> bool"""
|
|
return _datamodel.DatabaseArchive_remove(self, *args)
|
|
|
|
def addTree(self, *args):
|
|
r"""addTree(DatabaseArchive self, Object object, std::string const & parentID="", int * objectsHandled=None) -> bool"""
|
|
return _datamodel.DatabaseArchive_addTree(self, *args)
|
|
|
|
def removeTree(self, *args):
|
|
r"""removeTree(DatabaseArchive self, Object object, std::string const & parentID="", int * objectsHandled=None) -> bool"""
|
|
return _datamodel.DatabaseArchive_removeTree(self, *args)
|
|
|
|
def getObjectIterator(self, *args):
|
|
r"""
|
|
getObjectIterator(DatabaseArchive self, std::string const & query, RTTI classType) -> DatabaseIterator
|
|
getObjectIterator(DatabaseArchive self, std::string const & query, RTTI classType) -> DatabaseIterator
|
|
"""
|
|
return _datamodel.DatabaseArchive_getObjectIterator(self, *args)
|
|
|
|
def toString(self, *args):
|
|
r"""
|
|
toString(DatabaseArchive self, std::string const & value) -> std::string
|
|
toString(DatabaseArchive self, char const * value) -> std::string
|
|
toString(DatabaseArchive self, Time value) -> std::string
|
|
"""
|
|
return _datamodel.DatabaseArchive_toString(self, *args)
|
|
|
|
# Register DatabaseArchive in _datamodel:
|
|
_datamodel.DatabaseArchive_swigregister(DatabaseArchive)
|
|
|
|
class CachePopCallback(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::CachePopCallback class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def handle(self, obj):
|
|
r"""handle(CachePopCallback self, PublicObject obj)"""
|
|
return _datamodel.CachePopCallback_handle(self, obj)
|
|
__swig_destroy__ = _datamodel.delete_CachePopCallback
|
|
|
|
def __init__(self):
|
|
r"""__init__(CachePopCallback self) -> CachePopCallback"""
|
|
if self.__class__ == CachePopCallback:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
_datamodel.CachePopCallback_swiginit(self, _datamodel.new_CachePopCallback(_self, ))
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_datamodel.disown_CachePopCallback(self)
|
|
return weakref.proxy(self)
|
|
|
|
# Register CachePopCallback in _datamodel:
|
|
_datamodel.CachePopCallback_swigregister(CachePopCallback)
|
|
|
|
class PublicObjectCache(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::PublicObjectCache 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__ = _datamodel.delete_PublicObjectCache
|
|
|
|
def setDatabaseArchive(self, arg2):
|
|
r"""setDatabaseArchive(PublicObjectCache self, DatabaseArchive arg2)"""
|
|
return _datamodel.PublicObjectCache_setDatabaseArchive(self, arg2)
|
|
|
|
def setPopCallback(self, *args):
|
|
r"""
|
|
setPopCallback(PublicObjectCache self, Seiscomp::DataModel::PublicObjectCache::PopCallback const & arg2)
|
|
setPopCallback(PublicObjectCache self, CachePopCallback arg2)
|
|
"""
|
|
return _datamodel.PublicObjectCache_setPopCallback(self, *args)
|
|
|
|
def removePopCallback(self):
|
|
r"""removePopCallback(PublicObjectCache self)"""
|
|
return _datamodel.PublicObjectCache_removePopCallback(self)
|
|
|
|
def feed(self, po):
|
|
r"""feed(PublicObjectCache self, PublicObject po) -> bool"""
|
|
return _datamodel.PublicObjectCache_feed(self, po)
|
|
|
|
def remove(self, po):
|
|
r"""remove(PublicObjectCache self, PublicObject po) -> bool"""
|
|
return _datamodel.PublicObjectCache_remove(self, po)
|
|
|
|
def clear(self):
|
|
r"""clear(PublicObjectCache self)"""
|
|
return _datamodel.PublicObjectCache_clear(self)
|
|
|
|
def typeInfo(self, publicID):
|
|
r"""typeInfo(PublicObjectCache self, std::string const & publicID) -> RTTI"""
|
|
return _datamodel.PublicObjectCache_typeInfo(self, publicID)
|
|
|
|
def find(self, classType, publicID):
|
|
r"""find(PublicObjectCache self, RTTI classType, std::string const & publicID) -> PublicObject"""
|
|
return _datamodel.PublicObjectCache_find(self, classType, publicID)
|
|
|
|
def cached(self):
|
|
r"""cached(PublicObjectCache self) -> bool"""
|
|
return _datamodel.PublicObjectCache_cached(self)
|
|
|
|
def timeWindow(self):
|
|
r"""timeWindow(PublicObjectCache self) -> Seiscomp::Core::TimeWindow"""
|
|
return _datamodel.PublicObjectCache_timeWindow(self)
|
|
|
|
def oldest(self):
|
|
r"""oldest(PublicObjectCache self) -> Time"""
|
|
return _datamodel.PublicObjectCache_oldest(self)
|
|
|
|
def empty(self):
|
|
r"""empty(PublicObjectCache self) -> bool"""
|
|
return _datamodel.PublicObjectCache_empty(self)
|
|
|
|
def size(self):
|
|
r"""size(PublicObjectCache self) -> size_t"""
|
|
return _datamodel.PublicObjectCache_size(self)
|
|
|
|
def contains(self, *args):
|
|
r"""
|
|
contains(PublicObjectCache self, PublicObject object) -> bool
|
|
contains(PublicObjectCache self, std::string const & publicID) -> bool
|
|
"""
|
|
return _datamodel.PublicObjectCache_contains(self, *args)
|
|
|
|
def get(self, klass, publicID):
|
|
o = self.find(klass.TypeInfo(), publicID)
|
|
return klass.Cast(o)
|
|
|
|
def __iter__(self):
|
|
return PublicObjectCacheIterator(self)
|
|
|
|
|
|
# Register PublicObjectCache in _datamodel:
|
|
_datamodel.PublicObjectCache_swigregister(PublicObjectCache)
|
|
|
|
class PublicObjectRingBuffer(PublicObjectCache):
|
|
r"""Proxy of C++ Seiscomp::DataModel::PublicObjectRingBuffer 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__(PublicObjectRingBuffer self) -> PublicObjectRingBuffer
|
|
__init__(PublicObjectRingBuffer self, DatabaseArchive ar, size_t bufferSize) -> PublicObjectRingBuffer
|
|
"""
|
|
_datamodel.PublicObjectRingBuffer_swiginit(self, _datamodel.new_PublicObjectRingBuffer(*args))
|
|
|
|
def setBufferSize(self, bufferSize):
|
|
r"""setBufferSize(PublicObjectRingBuffer self, size_t bufferSize) -> bool"""
|
|
return _datamodel.PublicObjectRingBuffer_setBufferSize(self, bufferSize)
|
|
|
|
def feed(self, po):
|
|
r"""feed(PublicObjectRingBuffer self, PublicObject po) -> bool"""
|
|
return _datamodel.PublicObjectRingBuffer_feed(self, po)
|
|
__swig_destroy__ = _datamodel.delete_PublicObjectRingBuffer
|
|
|
|
# Register PublicObjectRingBuffer in _datamodel:
|
|
_datamodel.PublicObjectRingBuffer_swigregister(PublicObjectRingBuffer)
|
|
|
|
class PublicObjectTimeSpanBuffer(PublicObjectCache):
|
|
r"""Proxy of C++ Seiscomp::DataModel::PublicObjectTimeSpanBuffer 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__(PublicObjectTimeSpanBuffer self) -> PublicObjectTimeSpanBuffer
|
|
__init__(PublicObjectTimeSpanBuffer self, DatabaseArchive ar, TimeSpan length) -> PublicObjectTimeSpanBuffer
|
|
"""
|
|
_datamodel.PublicObjectTimeSpanBuffer_swiginit(self, _datamodel.new_PublicObjectTimeSpanBuffer(*args))
|
|
|
|
def setTimeSpan(self, arg2):
|
|
r"""setTimeSpan(PublicObjectTimeSpanBuffer self, TimeSpan arg2) -> bool"""
|
|
return _datamodel.PublicObjectTimeSpanBuffer_setTimeSpan(self, arg2)
|
|
|
|
def feed(self, po):
|
|
r"""feed(PublicObjectTimeSpanBuffer self, PublicObject po) -> bool"""
|
|
return _datamodel.PublicObjectTimeSpanBuffer_feed(self, po)
|
|
__swig_destroy__ = _datamodel.delete_PublicObjectTimeSpanBuffer
|
|
|
|
# Register PublicObjectTimeSpanBuffer in _datamodel:
|
|
_datamodel.PublicObjectTimeSpanBuffer_swigregister(PublicObjectTimeSpanBuffer)
|
|
|
|
class NotifierMessage(NotifierMessageBase):
|
|
r"""Proxy of C++ Seiscomp::DataModel::NotifierMessage 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 _datamodel.NotifierMessage_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.NotifierMessage_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(NotifierMessage self) -> char const *"""
|
|
return _datamodel.NotifierMessage_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(NotifierMessage self) -> RTTI"""
|
|
return _datamodel.NotifierMessage_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> NotifierMessage
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> NotifierMessage
|
|
"""
|
|
return _datamodel.NotifierMessage_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> NotifierMessage
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> NotifierMessage
|
|
"""
|
|
return _datamodel.NotifierMessage_ConstCast(*args)
|
|
|
|
def __init__(self):
|
|
r"""__init__(NotifierMessage self) -> NotifierMessage"""
|
|
_datamodel.NotifierMessage_swiginit(self, _datamodel.new_NotifierMessage())
|
|
__swig_destroy__ = _datamodel.delete_NotifierMessage
|
|
|
|
# Register NotifierMessage in _datamodel:
|
|
_datamodel.NotifierMessage_swigregister(NotifierMessage)
|
|
|
|
def NotifierMessage_ClassName():
|
|
r"""NotifierMessage_ClassName() -> char const *"""
|
|
return _datamodel.NotifierMessage_ClassName()
|
|
|
|
def NotifierMessage_TypeInfo():
|
|
r"""NotifierMessage_TypeInfo() -> RTTI"""
|
|
return _datamodel.NotifierMessage_TypeInfo()
|
|
|
|
def NotifierMessage_Cast(*args):
|
|
r"""
|
|
NotifierMessage_Cast(BaseObject o) -> NotifierMessage
|
|
NotifierMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> NotifierMessage
|
|
"""
|
|
return _datamodel.NotifierMessage_Cast(*args)
|
|
|
|
def NotifierMessage_ConstCast(*args):
|
|
r"""
|
|
NotifierMessage_ConstCast(BaseObject o) -> NotifierMessage
|
|
NotifierMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> NotifierMessage
|
|
"""
|
|
return _datamodel.NotifierMessage_ConstCast(*args)
|
|
|
|
class Notifier(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Notifier 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 _datamodel.Notifier_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Notifier_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Notifier self) -> char const *"""
|
|
return _datamodel.Notifier_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Notifier self) -> RTTI"""
|
|
return _datamodel.Notifier_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Notifier
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Notifier
|
|
"""
|
|
return _datamodel.Notifier_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Notifier
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Notifier
|
|
"""
|
|
return _datamodel.Notifier_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Notifier self, GenericArchive ar)"""
|
|
return _datamodel.Notifier_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Notifier_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Notifier self) -> MetaObject"""
|
|
return _datamodel.Notifier_meta(self)
|
|
CR_DIFFERENT = _datamodel.Notifier_CR_DIFFERENT
|
|
|
|
CR_EQUAL = _datamodel.Notifier_CR_EQUAL
|
|
|
|
CR_OPPOSITE = _datamodel.Notifier_CR_OPPOSITE
|
|
|
|
CR_OVERRIDE = _datamodel.Notifier_CR_OVERRIDE
|
|
|
|
CR_QUANTITY = _datamodel.Notifier_CR_QUANTITY
|
|
|
|
|
|
def __init__(self, parentID, arg3, object):
|
|
r"""__init__(Notifier self, std::string const & parentID, Seiscomp::DataModel::Operation arg3, Object object) -> Notifier"""
|
|
_datamodel.Notifier_swiginit(self, _datamodel.new_Notifier(parentID, arg3, object))
|
|
__swig_destroy__ = _datamodel.delete_Notifier
|
|
|
|
@staticmethod
|
|
def Enable():
|
|
r"""Enable()"""
|
|
return _datamodel.Notifier_Enable()
|
|
|
|
@staticmethod
|
|
def Disable():
|
|
r"""Disable()"""
|
|
return _datamodel.Notifier_Disable()
|
|
|
|
@staticmethod
|
|
def SetEnabled(arg1):
|
|
r"""SetEnabled(bool arg1)"""
|
|
return _datamodel.Notifier_SetEnabled(arg1)
|
|
|
|
@staticmethod
|
|
def IsEnabled():
|
|
r"""IsEnabled() -> bool"""
|
|
return _datamodel.Notifier_IsEnabled()
|
|
|
|
@staticmethod
|
|
def SetCheckEnabled(arg1):
|
|
r"""SetCheckEnabled(bool arg1)"""
|
|
return _datamodel.Notifier_SetCheckEnabled(arg1)
|
|
|
|
@staticmethod
|
|
def IsCheckEnabled():
|
|
r"""IsCheckEnabled() -> bool"""
|
|
return _datamodel.Notifier_IsCheckEnabled()
|
|
|
|
@staticmethod
|
|
def GetMessage(allNotifier=True):
|
|
r"""GetMessage(bool allNotifier=True) -> NotifierMessage"""
|
|
return _datamodel.Notifier_GetMessage(allNotifier)
|
|
|
|
@staticmethod
|
|
def Size():
|
|
r"""Size() -> size_t"""
|
|
return _datamodel.Notifier_Size()
|
|
|
|
@staticmethod
|
|
def Clear():
|
|
r"""Clear()"""
|
|
return _datamodel.Notifier_Clear()
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create(std::string const & parentID, Seiscomp::DataModel::Operation op, Object object) -> Notifier
|
|
Create(PublicObject parent, Seiscomp::DataModel::Operation op, Object object) -> Notifier
|
|
"""
|
|
return _datamodel.Notifier_Create(*args)
|
|
|
|
def apply(self):
|
|
r"""apply(Notifier self) -> bool"""
|
|
return _datamodel.Notifier_apply(self)
|
|
|
|
def setParentID(self, arg2):
|
|
r"""setParentID(Notifier self, std::string const & arg2)"""
|
|
return _datamodel.Notifier_setParentID(self, arg2)
|
|
|
|
def parentID(self):
|
|
r"""parentID(Notifier self) -> std::string const &"""
|
|
return _datamodel.Notifier_parentID(self)
|
|
|
|
def setOperation(self, arg2):
|
|
r"""setOperation(Notifier self, Seiscomp::DataModel::Operation arg2)"""
|
|
return _datamodel.Notifier_setOperation(self, arg2)
|
|
|
|
def operation(self):
|
|
r"""operation(Notifier self) -> Seiscomp::DataModel::Operation"""
|
|
return _datamodel.Notifier_operation(self)
|
|
|
|
def setObject(self, object):
|
|
r"""setObject(Notifier self, Object object)"""
|
|
return _datamodel.Notifier_setObject(self, object)
|
|
|
|
def object(self):
|
|
r"""object(Notifier self) -> Object"""
|
|
return _datamodel.Notifier_object(self)
|
|
|
|
def cmp(self, *args):
|
|
r"""
|
|
cmp(Notifier self, Notifier arg2) -> Seiscomp::DataModel::Notifier::CompareResult
|
|
cmp(Notifier self, Notifier arg2) -> Seiscomp::DataModel::Notifier::CompareResult
|
|
"""
|
|
return _datamodel.Notifier_cmp(self, *args)
|
|
|
|
# Register Notifier in _datamodel:
|
|
_datamodel.Notifier_swigregister(Notifier)
|
|
|
|
def Notifier_ClassName():
|
|
r"""Notifier_ClassName() -> char const *"""
|
|
return _datamodel.Notifier_ClassName()
|
|
|
|
def Notifier_TypeInfo():
|
|
r"""Notifier_TypeInfo() -> RTTI"""
|
|
return _datamodel.Notifier_TypeInfo()
|
|
|
|
def Notifier_Cast(*args):
|
|
r"""
|
|
Notifier_Cast(BaseObject o) -> Notifier
|
|
Notifier_Cast(Seiscomp::Core::BaseObjectPtr o) -> Notifier
|
|
"""
|
|
return _datamodel.Notifier_Cast(*args)
|
|
|
|
def Notifier_ConstCast(*args):
|
|
r"""
|
|
Notifier_ConstCast(BaseObject o) -> Notifier
|
|
Notifier_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Notifier
|
|
"""
|
|
return _datamodel.Notifier_ConstCast(*args)
|
|
|
|
def Notifier_Meta():
|
|
r"""Notifier_Meta() -> MetaObject"""
|
|
return _datamodel.Notifier_Meta()
|
|
|
|
def Notifier_Enable():
|
|
r"""Notifier_Enable()"""
|
|
return _datamodel.Notifier_Enable()
|
|
|
|
def Notifier_Disable():
|
|
r"""Notifier_Disable()"""
|
|
return _datamodel.Notifier_Disable()
|
|
|
|
def Notifier_SetEnabled(arg1):
|
|
r"""Notifier_SetEnabled(bool arg1)"""
|
|
return _datamodel.Notifier_SetEnabled(arg1)
|
|
|
|
def Notifier_IsEnabled():
|
|
r"""Notifier_IsEnabled() -> bool"""
|
|
return _datamodel.Notifier_IsEnabled()
|
|
|
|
def Notifier_SetCheckEnabled(arg1):
|
|
r"""Notifier_SetCheckEnabled(bool arg1)"""
|
|
return _datamodel.Notifier_SetCheckEnabled(arg1)
|
|
|
|
def Notifier_IsCheckEnabled():
|
|
r"""Notifier_IsCheckEnabled() -> bool"""
|
|
return _datamodel.Notifier_IsCheckEnabled()
|
|
|
|
def Notifier_GetMessage(allNotifier=True):
|
|
r"""Notifier_GetMessage(bool allNotifier=True) -> NotifierMessage"""
|
|
return _datamodel.Notifier_GetMessage(allNotifier)
|
|
|
|
def Notifier_Size():
|
|
r"""Notifier_Size() -> size_t"""
|
|
return _datamodel.Notifier_Size()
|
|
|
|
def Notifier_Clear():
|
|
r"""Notifier_Clear()"""
|
|
return _datamodel.Notifier_Clear()
|
|
|
|
def Notifier_Create(*args):
|
|
r"""
|
|
Notifier_Create(std::string const & parentID, Seiscomp::DataModel::Operation op, Object object) -> Notifier
|
|
Notifier_Create(PublicObject parent, Seiscomp::DataModel::Operation op, Object object) -> Notifier
|
|
"""
|
|
return _datamodel.Notifier_Create(*args)
|
|
|
|
class NotifierCreator(Visitor):
|
|
r"""Proxy of C++ Seiscomp::DataModel::NotifierCreator 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, op):
|
|
r"""__init__(NotifierCreator self, Seiscomp::DataModel::Operation op) -> NotifierCreator"""
|
|
_datamodel.NotifierCreator_swiginit(self, _datamodel.new_NotifierCreator(op))
|
|
|
|
def visit(self, *args):
|
|
r"""
|
|
visit(NotifierCreator self, PublicObject arg2) -> bool
|
|
visit(NotifierCreator self, Object arg2)
|
|
"""
|
|
return _datamodel.NotifierCreator_visit(self, *args)
|
|
__swig_destroy__ = _datamodel.delete_NotifierCreator
|
|
|
|
# Register NotifierCreator in _datamodel:
|
|
_datamodel.NotifierCreator_swigregister(NotifierCreator)
|
|
|
|
|
|
def eventRegion(arg1):
|
|
r"""eventRegion(Event arg1) -> std::string"""
|
|
return _datamodel.eventRegion(arg1)
|
|
NETWORK_CODE_NOT_FOUND = _datamodel.NETWORK_CODE_NOT_FOUND
|
|
|
|
NETWORK_EPOCH_NOT_FOUND = _datamodel.NETWORK_EPOCH_NOT_FOUND
|
|
|
|
STATION_CODE_NOT_FOUND = _datamodel.STATION_CODE_NOT_FOUND
|
|
|
|
STATION_EPOCH_NOT_FOUND = _datamodel.STATION_EPOCH_NOT_FOUND
|
|
|
|
SENSOR_CODE_NOT_FOUND = _datamodel.SENSOR_CODE_NOT_FOUND
|
|
|
|
SENSOR_EPOCH_NOT_FOUND = _datamodel.SENSOR_EPOCH_NOT_FOUND
|
|
|
|
STREAM_CODE_NOT_FOUND = _datamodel.STREAM_CODE_NOT_FOUND
|
|
|
|
STREAM_EPOCH_NOT_FOUND = _datamodel.STREAM_EPOCH_NOT_FOUND
|
|
|
|
EInventoryErrorQuantity = _datamodel.EInventoryErrorQuantity
|
|
|
|
class EInventoryErrorNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EInventoryErrorNames 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__(EInventoryErrorNames self) -> EInventoryErrorNames"""
|
|
_datamodel.EInventoryErrorNames_swiginit(self, _datamodel.new_EInventoryErrorNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EInventoryErrorNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EInventoryErrorNames
|
|
|
|
# Register EInventoryErrorNames in _datamodel:
|
|
_datamodel.EInventoryErrorNames_swigregister(EInventoryErrorNames)
|
|
|
|
def EInventoryErrorNames_name(i):
|
|
r"""EInventoryErrorNames_name(int i) -> char const *"""
|
|
return _datamodel.EInventoryErrorNames_name(i)
|
|
|
|
|
|
def getStation(*args):
|
|
r"""
|
|
getStation(Inventory inventory, std::string const & networkCode, std::string const & stationCode, Time arg4, Seiscomp::DataModel::InventoryError * error=None) -> Station
|
|
getStation(Inventory inventory, Pick pick) -> Station
|
|
"""
|
|
return _datamodel.getStation(*args)
|
|
|
|
def getSensorLocation(*args):
|
|
r"""
|
|
getSensorLocation(Inventory inventory, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, Time arg5, Seiscomp::DataModel::InventoryError * error=None) -> SensorLocation
|
|
getSensorLocation(Inventory inventory, Pick pick) -> SensorLocation
|
|
"""
|
|
return _datamodel.getSensorLocation(*args)
|
|
|
|
def getStream(*args):
|
|
r"""
|
|
getStream(Inventory inventory, 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 inventory, Pick pick) -> Stream
|
|
"""
|
|
return _datamodel.getStream(*args)
|
|
class ThreeComponents(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ThreeComponents class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
Vertical = _datamodel.ThreeComponents_Vertical
|
|
|
|
FirstHorizontal = _datamodel.ThreeComponents_FirstHorizontal
|
|
|
|
SecondHorizontal = _datamodel.ThreeComponents_SecondHorizontal
|
|
|
|
|
|
def vertical(self):
|
|
r"""vertical(ThreeComponents self) -> Stream"""
|
|
return _datamodel.ThreeComponents_vertical(self)
|
|
|
|
def firstHorizontal(self):
|
|
r"""firstHorizontal(ThreeComponents self) -> Stream"""
|
|
return _datamodel.ThreeComponents_firstHorizontal(self)
|
|
|
|
def secondHorizontal(self):
|
|
r"""secondHorizontal(ThreeComponents self) -> Stream"""
|
|
return _datamodel.ThreeComponents_secondHorizontal(self)
|
|
|
|
def __init__(self):
|
|
r"""__init__(ThreeComponents self) -> ThreeComponents"""
|
|
_datamodel.ThreeComponents_swiginit(self, _datamodel.new_ThreeComponents())
|
|
comps = property(_datamodel.ThreeComponents_comps_get, _datamodel.ThreeComponents_comps_set, doc=r"""comps : a(3).p.Seiscomp::DataModel::Stream""")
|
|
__swig_destroy__ = _datamodel.delete_ThreeComponents
|
|
|
|
# Register ThreeComponents in _datamodel:
|
|
_datamodel.ThreeComponents_swigregister(ThreeComponents)
|
|
|
|
|
|
def getVerticalComponent(loc, streamCode, time):
|
|
r"""getVerticalComponent(SensorLocation loc, char const * streamCode, Time time) -> Stream"""
|
|
return _datamodel.getVerticalComponent(loc, streamCode, time)
|
|
|
|
def getThreeComponents(res, loc, streamCode, time):
|
|
r"""getThreeComponents(ThreeComponents res, SensorLocation loc, char const * streamCode, Time time) -> bool"""
|
|
return _datamodel.getThreeComponents(res, loc, streamCode, time)
|
|
|
|
def findSetup(configStation, setupName, allowGlobal=True):
|
|
r"""findSetup(ConfigStation configStation, std::string const & setupName, bool allowGlobal=True) -> Setup"""
|
|
return _datamodel.findSetup(configStation, setupName, allowGlobal)
|
|
|
|
def copy(obj):
|
|
r"""copy(Object obj) -> Object"""
|
|
return _datamodel.copy(obj)
|
|
|
|
def id(*args):
|
|
r"""
|
|
id(Network net) -> std::string
|
|
id(Station sta) -> std::string
|
|
id(SensorLocation loc, char const * unsetCode="") -> std::string
|
|
id(Stream stream, char const * unsetCode="", bool includeComponent=True) -> std::string
|
|
"""
|
|
return _datamodel.id(*args)
|
|
|
|
def getLocation(*args):
|
|
r"""
|
|
getLocation(Station sta) -> GeoCoordinate
|
|
getLocation(SensorLocation loc) -> GeoCoordinate
|
|
getLocation(Stream stream) -> GeoCoordinate
|
|
"""
|
|
return _datamodel.getLocation(*args)
|
|
class DiffMerge(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DiffMerge 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__(DiffMerge self) -> DiffMerge"""
|
|
_datamodel.DiffMerge_swiginit(self, _datamodel.new_DiffMerge())
|
|
|
|
def setLoggingLevel(self, level):
|
|
r"""setLoggingLevel(DiffMerge self, int level)"""
|
|
return _datamodel.DiffMerge_setLoggingLevel(self, level)
|
|
|
|
def showLog(self, *args):
|
|
r"""showLog(DiffMerge self, std::ostream & os=std::cerr, int padding=0, int indent=1, bool ignoreFirstPad=False)"""
|
|
return _datamodel.DiffMerge_showLog(self, *args)
|
|
|
|
def find(self, tree, node):
|
|
r"""find(DiffMerge self, Object tree, Object node) -> Object"""
|
|
return _datamodel.DiffMerge_find(self, tree, node)
|
|
|
|
def diff(self, o1, o2, diffList):
|
|
r"""diff(DiffMerge self, Object o1, Object o2, std::vector< Seiscomp::DataModel::NotifierPtr,std::allocator< Seiscomp::DataModel::NotifierPtr > > & diffList) -> bool"""
|
|
return _datamodel.DiffMerge_diff(self, o1, o2, diffList)
|
|
|
|
def diff2Message(self, o1, o2):
|
|
r"""diff2Message(DiffMerge self, Object o1, Object o2) -> NotifierMessage"""
|
|
return _datamodel.DiffMerge_diff2Message(self, o1, o2)
|
|
|
|
def merge(self, *args):
|
|
r"""
|
|
merge(DiffMerge self, Object tree, Object node, std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > & idMap) -> bool
|
|
merge(DiffMerge self, Object mergeResult, std::vector< Seiscomp::DataModel::Object *,std::allocator< Seiscomp::DataModel::Object * > > const & objects) -> bool
|
|
"""
|
|
return _datamodel.DiffMerge_merge(self, *args)
|
|
|
|
def validateReferences(self, o):
|
|
r"""validateReferences(DiffMerge self, Object o) -> bool"""
|
|
return _datamodel.DiffMerge_validateReferences(self, o)
|
|
|
|
def mapReferences(self, o, publicIDMap):
|
|
r"""mapReferences(DiffMerge self, Object o, std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > const & publicIDMap) -> size_t"""
|
|
return _datamodel.DiffMerge_mapReferences(self, o, publicIDMap)
|
|
|
|
def compareObjects(self, o1, o2):
|
|
r"""compareObjects(DiffMerge self, Object o1, Object o2) -> bool"""
|
|
return _datamodel.DiffMerge_compareObjects(self, o1, o2)
|
|
__swig_destroy__ = _datamodel.delete_DiffMerge
|
|
|
|
# Register DiffMerge in _datamodel:
|
|
_datamodel.DiffMerge_swigregister(DiffMerge)
|
|
|
|
class Diff2(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Diff2 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__(Diff2 self) -> Diff2"""
|
|
_datamodel.Diff2_swiginit(self, _datamodel.new_Diff2())
|
|
__swig_destroy__ = _datamodel.delete_Diff2
|
|
|
|
def diff2Message(self, o1, o2, o1ParentID, logNode=None):
|
|
r"""diff2Message(Diff2 self, Object o1, Object o2, std::string const & o1ParentID, Seiscomp::DataModel::Diff2::LogNode * logNode=None) -> NotifierMessage"""
|
|
return _datamodel.Diff2_diff2Message(self, o1, o2, o1ParentID, logNode)
|
|
|
|
# Register Diff2 in _datamodel:
|
|
_datamodel.Diff2_swigregister(Diff2)
|
|
|
|
class Diff3(Diff2):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Diff3 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__ = _datamodel.delete_Diff3
|
|
|
|
# Register Diff3 in _datamodel:
|
|
_datamodel.Diff3_swigregister(Diff3)
|
|
|
|
class Diff4(Diff3):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Diff4 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__ = _datamodel.delete_Diff4
|
|
|
|
# Register Diff4 in _datamodel:
|
|
_datamodel.Diff4_swigregister(Diff4)
|
|
|
|
class PublicObjectCacheIterator(object):
|
|
r"""Proxy of C++ PublicObjectCacheIterator 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, cache):
|
|
r"""__init__(PublicObjectCacheIterator self, PublicObjectCache cache) -> PublicObjectCacheIterator"""
|
|
_datamodel.PublicObjectCacheIterator_swiginit(self, _datamodel.new_PublicObjectCacheIterator(cache))
|
|
|
|
def next(self):
|
|
r"""next(PublicObjectCacheIterator self) -> PublicObject"""
|
|
return _datamodel.PublicObjectCacheIterator_next(self)
|
|
|
|
def __next__(self):
|
|
o = self.next()
|
|
if o is None:
|
|
raise StopIteration
|
|
return o
|
|
|
|
__swig_destroy__ = _datamodel.delete_PublicObjectCacheIterator
|
|
|
|
# Register PublicObjectCacheIterator in _datamodel:
|
|
_datamodel.PublicObjectCacheIterator_swigregister(PublicObjectCacheIterator)
|
|
|
|
HORIZONTAL = _datamodel.HORIZONTAL
|
|
|
|
ELLIPSE = _datamodel.ELLIPSE
|
|
|
|
ELLIPSOID = _datamodel.ELLIPSOID
|
|
|
|
PDF = _datamodel.PDF
|
|
|
|
EOriginUncertaintyDescriptionQuantity = _datamodel.EOriginUncertaintyDescriptionQuantity
|
|
|
|
class EOriginUncertaintyDescriptionNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EOriginUncertaintyDescriptionNames 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__(EOriginUncertaintyDescriptionNames self) -> EOriginUncertaintyDescriptionNames"""
|
|
_datamodel.EOriginUncertaintyDescriptionNames_swiginit(self, _datamodel.new_EOriginUncertaintyDescriptionNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EOriginUncertaintyDescriptionNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EOriginUncertaintyDescriptionNames
|
|
|
|
# Register EOriginUncertaintyDescriptionNames in _datamodel:
|
|
_datamodel.EOriginUncertaintyDescriptionNames_swigregister(EOriginUncertaintyDescriptionNames)
|
|
|
|
def EOriginUncertaintyDescriptionNames_name(i):
|
|
r"""EOriginUncertaintyDescriptionNames_name(int i) -> char const *"""
|
|
return _datamodel.EOriginUncertaintyDescriptionNames_name(i)
|
|
|
|
CMT_S = _datamodel.CMT_S
|
|
|
|
CMT_Q = _datamodel.CMT_Q
|
|
|
|
EMomentTensorStatusQuantity = _datamodel.EMomentTensorStatusQuantity
|
|
|
|
class EMomentTensorStatusNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EMomentTensorStatusNames 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__(EMomentTensorStatusNames self) -> EMomentTensorStatusNames"""
|
|
_datamodel.EMomentTensorStatusNames_swiginit(self, _datamodel.new_EMomentTensorStatusNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EMomentTensorStatusNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EMomentTensorStatusNames
|
|
|
|
# Register EMomentTensorStatusNames in _datamodel:
|
|
_datamodel.EMomentTensorStatusNames_swigregister(EMomentTensorStatusNames)
|
|
|
|
def EMomentTensorStatusNames_name(i):
|
|
r"""EMomentTensorStatusNames_name(int i) -> char const *"""
|
|
return _datamodel.EMomentTensorStatusNames_name(i)
|
|
|
|
FROM_LOCATION = _datamodel.FROM_LOCATION
|
|
|
|
FROM_MOMENT_TENSOR_INVERSION = _datamodel.FROM_MOMENT_TENSOR_INVERSION
|
|
|
|
BROAD_BAND_P_WAVEFORMS = _datamodel.BROAD_BAND_P_WAVEFORMS
|
|
|
|
CONSTRAINED_BY_DEPTH_PHASES = _datamodel.CONSTRAINED_BY_DEPTH_PHASES
|
|
|
|
CONSTRAINED_BY_DIRECT_PHASES = _datamodel.CONSTRAINED_BY_DIRECT_PHASES
|
|
|
|
OPERATOR_ASSIGNED = _datamodel.OPERATOR_ASSIGNED
|
|
|
|
OTHER_ORIGIN_DEPTH = _datamodel.OTHER_ORIGIN_DEPTH
|
|
|
|
EOriginDepthTypeQuantity = _datamodel.EOriginDepthTypeQuantity
|
|
|
|
class EOriginDepthTypeNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EOriginDepthTypeNames 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__(EOriginDepthTypeNames self) -> EOriginDepthTypeNames"""
|
|
_datamodel.EOriginDepthTypeNames_swiginit(self, _datamodel.new_EOriginDepthTypeNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EOriginDepthTypeNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EOriginDepthTypeNames
|
|
|
|
# Register EOriginDepthTypeNames in _datamodel:
|
|
_datamodel.EOriginDepthTypeNames_swigregister(EOriginDepthTypeNames)
|
|
|
|
def EOriginDepthTypeNames_name(i):
|
|
r"""EOriginDepthTypeNames_name(int i) -> char const *"""
|
|
return _datamodel.EOriginDepthTypeNames_name(i)
|
|
|
|
HYPOCENTER = _datamodel.HYPOCENTER
|
|
|
|
CENTROID = _datamodel.CENTROID
|
|
|
|
AMPLITUDE = _datamodel.AMPLITUDE
|
|
|
|
MACROSEISMIC = _datamodel.MACROSEISMIC
|
|
|
|
RUPTURE_START = _datamodel.RUPTURE_START
|
|
|
|
RUPTURE_END = _datamodel.RUPTURE_END
|
|
|
|
EOriginTypeQuantity = _datamodel.EOriginTypeQuantity
|
|
|
|
class EOriginTypeNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EOriginTypeNames 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__(EOriginTypeNames self) -> EOriginTypeNames"""
|
|
_datamodel.EOriginTypeNames_swiginit(self, _datamodel.new_EOriginTypeNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EOriginTypeNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EOriginTypeNames
|
|
|
|
# Register EOriginTypeNames in _datamodel:
|
|
_datamodel.EOriginTypeNames_swigregister(EOriginTypeNames)
|
|
|
|
def EOriginTypeNames_name(i):
|
|
r"""EOriginTypeNames_name(int i) -> char const *"""
|
|
return _datamodel.EOriginTypeNames_name(i)
|
|
|
|
MANUAL = _datamodel.MANUAL
|
|
|
|
AUTOMATIC = _datamodel.AUTOMATIC
|
|
|
|
EEvaluationModeQuantity = _datamodel.EEvaluationModeQuantity
|
|
|
|
class EEvaluationModeNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EEvaluationModeNames 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__(EEvaluationModeNames self) -> EEvaluationModeNames"""
|
|
_datamodel.EEvaluationModeNames_swiginit(self, _datamodel.new_EEvaluationModeNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EEvaluationModeNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EEvaluationModeNames
|
|
|
|
# Register EEvaluationModeNames in _datamodel:
|
|
_datamodel.EEvaluationModeNames_swigregister(EEvaluationModeNames)
|
|
|
|
def EEvaluationModeNames_name(i):
|
|
r"""EEvaluationModeNames_name(int i) -> char const *"""
|
|
return _datamodel.EEvaluationModeNames_name(i)
|
|
|
|
PRELIMINARY = _datamodel.PRELIMINARY
|
|
|
|
CONFIRMED = _datamodel.CONFIRMED
|
|
|
|
REVIEWED = _datamodel.REVIEWED
|
|
|
|
FINAL = _datamodel.FINAL
|
|
|
|
REJECTED = _datamodel.REJECTED
|
|
|
|
REPORTED = _datamodel.REPORTED
|
|
|
|
EEvaluationStatusQuantity = _datamodel.EEvaluationStatusQuantity
|
|
|
|
class EEvaluationStatusNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EEvaluationStatusNames 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__(EEvaluationStatusNames self) -> EEvaluationStatusNames"""
|
|
_datamodel.EEvaluationStatusNames_swiginit(self, _datamodel.new_EEvaluationStatusNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EEvaluationStatusNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EEvaluationStatusNames
|
|
|
|
# Register EEvaluationStatusNames in _datamodel:
|
|
_datamodel.EEvaluationStatusNames_swigregister(EEvaluationStatusNames)
|
|
|
|
def EEvaluationStatusNames_name(i):
|
|
r"""EEvaluationStatusNames_name(int i) -> char const *"""
|
|
return _datamodel.EEvaluationStatusNames_name(i)
|
|
|
|
EMERGENT = _datamodel.EMERGENT
|
|
|
|
IMPULSIVE = _datamodel.IMPULSIVE
|
|
|
|
QUESTIONABLE = _datamodel.QUESTIONABLE
|
|
|
|
EPickOnsetQuantity = _datamodel.EPickOnsetQuantity
|
|
|
|
class EPickOnsetNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EPickOnsetNames 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__(EPickOnsetNames self) -> EPickOnsetNames"""
|
|
_datamodel.EPickOnsetNames_swiginit(self, _datamodel.new_EPickOnsetNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EPickOnsetNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EPickOnsetNames
|
|
|
|
# Register EPickOnsetNames in _datamodel:
|
|
_datamodel.EPickOnsetNames_swigregister(EPickOnsetNames)
|
|
|
|
def EPickOnsetNames_name(i):
|
|
r"""EPickOnsetNames_name(int i) -> char const *"""
|
|
return _datamodel.EPickOnsetNames_name(i)
|
|
|
|
CMT_0 = _datamodel.CMT_0
|
|
|
|
CMT_1 = _datamodel.CMT_1
|
|
|
|
CMT_2 = _datamodel.CMT_2
|
|
|
|
TELESEISMIC = _datamodel.TELESEISMIC
|
|
|
|
REGIONAL = _datamodel.REGIONAL
|
|
|
|
EMomentTensorMethodQuantity = _datamodel.EMomentTensorMethodQuantity
|
|
|
|
class EMomentTensorMethodNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EMomentTensorMethodNames 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__(EMomentTensorMethodNames self) -> EMomentTensorMethodNames"""
|
|
_datamodel.EMomentTensorMethodNames_swiginit(self, _datamodel.new_EMomentTensorMethodNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EMomentTensorMethodNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EMomentTensorMethodNames
|
|
|
|
# Register EMomentTensorMethodNames in _datamodel:
|
|
_datamodel.EMomentTensorMethodNames_swigregister(EMomentTensorMethodNames)
|
|
|
|
def EMomentTensorMethodNames_name(i):
|
|
r"""EMomentTensorMethodNames_name(int i) -> char const *"""
|
|
return _datamodel.EMomentTensorMethodNames_name(i)
|
|
|
|
BODY_WAVES = _datamodel.BODY_WAVES
|
|
|
|
P_BODY_WAVES = _datamodel.P_BODY_WAVES
|
|
|
|
LONG_PERIOD_BODY_WAVES = _datamodel.LONG_PERIOD_BODY_WAVES
|
|
|
|
SURFACE_WAVES = _datamodel.SURFACE_WAVES
|
|
|
|
INTERMEDIATE_PERIOD_SURFACE_WAVES = _datamodel.INTERMEDIATE_PERIOD_SURFACE_WAVES
|
|
|
|
LONG_PERIOD_MANTLE_WAVES = _datamodel.LONG_PERIOD_MANTLE_WAVES
|
|
|
|
UNKNOWN_WAVETYPE = _datamodel.UNKNOWN_WAVETYPE
|
|
|
|
EDataUsedWaveTypeQuantity = _datamodel.EDataUsedWaveTypeQuantity
|
|
|
|
class EDataUsedWaveTypeNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EDataUsedWaveTypeNames 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__(EDataUsedWaveTypeNames self) -> EDataUsedWaveTypeNames"""
|
|
_datamodel.EDataUsedWaveTypeNames_swiginit(self, _datamodel.new_EDataUsedWaveTypeNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EDataUsedWaveTypeNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EDataUsedWaveTypeNames
|
|
|
|
# Register EDataUsedWaveTypeNames in _datamodel:
|
|
_datamodel.EDataUsedWaveTypeNames_swigregister(EDataUsedWaveTypeNames)
|
|
|
|
def EDataUsedWaveTypeNames_name(i):
|
|
r"""EDataUsedWaveTypeNames_name(int i) -> char const *"""
|
|
return _datamodel.EDataUsedWaveTypeNames_name(i)
|
|
|
|
FELT_REPORT = _datamodel.FELT_REPORT
|
|
|
|
FLINN_ENGDAHL_REGION = _datamodel.FLINN_ENGDAHL_REGION
|
|
|
|
LOCAL_TIME = _datamodel.LOCAL_TIME
|
|
|
|
TECTONIC_SUMMARY = _datamodel.TECTONIC_SUMMARY
|
|
|
|
NEAREST_CITIES = _datamodel.NEAREST_CITIES
|
|
|
|
EARTHQUAKE_NAME = _datamodel.EARTHQUAKE_NAME
|
|
|
|
REGION_NAME = _datamodel.REGION_NAME
|
|
|
|
EEventDescriptionTypeQuantity = _datamodel.EEventDescriptionTypeQuantity
|
|
|
|
class EEventDescriptionTypeNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EEventDescriptionTypeNames 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__(EEventDescriptionTypeNames self) -> EEventDescriptionTypeNames"""
|
|
_datamodel.EEventDescriptionTypeNames_swiginit(self, _datamodel.new_EEventDescriptionTypeNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EEventDescriptionTypeNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EEventDescriptionTypeNames
|
|
|
|
# Register EEventDescriptionTypeNames in _datamodel:
|
|
_datamodel.EEventDescriptionTypeNames_swigregister(EEventDescriptionTypeNames)
|
|
|
|
def EEventDescriptionTypeNames_name(i):
|
|
r"""EEventDescriptionTypeNames_name(int i) -> char const *"""
|
|
return _datamodel.EEventDescriptionTypeNames_name(i)
|
|
|
|
NOT_EXISTING = _datamodel.NOT_EXISTING
|
|
|
|
NOT_LOCATABLE = _datamodel.NOT_LOCATABLE
|
|
|
|
OUTSIDE_OF_NETWORK_INTEREST = _datamodel.OUTSIDE_OF_NETWORK_INTEREST
|
|
|
|
EARTHQUAKE = _datamodel.EARTHQUAKE
|
|
|
|
INDUCED_EARTHQUAKE = _datamodel.INDUCED_EARTHQUAKE
|
|
|
|
QUARRY_BLAST = _datamodel.QUARRY_BLAST
|
|
|
|
EXPLOSION = _datamodel.EXPLOSION
|
|
|
|
CHEMICAL_EXPLOSION = _datamodel.CHEMICAL_EXPLOSION
|
|
|
|
NUCLEAR_EXPLOSION = _datamodel.NUCLEAR_EXPLOSION
|
|
|
|
LANDSLIDE = _datamodel.LANDSLIDE
|
|
|
|
ROCKSLIDE = _datamodel.ROCKSLIDE
|
|
|
|
SNOW_AVALANCHE = _datamodel.SNOW_AVALANCHE
|
|
|
|
DEBRIS_AVALANCHE = _datamodel.DEBRIS_AVALANCHE
|
|
|
|
MINE_COLLAPSE = _datamodel.MINE_COLLAPSE
|
|
|
|
BUILDING_COLLAPSE = _datamodel.BUILDING_COLLAPSE
|
|
|
|
VOLCANIC_ERUPTION = _datamodel.VOLCANIC_ERUPTION
|
|
|
|
METEOR_IMPACT = _datamodel.METEOR_IMPACT
|
|
|
|
PLANE_CRASH = _datamodel.PLANE_CRASH
|
|
|
|
SONIC_BOOM = _datamodel.SONIC_BOOM
|
|
|
|
DUPLICATE = _datamodel.DUPLICATE
|
|
|
|
OTHER_EVENT = _datamodel.OTHER_EVENT
|
|
|
|
NOT_REPORTED = _datamodel.NOT_REPORTED
|
|
|
|
ANTHROPOGENIC_EVENT = _datamodel.ANTHROPOGENIC_EVENT
|
|
|
|
COLLAPSE = _datamodel.COLLAPSE
|
|
|
|
CAVITY_COLLAPSE = _datamodel.CAVITY_COLLAPSE
|
|
|
|
ACCIDENTAL_EXPLOSION = _datamodel.ACCIDENTAL_EXPLOSION
|
|
|
|
CONTROLLED_EXPLOSION = _datamodel.CONTROLLED_EXPLOSION
|
|
|
|
EXPERIMENTAL_EXPLOSION = _datamodel.EXPERIMENTAL_EXPLOSION
|
|
|
|
INDUSTRIAL_EXPLOSION = _datamodel.INDUSTRIAL_EXPLOSION
|
|
|
|
MINING_EXPLOSION = _datamodel.MINING_EXPLOSION
|
|
|
|
ROAD_CUT = _datamodel.ROAD_CUT
|
|
|
|
BLASTING_LEVEE = _datamodel.BLASTING_LEVEE
|
|
|
|
INDUCED_OR_TRIGGERED_EVENT = _datamodel.INDUCED_OR_TRIGGERED_EVENT
|
|
|
|
ROCK_BURST = _datamodel.ROCK_BURST
|
|
|
|
RESERVOIR_LOADING = _datamodel.RESERVOIR_LOADING
|
|
|
|
FLUID_INJECTION = _datamodel.FLUID_INJECTION
|
|
|
|
FLUID_EXTRACTION = _datamodel.FLUID_EXTRACTION
|
|
|
|
CRASH = _datamodel.CRASH
|
|
|
|
TRAIN_CRASH = _datamodel.TRAIN_CRASH
|
|
|
|
BOAT_CRASH = _datamodel.BOAT_CRASH
|
|
|
|
ATMOSPHERIC_EVENT = _datamodel.ATMOSPHERIC_EVENT
|
|
|
|
SONIC_BLAST = _datamodel.SONIC_BLAST
|
|
|
|
ACOUSTIC_NOISE = _datamodel.ACOUSTIC_NOISE
|
|
|
|
THUNDER = _datamodel.THUNDER
|
|
|
|
AVALANCHE = _datamodel.AVALANCHE
|
|
|
|
HYDROACOUSTIC_EVENT = _datamodel.HYDROACOUSTIC_EVENT
|
|
|
|
ICE_QUAKE = _datamodel.ICE_QUAKE
|
|
|
|
SLIDE = _datamodel.SLIDE
|
|
|
|
METEORITE = _datamodel.METEORITE
|
|
|
|
CALVING = _datamodel.CALVING
|
|
|
|
FROST_QUAKE = _datamodel.FROST_QUAKE
|
|
|
|
TREMOR_PULSE = _datamodel.TREMOR_PULSE
|
|
|
|
SUBMARINE_LANDSLIDE = _datamodel.SUBMARINE_LANDSLIDE
|
|
|
|
ROCKET_LAUNCH = _datamodel.ROCKET_LAUNCH
|
|
|
|
ROCKET = _datamodel.ROCKET
|
|
|
|
ROCKET_IMPACT = _datamodel.ROCKET_IMPACT
|
|
|
|
ARTILLERY_STRIKE = _datamodel.ARTILLERY_STRIKE
|
|
|
|
BOMB_DETONATION = _datamodel.BOMB_DETONATION
|
|
|
|
MOVING_AIRCRAFT = _datamodel.MOVING_AIRCRAFT
|
|
|
|
ATMOSPHERIC_METEOR_EXPLOSION = _datamodel.ATMOSPHERIC_METEOR_EXPLOSION
|
|
|
|
EEventTypeQuantity = _datamodel.EEventTypeQuantity
|
|
|
|
class EEventTypeNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EEventTypeNames 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__(EEventTypeNames self) -> EEventTypeNames"""
|
|
_datamodel.EEventTypeNames_swiginit(self, _datamodel.new_EEventTypeNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EEventTypeNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EEventTypeNames
|
|
|
|
# Register EEventTypeNames in _datamodel:
|
|
_datamodel.EEventTypeNames_swigregister(EEventTypeNames)
|
|
|
|
def EEventTypeNames_name(i):
|
|
r"""EEventTypeNames_name(int i) -> char const *"""
|
|
return _datamodel.EEventTypeNames_name(i)
|
|
|
|
KNOWN = _datamodel.KNOWN
|
|
|
|
SUSPECTED = _datamodel.SUSPECTED
|
|
|
|
DAMAGING = _datamodel.DAMAGING
|
|
|
|
FELT = _datamodel.FELT
|
|
|
|
EEventTypeCertaintyQuantity = _datamodel.EEventTypeCertaintyQuantity
|
|
|
|
class EEventTypeCertaintyNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EEventTypeCertaintyNames 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__(EEventTypeCertaintyNames self) -> EEventTypeCertaintyNames"""
|
|
_datamodel.EEventTypeCertaintyNames_swiginit(self, _datamodel.new_EEventTypeCertaintyNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EEventTypeCertaintyNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EEventTypeCertaintyNames
|
|
|
|
# Register EEventTypeCertaintyNames in _datamodel:
|
|
_datamodel.EEventTypeCertaintyNames_swigregister(EEventTypeCertaintyNames)
|
|
|
|
def EEventTypeCertaintyNames_name(i):
|
|
r"""EEventTypeCertaintyNames_name(int i) -> char const *"""
|
|
return _datamodel.EEventTypeCertaintyNames_name(i)
|
|
|
|
BOX_CAR = _datamodel.BOX_CAR
|
|
|
|
TRIANGLE = _datamodel.TRIANGLE
|
|
|
|
TRAPEZOID = _datamodel.TRAPEZOID
|
|
|
|
UNKNOWN_FUNCTION = _datamodel.UNKNOWN_FUNCTION
|
|
|
|
ESourceTimeFunctionTypeQuantity = _datamodel.ESourceTimeFunctionTypeQuantity
|
|
|
|
class ESourceTimeFunctionTypeNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ESourceTimeFunctionTypeNames 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__(ESourceTimeFunctionTypeNames self) -> ESourceTimeFunctionTypeNames"""
|
|
_datamodel.ESourceTimeFunctionTypeNames_swiginit(self, _datamodel.new_ESourceTimeFunctionTypeNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.ESourceTimeFunctionTypeNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_ESourceTimeFunctionTypeNames
|
|
|
|
# Register ESourceTimeFunctionTypeNames in _datamodel:
|
|
_datamodel.ESourceTimeFunctionTypeNames_swigregister(ESourceTimeFunctionTypeNames)
|
|
|
|
def ESourceTimeFunctionTypeNames_name(i):
|
|
r"""ESourceTimeFunctionTypeNames_name(int i) -> char const *"""
|
|
return _datamodel.ESourceTimeFunctionTypeNames_name(i)
|
|
|
|
POSITIVE = _datamodel.POSITIVE
|
|
|
|
NEGATIVE = _datamodel.NEGATIVE
|
|
|
|
UNDECIDABLE = _datamodel.UNDECIDABLE
|
|
|
|
EPickPolarityQuantity = _datamodel.EPickPolarityQuantity
|
|
|
|
class EPickPolarityNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EPickPolarityNames 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__(EPickPolarityNames self) -> EPickPolarityNames"""
|
|
_datamodel.EPickPolarityNames_swiginit(self, _datamodel.new_EPickPolarityNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EPickPolarityNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EPickPolarityNames
|
|
|
|
# Register EPickPolarityNames in _datamodel:
|
|
_datamodel.EPickPolarityNames_swigregister(EPickPolarityNames)
|
|
|
|
def EPickPolarityNames_name(i):
|
|
r"""EPickPolarityNames_name(int i) -> char const *"""
|
|
return _datamodel.EPickPolarityNames_name(i)
|
|
|
|
DEPLOYMENT = _datamodel.DEPLOYMENT
|
|
|
|
ARRAY = _datamodel.ARRAY
|
|
|
|
EStationGroupTypeQuantity = _datamodel.EStationGroupTypeQuantity
|
|
|
|
class EStationGroupTypeNames(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EStationGroupTypeNames 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__(EStationGroupTypeNames self) -> EStationGroupTypeNames"""
|
|
_datamodel.EStationGroupTypeNames_swiginit(self, _datamodel.new_EStationGroupTypeNames())
|
|
|
|
@staticmethod
|
|
def name(i):
|
|
r"""name(int i) -> char const *"""
|
|
return _datamodel.EStationGroupTypeNames_name(i)
|
|
__swig_destroy__ = _datamodel.delete_EStationGroupTypeNames
|
|
|
|
# Register EStationGroupTypeNames in _datamodel:
|
|
_datamodel.EStationGroupTypeNames_swigregister(EStationGroupTypeNames)
|
|
|
|
def EStationGroupTypeNames_name(i):
|
|
r"""EStationGroupTypeNames_name(int i) -> char const *"""
|
|
return _datamodel.EStationGroupTypeNames_name(i)
|
|
|
|
class RealArray(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::RealArray 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 _datamodel.RealArray_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.RealArray_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(RealArray self) -> char const *"""
|
|
return _datamodel.RealArray_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(RealArray self) -> RTTI"""
|
|
return _datamodel.RealArray_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> RealArray
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> RealArray
|
|
"""
|
|
return _datamodel.RealArray_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> RealArray
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RealArray
|
|
"""
|
|
return _datamodel.RealArray_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(RealArray self, GenericArchive ar)"""
|
|
return _datamodel.RealArray_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.RealArray_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(RealArray self) -> MetaObject"""
|
|
return _datamodel.RealArray_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(RealArray self) -> RealArray
|
|
__init__(RealArray self, RealArray other) -> RealArray
|
|
"""
|
|
_datamodel.RealArray_swiginit(self, _datamodel.new_RealArray(*args))
|
|
__swig_destroy__ = _datamodel.delete_RealArray
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(RealArray self, RealArray other) -> bool"""
|
|
return _datamodel.RealArray___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(RealArray self, RealArray other) -> bool"""
|
|
return _datamodel.RealArray___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(RealArray self, RealArray other) -> bool"""
|
|
return _datamodel.RealArray_equal(self, other)
|
|
|
|
def setContent(self, arg2):
|
|
r"""setContent(RealArray self, vectord arg2)"""
|
|
return _datamodel.RealArray_setContent(self, arg2)
|
|
|
|
def content(self, *args):
|
|
r"""
|
|
content(RealArray self) -> vectord
|
|
content(RealArray self) -> vectord
|
|
"""
|
|
return _datamodel.RealArray_content(self, *args)
|
|
|
|
# Register RealArray in _datamodel:
|
|
_datamodel.RealArray_swigregister(RealArray)
|
|
|
|
def RealArray_ClassName():
|
|
r"""RealArray_ClassName() -> char const *"""
|
|
return _datamodel.RealArray_ClassName()
|
|
|
|
def RealArray_TypeInfo():
|
|
r"""RealArray_TypeInfo() -> RTTI"""
|
|
return _datamodel.RealArray_TypeInfo()
|
|
|
|
def RealArray_Cast(*args):
|
|
r"""
|
|
RealArray_Cast(BaseObject o) -> RealArray
|
|
RealArray_Cast(Seiscomp::Core::BaseObjectPtr o) -> RealArray
|
|
"""
|
|
return _datamodel.RealArray_Cast(*args)
|
|
|
|
def RealArray_ConstCast(*args):
|
|
r"""
|
|
RealArray_ConstCast(BaseObject o) -> RealArray
|
|
RealArray_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RealArray
|
|
"""
|
|
return _datamodel.RealArray_ConstCast(*args)
|
|
|
|
def RealArray_Meta():
|
|
r"""RealArray_Meta() -> MetaObject"""
|
|
return _datamodel.RealArray_Meta()
|
|
|
|
class TimeArray(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::TimeArray 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 _datamodel.TimeArray_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.TimeArray_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(TimeArray self) -> char const *"""
|
|
return _datamodel.TimeArray_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(TimeArray self) -> RTTI"""
|
|
return _datamodel.TimeArray_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> TimeArray
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> TimeArray
|
|
"""
|
|
return _datamodel.TimeArray_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> TimeArray
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimeArray
|
|
"""
|
|
return _datamodel.TimeArray_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(TimeArray self, GenericArchive ar)"""
|
|
return _datamodel.TimeArray_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.TimeArray_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(TimeArray self) -> MetaObject"""
|
|
return _datamodel.TimeArray_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(TimeArray self) -> TimeArray
|
|
__init__(TimeArray self, TimeArray other) -> TimeArray
|
|
"""
|
|
_datamodel.TimeArray_swiginit(self, _datamodel.new_TimeArray(*args))
|
|
__swig_destroy__ = _datamodel.delete_TimeArray
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(TimeArray self, TimeArray other) -> bool"""
|
|
return _datamodel.TimeArray___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(TimeArray self, TimeArray other) -> bool"""
|
|
return _datamodel.TimeArray___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(TimeArray self, TimeArray other) -> bool"""
|
|
return _datamodel.TimeArray_equal(self, other)
|
|
|
|
def setContent(self, arg2):
|
|
r"""setContent(TimeArray self, std::vector< Seiscomp::Core::Time,std::allocator< Seiscomp::Core::Time > > const & arg2)"""
|
|
return _datamodel.TimeArray_setContent(self, arg2)
|
|
|
|
def content(self, *args):
|
|
r"""
|
|
content(TimeArray self) -> std::vector< Seiscomp::Core::Time,std::allocator< Seiscomp::Core::Time > > const
|
|
content(TimeArray self) -> std::vector< Seiscomp::Core::Time,std::allocator< Seiscomp::Core::Time > > &
|
|
"""
|
|
return _datamodel.TimeArray_content(self, *args)
|
|
|
|
# Register TimeArray in _datamodel:
|
|
_datamodel.TimeArray_swigregister(TimeArray)
|
|
|
|
def TimeArray_ClassName():
|
|
r"""TimeArray_ClassName() -> char const *"""
|
|
return _datamodel.TimeArray_ClassName()
|
|
|
|
def TimeArray_TypeInfo():
|
|
r"""TimeArray_TypeInfo() -> RTTI"""
|
|
return _datamodel.TimeArray_TypeInfo()
|
|
|
|
def TimeArray_Cast(*args):
|
|
r"""
|
|
TimeArray_Cast(BaseObject o) -> TimeArray
|
|
TimeArray_Cast(Seiscomp::Core::BaseObjectPtr o) -> TimeArray
|
|
"""
|
|
return _datamodel.TimeArray_Cast(*args)
|
|
|
|
def TimeArray_ConstCast(*args):
|
|
r"""
|
|
TimeArray_ConstCast(BaseObject o) -> TimeArray
|
|
TimeArray_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimeArray
|
|
"""
|
|
return _datamodel.TimeArray_ConstCast(*args)
|
|
|
|
def TimeArray_Meta():
|
|
r"""TimeArray_Meta() -> MetaObject"""
|
|
return _datamodel.TimeArray_Meta()
|
|
|
|
class TimePDF1D(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::TimePDF1D 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 _datamodel.TimePDF1D_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.TimePDF1D_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(TimePDF1D self) -> char const *"""
|
|
return _datamodel.TimePDF1D_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(TimePDF1D self) -> RTTI"""
|
|
return _datamodel.TimePDF1D_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> TimePDF1D
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> TimePDF1D
|
|
"""
|
|
return _datamodel.TimePDF1D_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> TimePDF1D
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimePDF1D
|
|
"""
|
|
return _datamodel.TimePDF1D_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(TimePDF1D self, GenericArchive ar)"""
|
|
return _datamodel.TimePDF1D_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.TimePDF1D_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(TimePDF1D self) -> MetaObject"""
|
|
return _datamodel.TimePDF1D_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(TimePDF1D self) -> TimePDF1D
|
|
__init__(TimePDF1D self, TimePDF1D other) -> TimePDF1D
|
|
"""
|
|
_datamodel.TimePDF1D_swiginit(self, _datamodel.new_TimePDF1D(*args))
|
|
__swig_destroy__ = _datamodel.delete_TimePDF1D
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(TimePDF1D self, TimePDF1D other) -> bool"""
|
|
return _datamodel.TimePDF1D___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(TimePDF1D self, TimePDF1D other) -> bool"""
|
|
return _datamodel.TimePDF1D___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(TimePDF1D self, TimePDF1D other) -> bool"""
|
|
return _datamodel.TimePDF1D_equal(self, other)
|
|
|
|
def setVariable(self, variable):
|
|
r"""setVariable(TimePDF1D self, TimeArray variable)"""
|
|
return _datamodel.TimePDF1D_setVariable(self, variable)
|
|
|
|
def variable(self, *args):
|
|
r"""
|
|
variable(TimePDF1D self) -> TimeArray
|
|
variable(TimePDF1D self) -> TimeArray
|
|
"""
|
|
return _datamodel.TimePDF1D_variable(self, *args)
|
|
|
|
def setProbability(self, probability):
|
|
r"""setProbability(TimePDF1D self, RealArray probability)"""
|
|
return _datamodel.TimePDF1D_setProbability(self, probability)
|
|
|
|
def probability(self, *args):
|
|
r"""
|
|
probability(TimePDF1D self) -> RealArray
|
|
probability(TimePDF1D self) -> RealArray
|
|
"""
|
|
return _datamodel.TimePDF1D_probability(self, *args)
|
|
|
|
# Register TimePDF1D in _datamodel:
|
|
_datamodel.TimePDF1D_swigregister(TimePDF1D)
|
|
|
|
def TimePDF1D_ClassName():
|
|
r"""TimePDF1D_ClassName() -> char const *"""
|
|
return _datamodel.TimePDF1D_ClassName()
|
|
|
|
def TimePDF1D_TypeInfo():
|
|
r"""TimePDF1D_TypeInfo() -> RTTI"""
|
|
return _datamodel.TimePDF1D_TypeInfo()
|
|
|
|
def TimePDF1D_Cast(*args):
|
|
r"""
|
|
TimePDF1D_Cast(BaseObject o) -> TimePDF1D
|
|
TimePDF1D_Cast(Seiscomp::Core::BaseObjectPtr o) -> TimePDF1D
|
|
"""
|
|
return _datamodel.TimePDF1D_Cast(*args)
|
|
|
|
def TimePDF1D_ConstCast(*args):
|
|
r"""
|
|
TimePDF1D_ConstCast(BaseObject o) -> TimePDF1D
|
|
TimePDF1D_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimePDF1D
|
|
"""
|
|
return _datamodel.TimePDF1D_ConstCast(*args)
|
|
|
|
def TimePDF1D_Meta():
|
|
r"""TimePDF1D_Meta() -> MetaObject"""
|
|
return _datamodel.TimePDF1D_Meta()
|
|
|
|
class TimeQuantity(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::TimeQuantity 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 _datamodel.TimeQuantity_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.TimeQuantity_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(TimeQuantity self) -> char const *"""
|
|
return _datamodel.TimeQuantity_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(TimeQuantity self) -> RTTI"""
|
|
return _datamodel.TimeQuantity_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> TimeQuantity
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> TimeQuantity
|
|
"""
|
|
return _datamodel.TimeQuantity_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> TimeQuantity
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimeQuantity
|
|
"""
|
|
return _datamodel.TimeQuantity_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(TimeQuantity self, GenericArchive ar)"""
|
|
return _datamodel.TimeQuantity_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.TimeQuantity_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(TimeQuantity self) -> MetaObject"""
|
|
return _datamodel.TimeQuantity_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(TimeQuantity self) -> TimeQuantity
|
|
__init__(TimeQuantity self, TimeQuantity other) -> TimeQuantity
|
|
__init__(TimeQuantity self, Time value, Seiscomp::Core::Optional< double >::Impl const & uncertainty=Unset, Seiscomp::Core::Optional< double >::Impl const & lowerUncertainty=Unset, Seiscomp::Core::Optional< double >::Impl const & upperUncertainty=Unset, Seiscomp::Core::Optional< double >::Impl const & confidenceLevel=Unset, Seiscomp::Core::Optional< Seiscomp::DataModel::TimePDF1D >::Impl const & pdf=Unset) -> TimeQuantity
|
|
"""
|
|
_datamodel.TimeQuantity_swiginit(self, _datamodel.new_TimeQuantity(*args))
|
|
__swig_destroy__ = _datamodel.delete_TimeQuantity
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(TimeQuantity self, TimeQuantity other) -> bool"""
|
|
return _datamodel.TimeQuantity___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(TimeQuantity self, TimeQuantity other) -> bool"""
|
|
return _datamodel.TimeQuantity___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(TimeQuantity self, TimeQuantity other) -> bool"""
|
|
return _datamodel.TimeQuantity_equal(self, other)
|
|
|
|
def setValue(self, value):
|
|
r"""setValue(TimeQuantity self, Time value)"""
|
|
return _datamodel.TimeQuantity_setValue(self, value)
|
|
|
|
def value(self):
|
|
r"""value(TimeQuantity self) -> Time"""
|
|
return _datamodel.TimeQuantity_value(self)
|
|
|
|
def setUncertainty(self, uncertainty):
|
|
r"""setUncertainty(TimeQuantity self, Seiscomp::Core::Optional< double >::Impl const & uncertainty)"""
|
|
return _datamodel.TimeQuantity_setUncertainty(self, uncertainty)
|
|
|
|
def uncertainty(self):
|
|
r"""uncertainty(TimeQuantity self) -> double"""
|
|
return _datamodel.TimeQuantity_uncertainty(self)
|
|
|
|
def setLowerUncertainty(self, lowerUncertainty):
|
|
r"""setLowerUncertainty(TimeQuantity self, Seiscomp::Core::Optional< double >::Impl const & lowerUncertainty)"""
|
|
return _datamodel.TimeQuantity_setLowerUncertainty(self, lowerUncertainty)
|
|
|
|
def lowerUncertainty(self):
|
|
r"""lowerUncertainty(TimeQuantity self) -> double"""
|
|
return _datamodel.TimeQuantity_lowerUncertainty(self)
|
|
|
|
def setUpperUncertainty(self, upperUncertainty):
|
|
r"""setUpperUncertainty(TimeQuantity self, Seiscomp::Core::Optional< double >::Impl const & upperUncertainty)"""
|
|
return _datamodel.TimeQuantity_setUpperUncertainty(self, upperUncertainty)
|
|
|
|
def upperUncertainty(self):
|
|
r"""upperUncertainty(TimeQuantity self) -> double"""
|
|
return _datamodel.TimeQuantity_upperUncertainty(self)
|
|
|
|
def setConfidenceLevel(self, confidenceLevel):
|
|
r"""setConfidenceLevel(TimeQuantity self, Seiscomp::Core::Optional< double >::Impl const & confidenceLevel)"""
|
|
return _datamodel.TimeQuantity_setConfidenceLevel(self, confidenceLevel)
|
|
|
|
def confidenceLevel(self):
|
|
r"""confidenceLevel(TimeQuantity self) -> double"""
|
|
return _datamodel.TimeQuantity_confidenceLevel(self)
|
|
|
|
def setPdf(self, pdf):
|
|
r"""setPdf(TimeQuantity self, Seiscomp::Core::Optional< Seiscomp::DataModel::TimePDF1D >::Impl const & pdf)"""
|
|
return _datamodel.TimeQuantity_setPdf(self, pdf)
|
|
|
|
def pdf(self, *args):
|
|
r"""
|
|
pdf(TimeQuantity self) -> TimePDF1D
|
|
pdf(TimeQuantity self) -> TimePDF1D
|
|
"""
|
|
return _datamodel.TimeQuantity_pdf(self, *args)
|
|
|
|
# Register TimeQuantity in _datamodel:
|
|
_datamodel.TimeQuantity_swigregister(TimeQuantity)
|
|
|
|
def TimeQuantity_ClassName():
|
|
r"""TimeQuantity_ClassName() -> char const *"""
|
|
return _datamodel.TimeQuantity_ClassName()
|
|
|
|
def TimeQuantity_TypeInfo():
|
|
r"""TimeQuantity_TypeInfo() -> RTTI"""
|
|
return _datamodel.TimeQuantity_TypeInfo()
|
|
|
|
def TimeQuantity_Cast(*args):
|
|
r"""
|
|
TimeQuantity_Cast(BaseObject o) -> TimeQuantity
|
|
TimeQuantity_Cast(Seiscomp::Core::BaseObjectPtr o) -> TimeQuantity
|
|
"""
|
|
return _datamodel.TimeQuantity_Cast(*args)
|
|
|
|
def TimeQuantity_ConstCast(*args):
|
|
r"""
|
|
TimeQuantity_ConstCast(BaseObject o) -> TimeQuantity
|
|
TimeQuantity_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimeQuantity
|
|
"""
|
|
return _datamodel.TimeQuantity_ConstCast(*args)
|
|
|
|
def TimeQuantity_Meta():
|
|
r"""TimeQuantity_Meta() -> MetaObject"""
|
|
return _datamodel.TimeQuantity_Meta()
|
|
|
|
class CreationInfo(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::CreationInfo 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 _datamodel.CreationInfo_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.CreationInfo_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(CreationInfo self) -> char const *"""
|
|
return _datamodel.CreationInfo_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(CreationInfo self) -> RTTI"""
|
|
return _datamodel.CreationInfo_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> CreationInfo
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> CreationInfo
|
|
"""
|
|
return _datamodel.CreationInfo_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> CreationInfo
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> CreationInfo
|
|
"""
|
|
return _datamodel.CreationInfo_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(CreationInfo self, GenericArchive ar)"""
|
|
return _datamodel.CreationInfo_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.CreationInfo_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(CreationInfo self) -> MetaObject"""
|
|
return _datamodel.CreationInfo_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(CreationInfo self) -> CreationInfo
|
|
__init__(CreationInfo self, CreationInfo other) -> CreationInfo
|
|
"""
|
|
_datamodel.CreationInfo_swiginit(self, _datamodel.new_CreationInfo(*args))
|
|
__swig_destroy__ = _datamodel.delete_CreationInfo
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(CreationInfo self, CreationInfo other) -> bool"""
|
|
return _datamodel.CreationInfo___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(CreationInfo self, CreationInfo other) -> bool"""
|
|
return _datamodel.CreationInfo___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(CreationInfo self, CreationInfo other) -> bool"""
|
|
return _datamodel.CreationInfo_equal(self, other)
|
|
|
|
def setAgencyID(self, agencyID):
|
|
r"""setAgencyID(CreationInfo self, std::string const & agencyID)"""
|
|
return _datamodel.CreationInfo_setAgencyID(self, agencyID)
|
|
|
|
def agencyID(self):
|
|
r"""agencyID(CreationInfo self) -> std::string const &"""
|
|
return _datamodel.CreationInfo_agencyID(self)
|
|
|
|
def setAgencyURI(self, agencyURI):
|
|
r"""setAgencyURI(CreationInfo self, std::string const & agencyURI)"""
|
|
return _datamodel.CreationInfo_setAgencyURI(self, agencyURI)
|
|
|
|
def agencyURI(self):
|
|
r"""agencyURI(CreationInfo self) -> std::string const &"""
|
|
return _datamodel.CreationInfo_agencyURI(self)
|
|
|
|
def setAuthor(self, author):
|
|
r"""setAuthor(CreationInfo self, std::string const & author)"""
|
|
return _datamodel.CreationInfo_setAuthor(self, author)
|
|
|
|
def author(self):
|
|
r"""author(CreationInfo self) -> std::string const &"""
|
|
return _datamodel.CreationInfo_author(self)
|
|
|
|
def setAuthorURI(self, authorURI):
|
|
r"""setAuthorURI(CreationInfo self, std::string const & authorURI)"""
|
|
return _datamodel.CreationInfo_setAuthorURI(self, authorURI)
|
|
|
|
def authorURI(self):
|
|
r"""authorURI(CreationInfo self) -> std::string const &"""
|
|
return _datamodel.CreationInfo_authorURI(self)
|
|
|
|
def setCreationTime(self, creationTime):
|
|
r"""setCreationTime(CreationInfo self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & creationTime)"""
|
|
return _datamodel.CreationInfo_setCreationTime(self, creationTime)
|
|
|
|
def creationTime(self):
|
|
r"""creationTime(CreationInfo self) -> Time"""
|
|
return _datamodel.CreationInfo_creationTime(self)
|
|
|
|
def setModificationTime(self, modificationTime):
|
|
r"""setModificationTime(CreationInfo self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & modificationTime)"""
|
|
return _datamodel.CreationInfo_setModificationTime(self, modificationTime)
|
|
|
|
def modificationTime(self):
|
|
r"""modificationTime(CreationInfo self) -> Time"""
|
|
return _datamodel.CreationInfo_modificationTime(self)
|
|
|
|
def setVersion(self, version):
|
|
r"""setVersion(CreationInfo self, std::string const & version)"""
|
|
return _datamodel.CreationInfo_setVersion(self, version)
|
|
|
|
def version(self):
|
|
r"""version(CreationInfo self) -> std::string const &"""
|
|
return _datamodel.CreationInfo_version(self)
|
|
|
|
# Register CreationInfo in _datamodel:
|
|
_datamodel.CreationInfo_swigregister(CreationInfo)
|
|
|
|
def CreationInfo_ClassName():
|
|
r"""CreationInfo_ClassName() -> char const *"""
|
|
return _datamodel.CreationInfo_ClassName()
|
|
|
|
def CreationInfo_TypeInfo():
|
|
r"""CreationInfo_TypeInfo() -> RTTI"""
|
|
return _datamodel.CreationInfo_TypeInfo()
|
|
|
|
def CreationInfo_Cast(*args):
|
|
r"""
|
|
CreationInfo_Cast(BaseObject o) -> CreationInfo
|
|
CreationInfo_Cast(Seiscomp::Core::BaseObjectPtr o) -> CreationInfo
|
|
"""
|
|
return _datamodel.CreationInfo_Cast(*args)
|
|
|
|
def CreationInfo_ConstCast(*args):
|
|
r"""
|
|
CreationInfo_ConstCast(BaseObject o) -> CreationInfo
|
|
CreationInfo_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> CreationInfo
|
|
"""
|
|
return _datamodel.CreationInfo_ConstCast(*args)
|
|
|
|
def CreationInfo_Meta():
|
|
r"""CreationInfo_Meta() -> MetaObject"""
|
|
return _datamodel.CreationInfo_Meta()
|
|
|
|
class Phase(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Phase 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 _datamodel.Phase_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Phase_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Phase self) -> char const *"""
|
|
return _datamodel.Phase_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Phase self) -> RTTI"""
|
|
return _datamodel.Phase_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Phase
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Phase
|
|
"""
|
|
return _datamodel.Phase_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Phase
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Phase
|
|
"""
|
|
return _datamodel.Phase_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Phase self, GenericArchive ar)"""
|
|
return _datamodel.Phase_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Phase_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Phase self) -> MetaObject"""
|
|
return _datamodel.Phase_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Phase self) -> Phase
|
|
__init__(Phase self, Phase other) -> Phase
|
|
__init__(Phase self, std::string const & code) -> Phase
|
|
"""
|
|
_datamodel.Phase_swiginit(self, _datamodel.new_Phase(*args))
|
|
__swig_destroy__ = _datamodel.delete_Phase
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Phase self, Phase other) -> bool"""
|
|
return _datamodel.Phase___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Phase self, Phase other) -> bool"""
|
|
return _datamodel.Phase___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Phase self, Phase other) -> bool"""
|
|
return _datamodel.Phase_equal(self, other)
|
|
|
|
def setCode(self, code):
|
|
r"""setCode(Phase self, std::string const & code)"""
|
|
return _datamodel.Phase_setCode(self, code)
|
|
|
|
def code(self):
|
|
r"""code(Phase self) -> std::string const &"""
|
|
return _datamodel.Phase_code(self)
|
|
|
|
# Register Phase in _datamodel:
|
|
_datamodel.Phase_swigregister(Phase)
|
|
|
|
def Phase_ClassName():
|
|
r"""Phase_ClassName() -> char const *"""
|
|
return _datamodel.Phase_ClassName()
|
|
|
|
def Phase_TypeInfo():
|
|
r"""Phase_TypeInfo() -> RTTI"""
|
|
return _datamodel.Phase_TypeInfo()
|
|
|
|
def Phase_Cast(*args):
|
|
r"""
|
|
Phase_Cast(BaseObject o) -> Phase
|
|
Phase_Cast(Seiscomp::Core::BaseObjectPtr o) -> Phase
|
|
"""
|
|
return _datamodel.Phase_Cast(*args)
|
|
|
|
def Phase_ConstCast(*args):
|
|
r"""
|
|
Phase_ConstCast(BaseObject o) -> Phase
|
|
Phase_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Phase
|
|
"""
|
|
return _datamodel.Phase_ConstCast(*args)
|
|
|
|
def Phase_Meta():
|
|
r"""Phase_Meta() -> MetaObject"""
|
|
return _datamodel.Phase_Meta()
|
|
|
|
class CommentIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::CommentIndex 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__(CommentIndex self) -> CommentIndex
|
|
__init__(CommentIndex self, std::string const & id) -> CommentIndex
|
|
__init__(CommentIndex self, CommentIndex arg2) -> CommentIndex
|
|
"""
|
|
_datamodel.CommentIndex_swiginit(self, _datamodel.new_CommentIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(CommentIndex self, CommentIndex arg2) -> bool"""
|
|
return _datamodel.CommentIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(CommentIndex self, CommentIndex arg2) -> bool"""
|
|
return _datamodel.CommentIndex___ne__(self, arg2)
|
|
id = property(_datamodel.CommentIndex_id_get, _datamodel.CommentIndex_id_set, doc=r"""id : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_CommentIndex
|
|
|
|
# Register CommentIndex in _datamodel:
|
|
_datamodel.CommentIndex_swigregister(CommentIndex)
|
|
|
|
class Comment(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Comment 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 _datamodel.Comment_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Comment_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Comment self) -> char const *"""
|
|
return _datamodel.Comment_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Comment self) -> RTTI"""
|
|
return _datamodel.Comment_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Comment
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Comment
|
|
"""
|
|
return _datamodel.Comment_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Comment
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Comment
|
|
"""
|
|
return _datamodel.Comment_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Comment self, GenericArchive ar)"""
|
|
return _datamodel.Comment_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Comment_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Comment self) -> MetaObject"""
|
|
return _datamodel.Comment_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Comment self) -> Comment
|
|
__init__(Comment self, Comment other) -> Comment
|
|
"""
|
|
_datamodel.Comment_swiginit(self, _datamodel.new_Comment(*args))
|
|
__swig_destroy__ = _datamodel.delete_Comment
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Comment self, Comment other) -> bool"""
|
|
return _datamodel.Comment___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Comment self, Comment other) -> bool"""
|
|
return _datamodel.Comment___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Comment self, Comment other) -> bool"""
|
|
return _datamodel.Comment_equal(self, other)
|
|
|
|
def setText(self, text):
|
|
r"""setText(Comment self, std::string const & text)"""
|
|
return _datamodel.Comment_setText(self, text)
|
|
|
|
def text(self):
|
|
r"""text(Comment self) -> std::string const &"""
|
|
return _datamodel.Comment_text(self)
|
|
|
|
def setId(self, id):
|
|
r"""setId(Comment self, std::string const & id)"""
|
|
return _datamodel.Comment_setId(self, id)
|
|
|
|
def id(self):
|
|
r"""id(Comment self) -> std::string const &"""
|
|
return _datamodel.Comment_id(self)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(Comment self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & start)"""
|
|
return _datamodel.Comment_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(Comment self) -> Time"""
|
|
return _datamodel.Comment_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(Comment self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
|
|
return _datamodel.Comment_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(Comment self) -> Time"""
|
|
return _datamodel.Comment_end(self)
|
|
|
|
def setCreationInfo(self, creationInfo):
|
|
r"""setCreationInfo(Comment self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
|
|
return _datamodel.Comment_setCreationInfo(self, creationInfo)
|
|
|
|
def creationInfo(self, *args):
|
|
r"""
|
|
creationInfo(Comment self) -> CreationInfo
|
|
creationInfo(Comment self) -> CreationInfo
|
|
"""
|
|
return _datamodel.Comment_creationInfo(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(Comment self) -> CommentIndex"""
|
|
return _datamodel.Comment_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(Comment self, Comment lhs) -> bool"""
|
|
return _datamodel.Comment_equalIndex(self, lhs)
|
|
|
|
def momentTensor(self):
|
|
r"""momentTensor(Comment self) -> MomentTensor"""
|
|
return _datamodel.Comment_momentTensor(self)
|
|
|
|
def focalMechanism(self):
|
|
r"""focalMechanism(Comment self) -> FocalMechanism"""
|
|
return _datamodel.Comment_focalMechanism(self)
|
|
|
|
def amplitude(self):
|
|
r"""amplitude(Comment self) -> Amplitude"""
|
|
return _datamodel.Comment_amplitude(self)
|
|
|
|
def magnitude(self):
|
|
r"""magnitude(Comment self) -> Magnitude"""
|
|
return _datamodel.Comment_magnitude(self)
|
|
|
|
def stationMagnitude(self):
|
|
r"""stationMagnitude(Comment self) -> StationMagnitude"""
|
|
return _datamodel.Comment_stationMagnitude(self)
|
|
|
|
def pick(self):
|
|
r"""pick(Comment self) -> Pick"""
|
|
return _datamodel.Comment_pick(self)
|
|
|
|
def event(self):
|
|
r"""event(Comment self) -> Event"""
|
|
return _datamodel.Comment_event(self)
|
|
|
|
def origin(self):
|
|
r"""origin(Comment self) -> Origin"""
|
|
return _datamodel.Comment_origin(self)
|
|
|
|
def parameter(self):
|
|
r"""parameter(Comment self) -> Parameter"""
|
|
return _datamodel.Comment_parameter(self)
|
|
|
|
def parameterSet(self):
|
|
r"""parameterSet(Comment self) -> ParameterSet"""
|
|
return _datamodel.Comment_parameterSet(self)
|
|
|
|
def stream(self):
|
|
r"""stream(Comment self) -> Stream"""
|
|
return _datamodel.Comment_stream(self)
|
|
|
|
def sensorLocation(self):
|
|
r"""sensorLocation(Comment self) -> SensorLocation"""
|
|
return _datamodel.Comment_sensorLocation(self)
|
|
|
|
def station(self):
|
|
r"""station(Comment self) -> Station"""
|
|
return _datamodel.Comment_station(self)
|
|
|
|
def network(self):
|
|
r"""network(Comment self) -> Network"""
|
|
return _datamodel.Comment_network(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Comment self, Object other) -> bool"""
|
|
return _datamodel.Comment_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Comment self, PublicObject parent) -> bool"""
|
|
return _datamodel.Comment_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Comment self, PublicObject parent) -> bool"""
|
|
return _datamodel.Comment_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Comment self) -> bool"""
|
|
return _datamodel.Comment_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Comment self) -> Object"""
|
|
return _datamodel.Comment_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Comment self, Visitor visitor)"""
|
|
return _datamodel.Comment_accept(self, visitor)
|
|
|
|
# Register Comment in _datamodel:
|
|
_datamodel.Comment_swigregister(Comment)
|
|
|
|
def Comment_ClassName():
|
|
r"""Comment_ClassName() -> char const *"""
|
|
return _datamodel.Comment_ClassName()
|
|
|
|
def Comment_TypeInfo():
|
|
r"""Comment_TypeInfo() -> RTTI"""
|
|
return _datamodel.Comment_TypeInfo()
|
|
|
|
def Comment_Cast(*args):
|
|
r"""
|
|
Comment_Cast(BaseObject o) -> Comment
|
|
Comment_Cast(Seiscomp::Core::BaseObjectPtr o) -> Comment
|
|
"""
|
|
return _datamodel.Comment_Cast(*args)
|
|
|
|
def Comment_ConstCast(*args):
|
|
r"""
|
|
Comment_ConstCast(BaseObject o) -> Comment
|
|
Comment_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Comment
|
|
"""
|
|
return _datamodel.Comment_ConstCast(*args)
|
|
|
|
def Comment_Meta():
|
|
r"""Comment_Meta() -> MetaObject"""
|
|
return _datamodel.Comment_Meta()
|
|
|
|
class ComplexArray(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ComplexArray 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 _datamodel.ComplexArray_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ComplexArray_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ComplexArray self) -> char const *"""
|
|
return _datamodel.ComplexArray_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ComplexArray self) -> RTTI"""
|
|
return _datamodel.ComplexArray_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ComplexArray
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ComplexArray
|
|
"""
|
|
return _datamodel.ComplexArray_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ComplexArray
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ComplexArray
|
|
"""
|
|
return _datamodel.ComplexArray_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ComplexArray self, GenericArchive ar)"""
|
|
return _datamodel.ComplexArray_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ComplexArray_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ComplexArray self) -> MetaObject"""
|
|
return _datamodel.ComplexArray_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ComplexArray self) -> ComplexArray
|
|
__init__(ComplexArray self, ComplexArray other) -> ComplexArray
|
|
"""
|
|
_datamodel.ComplexArray_swiginit(self, _datamodel.new_ComplexArray(*args))
|
|
__swig_destroy__ = _datamodel.delete_ComplexArray
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ComplexArray self, ComplexArray other) -> bool"""
|
|
return _datamodel.ComplexArray___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ComplexArray self, ComplexArray other) -> bool"""
|
|
return _datamodel.ComplexArray___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ComplexArray self, ComplexArray other) -> bool"""
|
|
return _datamodel.ComplexArray_equal(self, other)
|
|
|
|
def setContent(self, arg2):
|
|
r"""setContent(ComplexArray self, arg2)"""
|
|
return _datamodel.ComplexArray_setContent(self, arg2)
|
|
|
|
def content(self, *args):
|
|
r"""
|
|
content(ComplexArray self)
|
|
content(ComplexArray self)
|
|
"""
|
|
return _datamodel.ComplexArray_content(self, *args)
|
|
|
|
# Register ComplexArray in _datamodel:
|
|
_datamodel.ComplexArray_swigregister(ComplexArray)
|
|
|
|
def ComplexArray_ClassName():
|
|
r"""ComplexArray_ClassName() -> char const *"""
|
|
return _datamodel.ComplexArray_ClassName()
|
|
|
|
def ComplexArray_TypeInfo():
|
|
r"""ComplexArray_TypeInfo() -> RTTI"""
|
|
return _datamodel.ComplexArray_TypeInfo()
|
|
|
|
def ComplexArray_Cast(*args):
|
|
r"""
|
|
ComplexArray_Cast(BaseObject o) -> ComplexArray
|
|
ComplexArray_Cast(Seiscomp::Core::BaseObjectPtr o) -> ComplexArray
|
|
"""
|
|
return _datamodel.ComplexArray_Cast(*args)
|
|
|
|
def ComplexArray_ConstCast(*args):
|
|
r"""
|
|
ComplexArray_ConstCast(BaseObject o) -> ComplexArray
|
|
ComplexArray_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ComplexArray
|
|
"""
|
|
return _datamodel.ComplexArray_ConstCast(*args)
|
|
|
|
def ComplexArray_Meta():
|
|
r"""ComplexArray_Meta() -> MetaObject"""
|
|
return _datamodel.ComplexArray_Meta()
|
|
|
|
class RealPDF1D(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::RealPDF1D 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 _datamodel.RealPDF1D_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.RealPDF1D_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(RealPDF1D self) -> char const *"""
|
|
return _datamodel.RealPDF1D_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(RealPDF1D self) -> RTTI"""
|
|
return _datamodel.RealPDF1D_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> RealPDF1D
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> RealPDF1D
|
|
"""
|
|
return _datamodel.RealPDF1D_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> RealPDF1D
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RealPDF1D
|
|
"""
|
|
return _datamodel.RealPDF1D_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(RealPDF1D self, GenericArchive ar)"""
|
|
return _datamodel.RealPDF1D_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.RealPDF1D_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(RealPDF1D self) -> MetaObject"""
|
|
return _datamodel.RealPDF1D_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(RealPDF1D self) -> RealPDF1D
|
|
__init__(RealPDF1D self, RealPDF1D other) -> RealPDF1D
|
|
"""
|
|
_datamodel.RealPDF1D_swiginit(self, _datamodel.new_RealPDF1D(*args))
|
|
__swig_destroy__ = _datamodel.delete_RealPDF1D
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(RealPDF1D self, RealPDF1D other) -> bool"""
|
|
return _datamodel.RealPDF1D___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(RealPDF1D self, RealPDF1D other) -> bool"""
|
|
return _datamodel.RealPDF1D___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(RealPDF1D self, RealPDF1D other) -> bool"""
|
|
return _datamodel.RealPDF1D_equal(self, other)
|
|
|
|
def setVariable(self, variable):
|
|
r"""setVariable(RealPDF1D self, RealArray variable)"""
|
|
return _datamodel.RealPDF1D_setVariable(self, variable)
|
|
|
|
def variable(self, *args):
|
|
r"""
|
|
variable(RealPDF1D self) -> RealArray
|
|
variable(RealPDF1D self) -> RealArray
|
|
"""
|
|
return _datamodel.RealPDF1D_variable(self, *args)
|
|
|
|
def setProbability(self, probability):
|
|
r"""setProbability(RealPDF1D self, RealArray probability)"""
|
|
return _datamodel.RealPDF1D_setProbability(self, probability)
|
|
|
|
def probability(self, *args):
|
|
r"""
|
|
probability(RealPDF1D self) -> RealArray
|
|
probability(RealPDF1D self) -> RealArray
|
|
"""
|
|
return _datamodel.RealPDF1D_probability(self, *args)
|
|
|
|
# Register RealPDF1D in _datamodel:
|
|
_datamodel.RealPDF1D_swigregister(RealPDF1D)
|
|
|
|
def RealPDF1D_ClassName():
|
|
r"""RealPDF1D_ClassName() -> char const *"""
|
|
return _datamodel.RealPDF1D_ClassName()
|
|
|
|
def RealPDF1D_TypeInfo():
|
|
r"""RealPDF1D_TypeInfo() -> RTTI"""
|
|
return _datamodel.RealPDF1D_TypeInfo()
|
|
|
|
def RealPDF1D_Cast(*args):
|
|
r"""
|
|
RealPDF1D_Cast(BaseObject o) -> RealPDF1D
|
|
RealPDF1D_Cast(Seiscomp::Core::BaseObjectPtr o) -> RealPDF1D
|
|
"""
|
|
return _datamodel.RealPDF1D_Cast(*args)
|
|
|
|
def RealPDF1D_ConstCast(*args):
|
|
r"""
|
|
RealPDF1D_ConstCast(BaseObject o) -> RealPDF1D
|
|
RealPDF1D_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RealPDF1D
|
|
"""
|
|
return _datamodel.RealPDF1D_ConstCast(*args)
|
|
|
|
def RealPDF1D_Meta():
|
|
r"""RealPDF1D_Meta() -> MetaObject"""
|
|
return _datamodel.RealPDF1D_Meta()
|
|
|
|
class RealQuantity(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::RealQuantity 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 _datamodel.RealQuantity_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.RealQuantity_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(RealQuantity self) -> char const *"""
|
|
return _datamodel.RealQuantity_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(RealQuantity self) -> RTTI"""
|
|
return _datamodel.RealQuantity_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> RealQuantity
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> RealQuantity
|
|
"""
|
|
return _datamodel.RealQuantity_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> RealQuantity
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RealQuantity
|
|
"""
|
|
return _datamodel.RealQuantity_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(RealQuantity self, GenericArchive ar)"""
|
|
return _datamodel.RealQuantity_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.RealQuantity_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(RealQuantity self) -> MetaObject"""
|
|
return _datamodel.RealQuantity_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(RealQuantity self) -> RealQuantity
|
|
__init__(RealQuantity self, RealQuantity other) -> RealQuantity
|
|
__init__(RealQuantity self, double value, Seiscomp::Core::Optional< double >::Impl const & uncertainty=Unset, Seiscomp::Core::Optional< double >::Impl const & lowerUncertainty=Unset, Seiscomp::Core::Optional< double >::Impl const & upperUncertainty=Unset, Seiscomp::Core::Optional< double >::Impl const & confidenceLevel=Unset, Seiscomp::Core::Optional< Seiscomp::DataModel::RealPDF1D >::Impl const & pdf=Unset) -> RealQuantity
|
|
"""
|
|
_datamodel.RealQuantity_swiginit(self, _datamodel.new_RealQuantity(*args))
|
|
__swig_destroy__ = _datamodel.delete_RealQuantity
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(RealQuantity self, RealQuantity other) -> bool"""
|
|
return _datamodel.RealQuantity___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(RealQuantity self, RealQuantity other) -> bool"""
|
|
return _datamodel.RealQuantity___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(RealQuantity self, RealQuantity other) -> bool"""
|
|
return _datamodel.RealQuantity_equal(self, other)
|
|
|
|
def setValue(self, value):
|
|
r"""setValue(RealQuantity self, double value)"""
|
|
return _datamodel.RealQuantity_setValue(self, value)
|
|
|
|
def value(self):
|
|
r"""value(RealQuantity self) -> double"""
|
|
return _datamodel.RealQuantity_value(self)
|
|
|
|
def setUncertainty(self, uncertainty):
|
|
r"""setUncertainty(RealQuantity self, Seiscomp::Core::Optional< double >::Impl const & uncertainty)"""
|
|
return _datamodel.RealQuantity_setUncertainty(self, uncertainty)
|
|
|
|
def uncertainty(self):
|
|
r"""uncertainty(RealQuantity self) -> double"""
|
|
return _datamodel.RealQuantity_uncertainty(self)
|
|
|
|
def setLowerUncertainty(self, lowerUncertainty):
|
|
r"""setLowerUncertainty(RealQuantity self, Seiscomp::Core::Optional< double >::Impl const & lowerUncertainty)"""
|
|
return _datamodel.RealQuantity_setLowerUncertainty(self, lowerUncertainty)
|
|
|
|
def lowerUncertainty(self):
|
|
r"""lowerUncertainty(RealQuantity self) -> double"""
|
|
return _datamodel.RealQuantity_lowerUncertainty(self)
|
|
|
|
def setUpperUncertainty(self, upperUncertainty):
|
|
r"""setUpperUncertainty(RealQuantity self, Seiscomp::Core::Optional< double >::Impl const & upperUncertainty)"""
|
|
return _datamodel.RealQuantity_setUpperUncertainty(self, upperUncertainty)
|
|
|
|
def upperUncertainty(self):
|
|
r"""upperUncertainty(RealQuantity self) -> double"""
|
|
return _datamodel.RealQuantity_upperUncertainty(self)
|
|
|
|
def setConfidenceLevel(self, confidenceLevel):
|
|
r"""setConfidenceLevel(RealQuantity self, Seiscomp::Core::Optional< double >::Impl const & confidenceLevel)"""
|
|
return _datamodel.RealQuantity_setConfidenceLevel(self, confidenceLevel)
|
|
|
|
def confidenceLevel(self):
|
|
r"""confidenceLevel(RealQuantity self) -> double"""
|
|
return _datamodel.RealQuantity_confidenceLevel(self)
|
|
|
|
def setPdf(self, pdf):
|
|
r"""setPdf(RealQuantity self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealPDF1D >::Impl const & pdf)"""
|
|
return _datamodel.RealQuantity_setPdf(self, pdf)
|
|
|
|
def pdf(self, *args):
|
|
r"""
|
|
pdf(RealQuantity self) -> RealPDF1D
|
|
pdf(RealQuantity self) -> RealPDF1D
|
|
"""
|
|
return _datamodel.RealQuantity_pdf(self, *args)
|
|
|
|
# Register RealQuantity in _datamodel:
|
|
_datamodel.RealQuantity_swigregister(RealQuantity)
|
|
|
|
def RealQuantity_ClassName():
|
|
r"""RealQuantity_ClassName() -> char const *"""
|
|
return _datamodel.RealQuantity_ClassName()
|
|
|
|
def RealQuantity_TypeInfo():
|
|
r"""RealQuantity_TypeInfo() -> RTTI"""
|
|
return _datamodel.RealQuantity_TypeInfo()
|
|
|
|
def RealQuantity_Cast(*args):
|
|
r"""
|
|
RealQuantity_Cast(BaseObject o) -> RealQuantity
|
|
RealQuantity_Cast(Seiscomp::Core::BaseObjectPtr o) -> RealQuantity
|
|
"""
|
|
return _datamodel.RealQuantity_Cast(*args)
|
|
|
|
def RealQuantity_ConstCast(*args):
|
|
r"""
|
|
RealQuantity_ConstCast(BaseObject o) -> RealQuantity
|
|
RealQuantity_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RealQuantity
|
|
"""
|
|
return _datamodel.RealQuantity_ConstCast(*args)
|
|
|
|
def RealQuantity_Meta():
|
|
r"""RealQuantity_Meta() -> MetaObject"""
|
|
return _datamodel.RealQuantity_Meta()
|
|
|
|
class IntegerQuantity(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::IntegerQuantity 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 _datamodel.IntegerQuantity_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.IntegerQuantity_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(IntegerQuantity self) -> char const *"""
|
|
return _datamodel.IntegerQuantity_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(IntegerQuantity self) -> RTTI"""
|
|
return _datamodel.IntegerQuantity_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> IntegerQuantity
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> IntegerQuantity
|
|
"""
|
|
return _datamodel.IntegerQuantity_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> IntegerQuantity
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> IntegerQuantity
|
|
"""
|
|
return _datamodel.IntegerQuantity_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(IntegerQuantity self, GenericArchive ar)"""
|
|
return _datamodel.IntegerQuantity_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.IntegerQuantity_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(IntegerQuantity self) -> MetaObject"""
|
|
return _datamodel.IntegerQuantity_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(IntegerQuantity self) -> IntegerQuantity
|
|
__init__(IntegerQuantity self, IntegerQuantity other) -> IntegerQuantity
|
|
__init__(IntegerQuantity self, int value, Seiscomp::Core::Optional< int >::Impl const & uncertainty=Unset, Seiscomp::Core::Optional< int >::Impl const & lowerUncertainty=Unset, Seiscomp::Core::Optional< int >::Impl const & upperUncertainty=Unset, Seiscomp::Core::Optional< double >::Impl const & confidenceLevel=Unset) -> IntegerQuantity
|
|
"""
|
|
_datamodel.IntegerQuantity_swiginit(self, _datamodel.new_IntegerQuantity(*args))
|
|
__swig_destroy__ = _datamodel.delete_IntegerQuantity
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(IntegerQuantity self, IntegerQuantity other) -> bool"""
|
|
return _datamodel.IntegerQuantity___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(IntegerQuantity self, IntegerQuantity other) -> bool"""
|
|
return _datamodel.IntegerQuantity___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(IntegerQuantity self, IntegerQuantity other) -> bool"""
|
|
return _datamodel.IntegerQuantity_equal(self, other)
|
|
|
|
def setValue(self, value):
|
|
r"""setValue(IntegerQuantity self, int value)"""
|
|
return _datamodel.IntegerQuantity_setValue(self, value)
|
|
|
|
def value(self):
|
|
r"""value(IntegerQuantity self) -> int"""
|
|
return _datamodel.IntegerQuantity_value(self)
|
|
|
|
def setUncertainty(self, uncertainty):
|
|
r"""setUncertainty(IntegerQuantity self, Seiscomp::Core::Optional< int >::Impl const & uncertainty)"""
|
|
return _datamodel.IntegerQuantity_setUncertainty(self, uncertainty)
|
|
|
|
def uncertainty(self):
|
|
r"""uncertainty(IntegerQuantity self) -> int"""
|
|
return _datamodel.IntegerQuantity_uncertainty(self)
|
|
|
|
def setLowerUncertainty(self, lowerUncertainty):
|
|
r"""setLowerUncertainty(IntegerQuantity self, Seiscomp::Core::Optional< int >::Impl const & lowerUncertainty)"""
|
|
return _datamodel.IntegerQuantity_setLowerUncertainty(self, lowerUncertainty)
|
|
|
|
def lowerUncertainty(self):
|
|
r"""lowerUncertainty(IntegerQuantity self) -> int"""
|
|
return _datamodel.IntegerQuantity_lowerUncertainty(self)
|
|
|
|
def setUpperUncertainty(self, upperUncertainty):
|
|
r"""setUpperUncertainty(IntegerQuantity self, Seiscomp::Core::Optional< int >::Impl const & upperUncertainty)"""
|
|
return _datamodel.IntegerQuantity_setUpperUncertainty(self, upperUncertainty)
|
|
|
|
def upperUncertainty(self):
|
|
r"""upperUncertainty(IntegerQuantity self) -> int"""
|
|
return _datamodel.IntegerQuantity_upperUncertainty(self)
|
|
|
|
def setConfidenceLevel(self, confidenceLevel):
|
|
r"""setConfidenceLevel(IntegerQuantity self, Seiscomp::Core::Optional< double >::Impl const & confidenceLevel)"""
|
|
return _datamodel.IntegerQuantity_setConfidenceLevel(self, confidenceLevel)
|
|
|
|
def confidenceLevel(self):
|
|
r"""confidenceLevel(IntegerQuantity self) -> double"""
|
|
return _datamodel.IntegerQuantity_confidenceLevel(self)
|
|
|
|
# Register IntegerQuantity in _datamodel:
|
|
_datamodel.IntegerQuantity_swigregister(IntegerQuantity)
|
|
|
|
def IntegerQuantity_ClassName():
|
|
r"""IntegerQuantity_ClassName() -> char const *"""
|
|
return _datamodel.IntegerQuantity_ClassName()
|
|
|
|
def IntegerQuantity_TypeInfo():
|
|
r"""IntegerQuantity_TypeInfo() -> RTTI"""
|
|
return _datamodel.IntegerQuantity_TypeInfo()
|
|
|
|
def IntegerQuantity_Cast(*args):
|
|
r"""
|
|
IntegerQuantity_Cast(BaseObject o) -> IntegerQuantity
|
|
IntegerQuantity_Cast(Seiscomp::Core::BaseObjectPtr o) -> IntegerQuantity
|
|
"""
|
|
return _datamodel.IntegerQuantity_Cast(*args)
|
|
|
|
def IntegerQuantity_ConstCast(*args):
|
|
r"""
|
|
IntegerQuantity_ConstCast(BaseObject o) -> IntegerQuantity
|
|
IntegerQuantity_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> IntegerQuantity
|
|
"""
|
|
return _datamodel.IntegerQuantity_ConstCast(*args)
|
|
|
|
def IntegerQuantity_Meta():
|
|
r"""IntegerQuantity_Meta() -> MetaObject"""
|
|
return _datamodel.IntegerQuantity_Meta()
|
|
|
|
class Axis(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Axis 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 _datamodel.Axis_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Axis_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Axis self) -> char const *"""
|
|
return _datamodel.Axis_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Axis self) -> RTTI"""
|
|
return _datamodel.Axis_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Axis
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Axis
|
|
"""
|
|
return _datamodel.Axis_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Axis
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Axis
|
|
"""
|
|
return _datamodel.Axis_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Axis self, GenericArchive ar)"""
|
|
return _datamodel.Axis_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Axis_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Axis self) -> MetaObject"""
|
|
return _datamodel.Axis_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Axis self) -> Axis
|
|
__init__(Axis self, Axis other) -> Axis
|
|
"""
|
|
_datamodel.Axis_swiginit(self, _datamodel.new_Axis(*args))
|
|
__swig_destroy__ = _datamodel.delete_Axis
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Axis self, Axis other) -> bool"""
|
|
return _datamodel.Axis___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Axis self, Axis other) -> bool"""
|
|
return _datamodel.Axis___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Axis self, Axis other) -> bool"""
|
|
return _datamodel.Axis_equal(self, other)
|
|
|
|
def setAzimuth(self, azimuth):
|
|
r"""setAzimuth(Axis self, RealQuantity azimuth)"""
|
|
return _datamodel.Axis_setAzimuth(self, azimuth)
|
|
|
|
def azimuth(self, *args):
|
|
r"""
|
|
azimuth(Axis self) -> RealQuantity
|
|
azimuth(Axis self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Axis_azimuth(self, *args)
|
|
|
|
def setPlunge(self, plunge):
|
|
r"""setPlunge(Axis self, RealQuantity plunge)"""
|
|
return _datamodel.Axis_setPlunge(self, plunge)
|
|
|
|
def plunge(self, *args):
|
|
r"""
|
|
plunge(Axis self) -> RealQuantity
|
|
plunge(Axis self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Axis_plunge(self, *args)
|
|
|
|
def setLength(self, length):
|
|
r"""setLength(Axis self, RealQuantity length)"""
|
|
return _datamodel.Axis_setLength(self, length)
|
|
|
|
def length(self, *args):
|
|
r"""
|
|
length(Axis self) -> RealQuantity
|
|
length(Axis self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Axis_length(self, *args)
|
|
|
|
# Register Axis in _datamodel:
|
|
_datamodel.Axis_swigregister(Axis)
|
|
|
|
def Axis_ClassName():
|
|
r"""Axis_ClassName() -> char const *"""
|
|
return _datamodel.Axis_ClassName()
|
|
|
|
def Axis_TypeInfo():
|
|
r"""Axis_TypeInfo() -> RTTI"""
|
|
return _datamodel.Axis_TypeInfo()
|
|
|
|
def Axis_Cast(*args):
|
|
r"""
|
|
Axis_Cast(BaseObject o) -> Axis
|
|
Axis_Cast(Seiscomp::Core::BaseObjectPtr o) -> Axis
|
|
"""
|
|
return _datamodel.Axis_Cast(*args)
|
|
|
|
def Axis_ConstCast(*args):
|
|
r"""
|
|
Axis_ConstCast(BaseObject o) -> Axis
|
|
Axis_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Axis
|
|
"""
|
|
return _datamodel.Axis_ConstCast(*args)
|
|
|
|
def Axis_Meta():
|
|
r"""Axis_Meta() -> MetaObject"""
|
|
return _datamodel.Axis_Meta()
|
|
|
|
class PrincipalAxes(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::PrincipalAxes 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 _datamodel.PrincipalAxes_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.PrincipalAxes_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(PrincipalAxes self) -> char const *"""
|
|
return _datamodel.PrincipalAxes_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(PrincipalAxes self) -> RTTI"""
|
|
return _datamodel.PrincipalAxes_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> PrincipalAxes
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> PrincipalAxes
|
|
"""
|
|
return _datamodel.PrincipalAxes_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> PrincipalAxes
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> PrincipalAxes
|
|
"""
|
|
return _datamodel.PrincipalAxes_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(PrincipalAxes self, GenericArchive ar)"""
|
|
return _datamodel.PrincipalAxes_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.PrincipalAxes_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(PrincipalAxes self) -> MetaObject"""
|
|
return _datamodel.PrincipalAxes_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(PrincipalAxes self) -> PrincipalAxes
|
|
__init__(PrincipalAxes self, PrincipalAxes other) -> PrincipalAxes
|
|
"""
|
|
_datamodel.PrincipalAxes_swiginit(self, _datamodel.new_PrincipalAxes(*args))
|
|
__swig_destroy__ = _datamodel.delete_PrincipalAxes
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(PrincipalAxes self, PrincipalAxes other) -> bool"""
|
|
return _datamodel.PrincipalAxes___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(PrincipalAxes self, PrincipalAxes other) -> bool"""
|
|
return _datamodel.PrincipalAxes___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(PrincipalAxes self, PrincipalAxes other) -> bool"""
|
|
return _datamodel.PrincipalAxes_equal(self, other)
|
|
|
|
def setTAxis(self, tAxis):
|
|
r"""setTAxis(PrincipalAxes self, Axis tAxis)"""
|
|
return _datamodel.PrincipalAxes_setTAxis(self, tAxis)
|
|
|
|
def tAxis(self, *args):
|
|
r"""
|
|
tAxis(PrincipalAxes self) -> Axis
|
|
tAxis(PrincipalAxes self) -> Axis
|
|
"""
|
|
return _datamodel.PrincipalAxes_tAxis(self, *args)
|
|
|
|
def setPAxis(self, pAxis):
|
|
r"""setPAxis(PrincipalAxes self, Axis pAxis)"""
|
|
return _datamodel.PrincipalAxes_setPAxis(self, pAxis)
|
|
|
|
def pAxis(self, *args):
|
|
r"""
|
|
pAxis(PrincipalAxes self) -> Axis
|
|
pAxis(PrincipalAxes self) -> Axis
|
|
"""
|
|
return _datamodel.PrincipalAxes_pAxis(self, *args)
|
|
|
|
def setNAxis(self, nAxis):
|
|
r"""setNAxis(PrincipalAxes self, Seiscomp::Core::Optional< Seiscomp::DataModel::Axis >::Impl const & nAxis)"""
|
|
return _datamodel.PrincipalAxes_setNAxis(self, nAxis)
|
|
|
|
def nAxis(self, *args):
|
|
r"""
|
|
nAxis(PrincipalAxes self) -> Axis
|
|
nAxis(PrincipalAxes self) -> Axis
|
|
"""
|
|
return _datamodel.PrincipalAxes_nAxis(self, *args)
|
|
|
|
# Register PrincipalAxes in _datamodel:
|
|
_datamodel.PrincipalAxes_swigregister(PrincipalAxes)
|
|
|
|
def PrincipalAxes_ClassName():
|
|
r"""PrincipalAxes_ClassName() -> char const *"""
|
|
return _datamodel.PrincipalAxes_ClassName()
|
|
|
|
def PrincipalAxes_TypeInfo():
|
|
r"""PrincipalAxes_TypeInfo() -> RTTI"""
|
|
return _datamodel.PrincipalAxes_TypeInfo()
|
|
|
|
def PrincipalAxes_Cast(*args):
|
|
r"""
|
|
PrincipalAxes_Cast(BaseObject o) -> PrincipalAxes
|
|
PrincipalAxes_Cast(Seiscomp::Core::BaseObjectPtr o) -> PrincipalAxes
|
|
"""
|
|
return _datamodel.PrincipalAxes_Cast(*args)
|
|
|
|
def PrincipalAxes_ConstCast(*args):
|
|
r"""
|
|
PrincipalAxes_ConstCast(BaseObject o) -> PrincipalAxes
|
|
PrincipalAxes_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> PrincipalAxes
|
|
"""
|
|
return _datamodel.PrincipalAxes_ConstCast(*args)
|
|
|
|
def PrincipalAxes_Meta():
|
|
r"""PrincipalAxes_Meta() -> MetaObject"""
|
|
return _datamodel.PrincipalAxes_Meta()
|
|
|
|
class Tensor(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Tensor 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 _datamodel.Tensor_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Tensor_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Tensor self) -> char const *"""
|
|
return _datamodel.Tensor_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Tensor self) -> RTTI"""
|
|
return _datamodel.Tensor_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Tensor
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Tensor
|
|
"""
|
|
return _datamodel.Tensor_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Tensor
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Tensor
|
|
"""
|
|
return _datamodel.Tensor_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Tensor self, GenericArchive ar)"""
|
|
return _datamodel.Tensor_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Tensor_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Tensor self) -> MetaObject"""
|
|
return _datamodel.Tensor_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Tensor self) -> Tensor
|
|
__init__(Tensor self, Tensor other) -> Tensor
|
|
"""
|
|
_datamodel.Tensor_swiginit(self, _datamodel.new_Tensor(*args))
|
|
__swig_destroy__ = _datamodel.delete_Tensor
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Tensor self, Tensor other) -> bool"""
|
|
return _datamodel.Tensor___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Tensor self, Tensor other) -> bool"""
|
|
return _datamodel.Tensor___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Tensor self, Tensor other) -> bool"""
|
|
return _datamodel.Tensor_equal(self, other)
|
|
|
|
def setMrr(self, Mrr):
|
|
r"""setMrr(Tensor self, RealQuantity Mrr)"""
|
|
return _datamodel.Tensor_setMrr(self, Mrr)
|
|
|
|
def Mrr(self, *args):
|
|
r"""
|
|
Mrr(Tensor self) -> RealQuantity
|
|
Mrr(Tensor self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Tensor_Mrr(self, *args)
|
|
|
|
def setMtt(self, Mtt):
|
|
r"""setMtt(Tensor self, RealQuantity Mtt)"""
|
|
return _datamodel.Tensor_setMtt(self, Mtt)
|
|
|
|
def Mtt(self, *args):
|
|
r"""
|
|
Mtt(Tensor self) -> RealQuantity
|
|
Mtt(Tensor self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Tensor_Mtt(self, *args)
|
|
|
|
def setMpp(self, Mpp):
|
|
r"""setMpp(Tensor self, RealQuantity Mpp)"""
|
|
return _datamodel.Tensor_setMpp(self, Mpp)
|
|
|
|
def Mpp(self, *args):
|
|
r"""
|
|
Mpp(Tensor self) -> RealQuantity
|
|
Mpp(Tensor self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Tensor_Mpp(self, *args)
|
|
|
|
def setMrt(self, Mrt):
|
|
r"""setMrt(Tensor self, RealQuantity Mrt)"""
|
|
return _datamodel.Tensor_setMrt(self, Mrt)
|
|
|
|
def Mrt(self, *args):
|
|
r"""
|
|
Mrt(Tensor self) -> RealQuantity
|
|
Mrt(Tensor self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Tensor_Mrt(self, *args)
|
|
|
|
def setMrp(self, Mrp):
|
|
r"""setMrp(Tensor self, RealQuantity Mrp)"""
|
|
return _datamodel.Tensor_setMrp(self, Mrp)
|
|
|
|
def Mrp(self, *args):
|
|
r"""
|
|
Mrp(Tensor self) -> RealQuantity
|
|
Mrp(Tensor self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Tensor_Mrp(self, *args)
|
|
|
|
def setMtp(self, Mtp):
|
|
r"""setMtp(Tensor self, RealQuantity Mtp)"""
|
|
return _datamodel.Tensor_setMtp(self, Mtp)
|
|
|
|
def Mtp(self, *args):
|
|
r"""
|
|
Mtp(Tensor self) -> RealQuantity
|
|
Mtp(Tensor self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Tensor_Mtp(self, *args)
|
|
|
|
# Register Tensor in _datamodel:
|
|
_datamodel.Tensor_swigregister(Tensor)
|
|
|
|
def Tensor_ClassName():
|
|
r"""Tensor_ClassName() -> char const *"""
|
|
return _datamodel.Tensor_ClassName()
|
|
|
|
def Tensor_TypeInfo():
|
|
r"""Tensor_TypeInfo() -> RTTI"""
|
|
return _datamodel.Tensor_TypeInfo()
|
|
|
|
def Tensor_Cast(*args):
|
|
r"""
|
|
Tensor_Cast(BaseObject o) -> Tensor
|
|
Tensor_Cast(Seiscomp::Core::BaseObjectPtr o) -> Tensor
|
|
"""
|
|
return _datamodel.Tensor_Cast(*args)
|
|
|
|
def Tensor_ConstCast(*args):
|
|
r"""
|
|
Tensor_ConstCast(BaseObject o) -> Tensor
|
|
Tensor_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Tensor
|
|
"""
|
|
return _datamodel.Tensor_ConstCast(*args)
|
|
|
|
def Tensor_Meta():
|
|
r"""Tensor_Meta() -> MetaObject"""
|
|
return _datamodel.Tensor_Meta()
|
|
|
|
class OriginQuality(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::OriginQuality 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 _datamodel.OriginQuality_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.OriginQuality_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(OriginQuality self) -> char const *"""
|
|
return _datamodel.OriginQuality_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(OriginQuality self) -> RTTI"""
|
|
return _datamodel.OriginQuality_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> OriginQuality
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> OriginQuality
|
|
"""
|
|
return _datamodel.OriginQuality_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> OriginQuality
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> OriginQuality
|
|
"""
|
|
return _datamodel.OriginQuality_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(OriginQuality self, GenericArchive ar)"""
|
|
return _datamodel.OriginQuality_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.OriginQuality_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(OriginQuality self) -> MetaObject"""
|
|
return _datamodel.OriginQuality_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(OriginQuality self) -> OriginQuality
|
|
__init__(OriginQuality self, OriginQuality other) -> OriginQuality
|
|
"""
|
|
_datamodel.OriginQuality_swiginit(self, _datamodel.new_OriginQuality(*args))
|
|
__swig_destroy__ = _datamodel.delete_OriginQuality
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(OriginQuality self, OriginQuality other) -> bool"""
|
|
return _datamodel.OriginQuality___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(OriginQuality self, OriginQuality other) -> bool"""
|
|
return _datamodel.OriginQuality___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(OriginQuality self, OriginQuality other) -> bool"""
|
|
return _datamodel.OriginQuality_equal(self, other)
|
|
|
|
def setAssociatedPhaseCount(self, associatedPhaseCount):
|
|
r"""setAssociatedPhaseCount(OriginQuality self, Seiscomp::Core::Optional< int >::Impl const & associatedPhaseCount)"""
|
|
return _datamodel.OriginQuality_setAssociatedPhaseCount(self, associatedPhaseCount)
|
|
|
|
def associatedPhaseCount(self):
|
|
r"""associatedPhaseCount(OriginQuality self) -> int"""
|
|
return _datamodel.OriginQuality_associatedPhaseCount(self)
|
|
|
|
def setUsedPhaseCount(self, usedPhaseCount):
|
|
r"""setUsedPhaseCount(OriginQuality self, Seiscomp::Core::Optional< int >::Impl const & usedPhaseCount)"""
|
|
return _datamodel.OriginQuality_setUsedPhaseCount(self, usedPhaseCount)
|
|
|
|
def usedPhaseCount(self):
|
|
r"""usedPhaseCount(OriginQuality self) -> int"""
|
|
return _datamodel.OriginQuality_usedPhaseCount(self)
|
|
|
|
def setAssociatedStationCount(self, associatedStationCount):
|
|
r"""setAssociatedStationCount(OriginQuality self, Seiscomp::Core::Optional< int >::Impl const & associatedStationCount)"""
|
|
return _datamodel.OriginQuality_setAssociatedStationCount(self, associatedStationCount)
|
|
|
|
def associatedStationCount(self):
|
|
r"""associatedStationCount(OriginQuality self) -> int"""
|
|
return _datamodel.OriginQuality_associatedStationCount(self)
|
|
|
|
def setUsedStationCount(self, usedStationCount):
|
|
r"""setUsedStationCount(OriginQuality self, Seiscomp::Core::Optional< int >::Impl const & usedStationCount)"""
|
|
return _datamodel.OriginQuality_setUsedStationCount(self, usedStationCount)
|
|
|
|
def usedStationCount(self):
|
|
r"""usedStationCount(OriginQuality self) -> int"""
|
|
return _datamodel.OriginQuality_usedStationCount(self)
|
|
|
|
def setDepthPhaseCount(self, depthPhaseCount):
|
|
r"""setDepthPhaseCount(OriginQuality self, Seiscomp::Core::Optional< int >::Impl const & depthPhaseCount)"""
|
|
return _datamodel.OriginQuality_setDepthPhaseCount(self, depthPhaseCount)
|
|
|
|
def depthPhaseCount(self):
|
|
r"""depthPhaseCount(OriginQuality self) -> int"""
|
|
return _datamodel.OriginQuality_depthPhaseCount(self)
|
|
|
|
def setStandardError(self, standardError):
|
|
r"""setStandardError(OriginQuality self, Seiscomp::Core::Optional< double >::Impl const & standardError)"""
|
|
return _datamodel.OriginQuality_setStandardError(self, standardError)
|
|
|
|
def standardError(self):
|
|
r"""standardError(OriginQuality self) -> double"""
|
|
return _datamodel.OriginQuality_standardError(self)
|
|
|
|
def setAzimuthalGap(self, azimuthalGap):
|
|
r"""setAzimuthalGap(OriginQuality self, Seiscomp::Core::Optional< double >::Impl const & azimuthalGap)"""
|
|
return _datamodel.OriginQuality_setAzimuthalGap(self, azimuthalGap)
|
|
|
|
def azimuthalGap(self):
|
|
r"""azimuthalGap(OriginQuality self) -> double"""
|
|
return _datamodel.OriginQuality_azimuthalGap(self)
|
|
|
|
def setSecondaryAzimuthalGap(self, secondaryAzimuthalGap):
|
|
r"""setSecondaryAzimuthalGap(OriginQuality self, Seiscomp::Core::Optional< double >::Impl const & secondaryAzimuthalGap)"""
|
|
return _datamodel.OriginQuality_setSecondaryAzimuthalGap(self, secondaryAzimuthalGap)
|
|
|
|
def secondaryAzimuthalGap(self):
|
|
r"""secondaryAzimuthalGap(OriginQuality self) -> double"""
|
|
return _datamodel.OriginQuality_secondaryAzimuthalGap(self)
|
|
|
|
def setGroundTruthLevel(self, groundTruthLevel):
|
|
r"""setGroundTruthLevel(OriginQuality self, std::string const & groundTruthLevel)"""
|
|
return _datamodel.OriginQuality_setGroundTruthLevel(self, groundTruthLevel)
|
|
|
|
def groundTruthLevel(self):
|
|
r"""groundTruthLevel(OriginQuality self) -> std::string const &"""
|
|
return _datamodel.OriginQuality_groundTruthLevel(self)
|
|
|
|
def setMaximumDistance(self, maximumDistance):
|
|
r"""setMaximumDistance(OriginQuality self, Seiscomp::Core::Optional< double >::Impl const & maximumDistance)"""
|
|
return _datamodel.OriginQuality_setMaximumDistance(self, maximumDistance)
|
|
|
|
def maximumDistance(self):
|
|
r"""maximumDistance(OriginQuality self) -> double"""
|
|
return _datamodel.OriginQuality_maximumDistance(self)
|
|
|
|
def setMinimumDistance(self, minimumDistance):
|
|
r"""setMinimumDistance(OriginQuality self, Seiscomp::Core::Optional< double >::Impl const & minimumDistance)"""
|
|
return _datamodel.OriginQuality_setMinimumDistance(self, minimumDistance)
|
|
|
|
def minimumDistance(self):
|
|
r"""minimumDistance(OriginQuality self) -> double"""
|
|
return _datamodel.OriginQuality_minimumDistance(self)
|
|
|
|
def setMedianDistance(self, medianDistance):
|
|
r"""setMedianDistance(OriginQuality self, Seiscomp::Core::Optional< double >::Impl const & medianDistance)"""
|
|
return _datamodel.OriginQuality_setMedianDistance(self, medianDistance)
|
|
|
|
def medianDistance(self):
|
|
r"""medianDistance(OriginQuality self) -> double"""
|
|
return _datamodel.OriginQuality_medianDistance(self)
|
|
|
|
# Register OriginQuality in _datamodel:
|
|
_datamodel.OriginQuality_swigregister(OriginQuality)
|
|
|
|
def OriginQuality_ClassName():
|
|
r"""OriginQuality_ClassName() -> char const *"""
|
|
return _datamodel.OriginQuality_ClassName()
|
|
|
|
def OriginQuality_TypeInfo():
|
|
r"""OriginQuality_TypeInfo() -> RTTI"""
|
|
return _datamodel.OriginQuality_TypeInfo()
|
|
|
|
def OriginQuality_Cast(*args):
|
|
r"""
|
|
OriginQuality_Cast(BaseObject o) -> OriginQuality
|
|
OriginQuality_Cast(Seiscomp::Core::BaseObjectPtr o) -> OriginQuality
|
|
"""
|
|
return _datamodel.OriginQuality_Cast(*args)
|
|
|
|
def OriginQuality_ConstCast(*args):
|
|
r"""
|
|
OriginQuality_ConstCast(BaseObject o) -> OriginQuality
|
|
OriginQuality_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> OriginQuality
|
|
"""
|
|
return _datamodel.OriginQuality_ConstCast(*args)
|
|
|
|
def OriginQuality_Meta():
|
|
r"""OriginQuality_Meta() -> MetaObject"""
|
|
return _datamodel.OriginQuality_Meta()
|
|
|
|
class NodalPlane(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::NodalPlane 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 _datamodel.NodalPlane_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.NodalPlane_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(NodalPlane self) -> char const *"""
|
|
return _datamodel.NodalPlane_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(NodalPlane self) -> RTTI"""
|
|
return _datamodel.NodalPlane_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> NodalPlane
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> NodalPlane
|
|
"""
|
|
return _datamodel.NodalPlane_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> NodalPlane
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> NodalPlane
|
|
"""
|
|
return _datamodel.NodalPlane_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(NodalPlane self, GenericArchive ar)"""
|
|
return _datamodel.NodalPlane_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.NodalPlane_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(NodalPlane self) -> MetaObject"""
|
|
return _datamodel.NodalPlane_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(NodalPlane self) -> NodalPlane
|
|
__init__(NodalPlane self, NodalPlane other) -> NodalPlane
|
|
"""
|
|
_datamodel.NodalPlane_swiginit(self, _datamodel.new_NodalPlane(*args))
|
|
__swig_destroy__ = _datamodel.delete_NodalPlane
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(NodalPlane self, NodalPlane other) -> bool"""
|
|
return _datamodel.NodalPlane___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(NodalPlane self, NodalPlane other) -> bool"""
|
|
return _datamodel.NodalPlane___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(NodalPlane self, NodalPlane other) -> bool"""
|
|
return _datamodel.NodalPlane_equal(self, other)
|
|
|
|
def setStrike(self, strike):
|
|
r"""setStrike(NodalPlane self, RealQuantity strike)"""
|
|
return _datamodel.NodalPlane_setStrike(self, strike)
|
|
|
|
def strike(self, *args):
|
|
r"""
|
|
strike(NodalPlane self) -> RealQuantity
|
|
strike(NodalPlane self) -> RealQuantity
|
|
"""
|
|
return _datamodel.NodalPlane_strike(self, *args)
|
|
|
|
def setDip(self, dip):
|
|
r"""setDip(NodalPlane self, RealQuantity dip)"""
|
|
return _datamodel.NodalPlane_setDip(self, dip)
|
|
|
|
def dip(self, *args):
|
|
r"""
|
|
dip(NodalPlane self) -> RealQuantity
|
|
dip(NodalPlane self) -> RealQuantity
|
|
"""
|
|
return _datamodel.NodalPlane_dip(self, *args)
|
|
|
|
def setRake(self, rake):
|
|
r"""setRake(NodalPlane self, RealQuantity rake)"""
|
|
return _datamodel.NodalPlane_setRake(self, rake)
|
|
|
|
def rake(self, *args):
|
|
r"""
|
|
rake(NodalPlane self) -> RealQuantity
|
|
rake(NodalPlane self) -> RealQuantity
|
|
"""
|
|
return _datamodel.NodalPlane_rake(self, *args)
|
|
|
|
# Register NodalPlane in _datamodel:
|
|
_datamodel.NodalPlane_swigregister(NodalPlane)
|
|
|
|
def NodalPlane_ClassName():
|
|
r"""NodalPlane_ClassName() -> char const *"""
|
|
return _datamodel.NodalPlane_ClassName()
|
|
|
|
def NodalPlane_TypeInfo():
|
|
r"""NodalPlane_TypeInfo() -> RTTI"""
|
|
return _datamodel.NodalPlane_TypeInfo()
|
|
|
|
def NodalPlane_Cast(*args):
|
|
r"""
|
|
NodalPlane_Cast(BaseObject o) -> NodalPlane
|
|
NodalPlane_Cast(Seiscomp::Core::BaseObjectPtr o) -> NodalPlane
|
|
"""
|
|
return _datamodel.NodalPlane_Cast(*args)
|
|
|
|
def NodalPlane_ConstCast(*args):
|
|
r"""
|
|
NodalPlane_ConstCast(BaseObject o) -> NodalPlane
|
|
NodalPlane_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> NodalPlane
|
|
"""
|
|
return _datamodel.NodalPlane_ConstCast(*args)
|
|
|
|
def NodalPlane_Meta():
|
|
r"""NodalPlane_Meta() -> MetaObject"""
|
|
return _datamodel.NodalPlane_Meta()
|
|
|
|
class TimeWindow(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::TimeWindow 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 _datamodel.TimeWindow_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.TimeWindow_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(TimeWindow self) -> char const *"""
|
|
return _datamodel.TimeWindow_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(TimeWindow self) -> RTTI"""
|
|
return _datamodel.TimeWindow_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> TimeWindow
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> TimeWindow
|
|
"""
|
|
return _datamodel.TimeWindow_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> TimeWindow
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimeWindow
|
|
"""
|
|
return _datamodel.TimeWindow_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(TimeWindow self, GenericArchive ar)"""
|
|
return _datamodel.TimeWindow_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.TimeWindow_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(TimeWindow self) -> MetaObject"""
|
|
return _datamodel.TimeWindow_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(TimeWindow self) -> TimeWindow
|
|
__init__(TimeWindow self, TimeWindow other) -> TimeWindow
|
|
__init__(TimeWindow self, Time reference) -> TimeWindow
|
|
__init__(TimeWindow self, Time reference, double begin, double end) -> TimeWindow
|
|
"""
|
|
_datamodel.TimeWindow_swiginit(self, _datamodel.new_TimeWindow(*args))
|
|
__swig_destroy__ = _datamodel.delete_TimeWindow
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(TimeWindow self, TimeWindow other) -> bool"""
|
|
return _datamodel.TimeWindow___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(TimeWindow self, TimeWindow other) -> bool"""
|
|
return _datamodel.TimeWindow___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(TimeWindow self, TimeWindow other) -> bool"""
|
|
return _datamodel.TimeWindow_equal(self, other)
|
|
|
|
def setReference(self, reference):
|
|
r"""setReference(TimeWindow self, Time reference)"""
|
|
return _datamodel.TimeWindow_setReference(self, reference)
|
|
|
|
def reference(self):
|
|
r"""reference(TimeWindow self) -> Time"""
|
|
return _datamodel.TimeWindow_reference(self)
|
|
|
|
def setBegin(self, begin):
|
|
r"""setBegin(TimeWindow self, double begin)"""
|
|
return _datamodel.TimeWindow_setBegin(self, begin)
|
|
|
|
def begin(self):
|
|
r"""begin(TimeWindow self) -> double"""
|
|
return _datamodel.TimeWindow_begin(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(TimeWindow self, double end)"""
|
|
return _datamodel.TimeWindow_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(TimeWindow self) -> double"""
|
|
return _datamodel.TimeWindow_end(self)
|
|
|
|
# Register TimeWindow in _datamodel:
|
|
_datamodel.TimeWindow_swigregister(TimeWindow)
|
|
|
|
def TimeWindow_ClassName():
|
|
r"""TimeWindow_ClassName() -> char const *"""
|
|
return _datamodel.TimeWindow_ClassName()
|
|
|
|
def TimeWindow_TypeInfo():
|
|
r"""TimeWindow_TypeInfo() -> RTTI"""
|
|
return _datamodel.TimeWindow_TypeInfo()
|
|
|
|
def TimeWindow_Cast(*args):
|
|
r"""
|
|
TimeWindow_Cast(BaseObject o) -> TimeWindow
|
|
TimeWindow_Cast(Seiscomp::Core::BaseObjectPtr o) -> TimeWindow
|
|
"""
|
|
return _datamodel.TimeWindow_Cast(*args)
|
|
|
|
def TimeWindow_ConstCast(*args):
|
|
r"""
|
|
TimeWindow_ConstCast(BaseObject o) -> TimeWindow
|
|
TimeWindow_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> TimeWindow
|
|
"""
|
|
return _datamodel.TimeWindow_ConstCast(*args)
|
|
|
|
def TimeWindow_Meta():
|
|
r"""TimeWindow_Meta() -> MetaObject"""
|
|
return _datamodel.TimeWindow_Meta()
|
|
|
|
class WaveformStreamID(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::WaveformStreamID 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 _datamodel.WaveformStreamID_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.WaveformStreamID_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(WaveformStreamID self) -> char const *"""
|
|
return _datamodel.WaveformStreamID_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(WaveformStreamID self) -> RTTI"""
|
|
return _datamodel.WaveformStreamID_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> WaveformStreamID
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> WaveformStreamID
|
|
"""
|
|
return _datamodel.WaveformStreamID_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> WaveformStreamID
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> WaveformStreamID
|
|
"""
|
|
return _datamodel.WaveformStreamID_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(WaveformStreamID self, GenericArchive ar)"""
|
|
return _datamodel.WaveformStreamID_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.WaveformStreamID_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(WaveformStreamID self) -> MetaObject"""
|
|
return _datamodel.WaveformStreamID_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(WaveformStreamID self) -> WaveformStreamID
|
|
__init__(WaveformStreamID self, WaveformStreamID other) -> WaveformStreamID
|
|
__init__(WaveformStreamID self, std::string const & resourceURI) -> WaveformStreamID
|
|
__init__(WaveformStreamID self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode, std::string const & resourceURI) -> WaveformStreamID
|
|
"""
|
|
_datamodel.WaveformStreamID_swiginit(self, _datamodel.new_WaveformStreamID(*args))
|
|
__swig_destroy__ = _datamodel.delete_WaveformStreamID
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(WaveformStreamID self, WaveformStreamID other) -> bool"""
|
|
return _datamodel.WaveformStreamID___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(WaveformStreamID self, WaveformStreamID other) -> bool"""
|
|
return _datamodel.WaveformStreamID___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(WaveformStreamID self, WaveformStreamID other) -> bool"""
|
|
return _datamodel.WaveformStreamID_equal(self, other)
|
|
|
|
def setNetworkCode(self, networkCode):
|
|
r"""setNetworkCode(WaveformStreamID self, std::string const & networkCode)"""
|
|
return _datamodel.WaveformStreamID_setNetworkCode(self, networkCode)
|
|
|
|
def networkCode(self):
|
|
r"""networkCode(WaveformStreamID self) -> std::string const &"""
|
|
return _datamodel.WaveformStreamID_networkCode(self)
|
|
|
|
def setStationCode(self, stationCode):
|
|
r"""setStationCode(WaveformStreamID self, std::string const & stationCode)"""
|
|
return _datamodel.WaveformStreamID_setStationCode(self, stationCode)
|
|
|
|
def stationCode(self):
|
|
r"""stationCode(WaveformStreamID self) -> std::string const &"""
|
|
return _datamodel.WaveformStreamID_stationCode(self)
|
|
|
|
def setLocationCode(self, locationCode):
|
|
r"""setLocationCode(WaveformStreamID self, std::string const & locationCode)"""
|
|
return _datamodel.WaveformStreamID_setLocationCode(self, locationCode)
|
|
|
|
def locationCode(self):
|
|
r"""locationCode(WaveformStreamID self) -> std::string const &"""
|
|
return _datamodel.WaveformStreamID_locationCode(self)
|
|
|
|
def setChannelCode(self, channelCode):
|
|
r"""setChannelCode(WaveformStreamID self, std::string const & channelCode)"""
|
|
return _datamodel.WaveformStreamID_setChannelCode(self, channelCode)
|
|
|
|
def channelCode(self):
|
|
r"""channelCode(WaveformStreamID self) -> std::string const &"""
|
|
return _datamodel.WaveformStreamID_channelCode(self)
|
|
|
|
def setResourceURI(self, resourceURI):
|
|
r"""setResourceURI(WaveformStreamID self, std::string const & resourceURI)"""
|
|
return _datamodel.WaveformStreamID_setResourceURI(self, resourceURI)
|
|
|
|
def resourceURI(self):
|
|
r"""resourceURI(WaveformStreamID self) -> std::string const &"""
|
|
return _datamodel.WaveformStreamID_resourceURI(self)
|
|
|
|
# Register WaveformStreamID in _datamodel:
|
|
_datamodel.WaveformStreamID_swigregister(WaveformStreamID)
|
|
|
|
def WaveformStreamID_ClassName():
|
|
r"""WaveformStreamID_ClassName() -> char const *"""
|
|
return _datamodel.WaveformStreamID_ClassName()
|
|
|
|
def WaveformStreamID_TypeInfo():
|
|
r"""WaveformStreamID_TypeInfo() -> RTTI"""
|
|
return _datamodel.WaveformStreamID_TypeInfo()
|
|
|
|
def WaveformStreamID_Cast(*args):
|
|
r"""
|
|
WaveformStreamID_Cast(BaseObject o) -> WaveformStreamID
|
|
WaveformStreamID_Cast(Seiscomp::Core::BaseObjectPtr o) -> WaveformStreamID
|
|
"""
|
|
return _datamodel.WaveformStreamID_Cast(*args)
|
|
|
|
def WaveformStreamID_ConstCast(*args):
|
|
r"""
|
|
WaveformStreamID_ConstCast(BaseObject o) -> WaveformStreamID
|
|
WaveformStreamID_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> WaveformStreamID
|
|
"""
|
|
return _datamodel.WaveformStreamID_ConstCast(*args)
|
|
|
|
def WaveformStreamID_Meta():
|
|
r"""WaveformStreamID_Meta() -> MetaObject"""
|
|
return _datamodel.WaveformStreamID_Meta()
|
|
|
|
class SourceTimeFunction(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::SourceTimeFunction 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 _datamodel.SourceTimeFunction_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.SourceTimeFunction_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(SourceTimeFunction self) -> char const *"""
|
|
return _datamodel.SourceTimeFunction_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(SourceTimeFunction self) -> RTTI"""
|
|
return _datamodel.SourceTimeFunction_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> SourceTimeFunction
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> SourceTimeFunction
|
|
"""
|
|
return _datamodel.SourceTimeFunction_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> SourceTimeFunction
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SourceTimeFunction
|
|
"""
|
|
return _datamodel.SourceTimeFunction_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(SourceTimeFunction self, GenericArchive ar)"""
|
|
return _datamodel.SourceTimeFunction_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.SourceTimeFunction_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(SourceTimeFunction self) -> MetaObject"""
|
|
return _datamodel.SourceTimeFunction_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(SourceTimeFunction self) -> SourceTimeFunction
|
|
__init__(SourceTimeFunction self, SourceTimeFunction other) -> SourceTimeFunction
|
|
"""
|
|
_datamodel.SourceTimeFunction_swiginit(self, _datamodel.new_SourceTimeFunction(*args))
|
|
__swig_destroy__ = _datamodel.delete_SourceTimeFunction
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(SourceTimeFunction self, SourceTimeFunction other) -> bool"""
|
|
return _datamodel.SourceTimeFunction___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(SourceTimeFunction self, SourceTimeFunction other) -> bool"""
|
|
return _datamodel.SourceTimeFunction___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(SourceTimeFunction self, SourceTimeFunction other) -> bool"""
|
|
return _datamodel.SourceTimeFunction_equal(self, other)
|
|
|
|
def setType(self, type):
|
|
r"""setType(SourceTimeFunction self, Seiscomp::DataModel::SourceTimeFunctionType type)"""
|
|
return _datamodel.SourceTimeFunction_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(SourceTimeFunction self) -> Seiscomp::DataModel::SourceTimeFunctionType"""
|
|
return _datamodel.SourceTimeFunction_type(self)
|
|
|
|
def setDuration(self, duration):
|
|
r"""setDuration(SourceTimeFunction self, double duration)"""
|
|
return _datamodel.SourceTimeFunction_setDuration(self, duration)
|
|
|
|
def duration(self):
|
|
r"""duration(SourceTimeFunction self) -> double"""
|
|
return _datamodel.SourceTimeFunction_duration(self)
|
|
|
|
def setRiseTime(self, riseTime):
|
|
r"""setRiseTime(SourceTimeFunction self, Seiscomp::Core::Optional< double >::Impl const & riseTime)"""
|
|
return _datamodel.SourceTimeFunction_setRiseTime(self, riseTime)
|
|
|
|
def riseTime(self):
|
|
r"""riseTime(SourceTimeFunction self) -> double"""
|
|
return _datamodel.SourceTimeFunction_riseTime(self)
|
|
|
|
def setDecayTime(self, decayTime):
|
|
r"""setDecayTime(SourceTimeFunction self, Seiscomp::Core::Optional< double >::Impl const & decayTime)"""
|
|
return _datamodel.SourceTimeFunction_setDecayTime(self, decayTime)
|
|
|
|
def decayTime(self):
|
|
r"""decayTime(SourceTimeFunction self) -> double"""
|
|
return _datamodel.SourceTimeFunction_decayTime(self)
|
|
|
|
# Register SourceTimeFunction in _datamodel:
|
|
_datamodel.SourceTimeFunction_swigregister(SourceTimeFunction)
|
|
|
|
def SourceTimeFunction_ClassName():
|
|
r"""SourceTimeFunction_ClassName() -> char const *"""
|
|
return _datamodel.SourceTimeFunction_ClassName()
|
|
|
|
def SourceTimeFunction_TypeInfo():
|
|
r"""SourceTimeFunction_TypeInfo() -> RTTI"""
|
|
return _datamodel.SourceTimeFunction_TypeInfo()
|
|
|
|
def SourceTimeFunction_Cast(*args):
|
|
r"""
|
|
SourceTimeFunction_Cast(BaseObject o) -> SourceTimeFunction
|
|
SourceTimeFunction_Cast(Seiscomp::Core::BaseObjectPtr o) -> SourceTimeFunction
|
|
"""
|
|
return _datamodel.SourceTimeFunction_Cast(*args)
|
|
|
|
def SourceTimeFunction_ConstCast(*args):
|
|
r"""
|
|
SourceTimeFunction_ConstCast(BaseObject o) -> SourceTimeFunction
|
|
SourceTimeFunction_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SourceTimeFunction
|
|
"""
|
|
return _datamodel.SourceTimeFunction_ConstCast(*args)
|
|
|
|
def SourceTimeFunction_Meta():
|
|
r"""SourceTimeFunction_Meta() -> MetaObject"""
|
|
return _datamodel.SourceTimeFunction_Meta()
|
|
|
|
class NodalPlanes(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::NodalPlanes 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 _datamodel.NodalPlanes_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.NodalPlanes_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(NodalPlanes self) -> char const *"""
|
|
return _datamodel.NodalPlanes_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(NodalPlanes self) -> RTTI"""
|
|
return _datamodel.NodalPlanes_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> NodalPlanes
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> NodalPlanes
|
|
"""
|
|
return _datamodel.NodalPlanes_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> NodalPlanes
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> NodalPlanes
|
|
"""
|
|
return _datamodel.NodalPlanes_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(NodalPlanes self, GenericArchive ar)"""
|
|
return _datamodel.NodalPlanes_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.NodalPlanes_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(NodalPlanes self) -> MetaObject"""
|
|
return _datamodel.NodalPlanes_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(NodalPlanes self) -> NodalPlanes
|
|
__init__(NodalPlanes self, NodalPlanes other) -> NodalPlanes
|
|
"""
|
|
_datamodel.NodalPlanes_swiginit(self, _datamodel.new_NodalPlanes(*args))
|
|
__swig_destroy__ = _datamodel.delete_NodalPlanes
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(NodalPlanes self, NodalPlanes other) -> bool"""
|
|
return _datamodel.NodalPlanes___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(NodalPlanes self, NodalPlanes other) -> bool"""
|
|
return _datamodel.NodalPlanes___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(NodalPlanes self, NodalPlanes other) -> bool"""
|
|
return _datamodel.NodalPlanes_equal(self, other)
|
|
|
|
def setNodalPlane1(self, nodalPlane1):
|
|
r"""setNodalPlane1(NodalPlanes self, Seiscomp::Core::Optional< Seiscomp::DataModel::NodalPlane >::Impl const & nodalPlane1)"""
|
|
return _datamodel.NodalPlanes_setNodalPlane1(self, nodalPlane1)
|
|
|
|
def nodalPlane1(self, *args):
|
|
r"""
|
|
nodalPlane1(NodalPlanes self) -> NodalPlane
|
|
nodalPlane1(NodalPlanes self) -> NodalPlane
|
|
"""
|
|
return _datamodel.NodalPlanes_nodalPlane1(self, *args)
|
|
|
|
def setNodalPlane2(self, nodalPlane2):
|
|
r"""setNodalPlane2(NodalPlanes self, Seiscomp::Core::Optional< Seiscomp::DataModel::NodalPlane >::Impl const & nodalPlane2)"""
|
|
return _datamodel.NodalPlanes_setNodalPlane2(self, nodalPlane2)
|
|
|
|
def nodalPlane2(self, *args):
|
|
r"""
|
|
nodalPlane2(NodalPlanes self) -> NodalPlane
|
|
nodalPlane2(NodalPlanes self) -> NodalPlane
|
|
"""
|
|
return _datamodel.NodalPlanes_nodalPlane2(self, *args)
|
|
|
|
def setPreferredPlane(self, preferredPlane):
|
|
r"""setPreferredPlane(NodalPlanes self, Seiscomp::Core::Optional< int >::Impl const & preferredPlane)"""
|
|
return _datamodel.NodalPlanes_setPreferredPlane(self, preferredPlane)
|
|
|
|
def preferredPlane(self):
|
|
r"""preferredPlane(NodalPlanes self) -> int"""
|
|
return _datamodel.NodalPlanes_preferredPlane(self)
|
|
|
|
# Register NodalPlanes in _datamodel:
|
|
_datamodel.NodalPlanes_swigregister(NodalPlanes)
|
|
|
|
def NodalPlanes_ClassName():
|
|
r"""NodalPlanes_ClassName() -> char const *"""
|
|
return _datamodel.NodalPlanes_ClassName()
|
|
|
|
def NodalPlanes_TypeInfo():
|
|
r"""NodalPlanes_TypeInfo() -> RTTI"""
|
|
return _datamodel.NodalPlanes_TypeInfo()
|
|
|
|
def NodalPlanes_Cast(*args):
|
|
r"""
|
|
NodalPlanes_Cast(BaseObject o) -> NodalPlanes
|
|
NodalPlanes_Cast(Seiscomp::Core::BaseObjectPtr o) -> NodalPlanes
|
|
"""
|
|
return _datamodel.NodalPlanes_Cast(*args)
|
|
|
|
def NodalPlanes_ConstCast(*args):
|
|
r"""
|
|
NodalPlanes_ConstCast(BaseObject o) -> NodalPlanes
|
|
NodalPlanes_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> NodalPlanes
|
|
"""
|
|
return _datamodel.NodalPlanes_ConstCast(*args)
|
|
|
|
def NodalPlanes_Meta():
|
|
r"""NodalPlanes_Meta() -> MetaObject"""
|
|
return _datamodel.NodalPlanes_Meta()
|
|
|
|
class ConfidenceEllipsoid(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ConfidenceEllipsoid 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 _datamodel.ConfidenceEllipsoid_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ConfidenceEllipsoid_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ConfidenceEllipsoid self) -> char const *"""
|
|
return _datamodel.ConfidenceEllipsoid_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ConfidenceEllipsoid self) -> RTTI"""
|
|
return _datamodel.ConfidenceEllipsoid_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ConfidenceEllipsoid
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfidenceEllipsoid
|
|
"""
|
|
return _datamodel.ConfidenceEllipsoid_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ConfidenceEllipsoid
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfidenceEllipsoid
|
|
"""
|
|
return _datamodel.ConfidenceEllipsoid_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ConfidenceEllipsoid self, GenericArchive ar)"""
|
|
return _datamodel.ConfidenceEllipsoid_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ConfidenceEllipsoid_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ConfidenceEllipsoid self) -> MetaObject"""
|
|
return _datamodel.ConfidenceEllipsoid_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ConfidenceEllipsoid self) -> ConfidenceEllipsoid
|
|
__init__(ConfidenceEllipsoid self, ConfidenceEllipsoid other) -> ConfidenceEllipsoid
|
|
"""
|
|
_datamodel.ConfidenceEllipsoid_swiginit(self, _datamodel.new_ConfidenceEllipsoid(*args))
|
|
__swig_destroy__ = _datamodel.delete_ConfidenceEllipsoid
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ConfidenceEllipsoid self, ConfidenceEllipsoid other) -> bool"""
|
|
return _datamodel.ConfidenceEllipsoid___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ConfidenceEllipsoid self, ConfidenceEllipsoid other) -> bool"""
|
|
return _datamodel.ConfidenceEllipsoid___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ConfidenceEllipsoid self, ConfidenceEllipsoid other) -> bool"""
|
|
return _datamodel.ConfidenceEllipsoid_equal(self, other)
|
|
|
|
def setSemiMajorAxisLength(self, semiMajorAxisLength):
|
|
r"""setSemiMajorAxisLength(ConfidenceEllipsoid self, double semiMajorAxisLength)"""
|
|
return _datamodel.ConfidenceEllipsoid_setSemiMajorAxisLength(self, semiMajorAxisLength)
|
|
|
|
def semiMajorAxisLength(self):
|
|
r"""semiMajorAxisLength(ConfidenceEllipsoid self) -> double"""
|
|
return _datamodel.ConfidenceEllipsoid_semiMajorAxisLength(self)
|
|
|
|
def setSemiMinorAxisLength(self, semiMinorAxisLength):
|
|
r"""setSemiMinorAxisLength(ConfidenceEllipsoid self, double semiMinorAxisLength)"""
|
|
return _datamodel.ConfidenceEllipsoid_setSemiMinorAxisLength(self, semiMinorAxisLength)
|
|
|
|
def semiMinorAxisLength(self):
|
|
r"""semiMinorAxisLength(ConfidenceEllipsoid self) -> double"""
|
|
return _datamodel.ConfidenceEllipsoid_semiMinorAxisLength(self)
|
|
|
|
def setSemiIntermediateAxisLength(self, semiIntermediateAxisLength):
|
|
r"""setSemiIntermediateAxisLength(ConfidenceEllipsoid self, double semiIntermediateAxisLength)"""
|
|
return _datamodel.ConfidenceEllipsoid_setSemiIntermediateAxisLength(self, semiIntermediateAxisLength)
|
|
|
|
def semiIntermediateAxisLength(self):
|
|
r"""semiIntermediateAxisLength(ConfidenceEllipsoid self) -> double"""
|
|
return _datamodel.ConfidenceEllipsoid_semiIntermediateAxisLength(self)
|
|
|
|
def setMajorAxisPlunge(self, majorAxisPlunge):
|
|
r"""setMajorAxisPlunge(ConfidenceEllipsoid self, double majorAxisPlunge)"""
|
|
return _datamodel.ConfidenceEllipsoid_setMajorAxisPlunge(self, majorAxisPlunge)
|
|
|
|
def majorAxisPlunge(self):
|
|
r"""majorAxisPlunge(ConfidenceEllipsoid self) -> double"""
|
|
return _datamodel.ConfidenceEllipsoid_majorAxisPlunge(self)
|
|
|
|
def setMajorAxisAzimuth(self, majorAxisAzimuth):
|
|
r"""setMajorAxisAzimuth(ConfidenceEllipsoid self, double majorAxisAzimuth)"""
|
|
return _datamodel.ConfidenceEllipsoid_setMajorAxisAzimuth(self, majorAxisAzimuth)
|
|
|
|
def majorAxisAzimuth(self):
|
|
r"""majorAxisAzimuth(ConfidenceEllipsoid self) -> double"""
|
|
return _datamodel.ConfidenceEllipsoid_majorAxisAzimuth(self)
|
|
|
|
def setMajorAxisRotation(self, majorAxisRotation):
|
|
r"""setMajorAxisRotation(ConfidenceEllipsoid self, double majorAxisRotation)"""
|
|
return _datamodel.ConfidenceEllipsoid_setMajorAxisRotation(self, majorAxisRotation)
|
|
|
|
def majorAxisRotation(self):
|
|
r"""majorAxisRotation(ConfidenceEllipsoid self) -> double"""
|
|
return _datamodel.ConfidenceEllipsoid_majorAxisRotation(self)
|
|
|
|
# Register ConfidenceEllipsoid in _datamodel:
|
|
_datamodel.ConfidenceEllipsoid_swigregister(ConfidenceEllipsoid)
|
|
|
|
def ConfidenceEllipsoid_ClassName():
|
|
r"""ConfidenceEllipsoid_ClassName() -> char const *"""
|
|
return _datamodel.ConfidenceEllipsoid_ClassName()
|
|
|
|
def ConfidenceEllipsoid_TypeInfo():
|
|
r"""ConfidenceEllipsoid_TypeInfo() -> RTTI"""
|
|
return _datamodel.ConfidenceEllipsoid_TypeInfo()
|
|
|
|
def ConfidenceEllipsoid_Cast(*args):
|
|
r"""
|
|
ConfidenceEllipsoid_Cast(BaseObject o) -> ConfidenceEllipsoid
|
|
ConfidenceEllipsoid_Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfidenceEllipsoid
|
|
"""
|
|
return _datamodel.ConfidenceEllipsoid_Cast(*args)
|
|
|
|
def ConfidenceEllipsoid_ConstCast(*args):
|
|
r"""
|
|
ConfidenceEllipsoid_ConstCast(BaseObject o) -> ConfidenceEllipsoid
|
|
ConfidenceEllipsoid_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfidenceEllipsoid
|
|
"""
|
|
return _datamodel.ConfidenceEllipsoid_ConstCast(*args)
|
|
|
|
def ConfidenceEllipsoid_Meta():
|
|
r"""ConfidenceEllipsoid_Meta() -> MetaObject"""
|
|
return _datamodel.ConfidenceEllipsoid_Meta()
|
|
|
|
class OriginUncertainty(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::OriginUncertainty 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 _datamodel.OriginUncertainty_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.OriginUncertainty_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(OriginUncertainty self) -> char const *"""
|
|
return _datamodel.OriginUncertainty_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(OriginUncertainty self) -> RTTI"""
|
|
return _datamodel.OriginUncertainty_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> OriginUncertainty
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> OriginUncertainty
|
|
"""
|
|
return _datamodel.OriginUncertainty_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> OriginUncertainty
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> OriginUncertainty
|
|
"""
|
|
return _datamodel.OriginUncertainty_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(OriginUncertainty self, GenericArchive ar)"""
|
|
return _datamodel.OriginUncertainty_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.OriginUncertainty_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(OriginUncertainty self) -> MetaObject"""
|
|
return _datamodel.OriginUncertainty_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(OriginUncertainty self) -> OriginUncertainty
|
|
__init__(OriginUncertainty self, OriginUncertainty other) -> OriginUncertainty
|
|
"""
|
|
_datamodel.OriginUncertainty_swiginit(self, _datamodel.new_OriginUncertainty(*args))
|
|
__swig_destroy__ = _datamodel.delete_OriginUncertainty
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(OriginUncertainty self, OriginUncertainty other) -> bool"""
|
|
return _datamodel.OriginUncertainty___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(OriginUncertainty self, OriginUncertainty other) -> bool"""
|
|
return _datamodel.OriginUncertainty___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(OriginUncertainty self, OriginUncertainty other) -> bool"""
|
|
return _datamodel.OriginUncertainty_equal(self, other)
|
|
|
|
def setHorizontalUncertainty(self, horizontalUncertainty):
|
|
r"""setHorizontalUncertainty(OriginUncertainty self, Seiscomp::Core::Optional< double >::Impl const & horizontalUncertainty)"""
|
|
return _datamodel.OriginUncertainty_setHorizontalUncertainty(self, horizontalUncertainty)
|
|
|
|
def horizontalUncertainty(self):
|
|
r"""horizontalUncertainty(OriginUncertainty self) -> double"""
|
|
return _datamodel.OriginUncertainty_horizontalUncertainty(self)
|
|
|
|
def setMinHorizontalUncertainty(self, minHorizontalUncertainty):
|
|
r"""setMinHorizontalUncertainty(OriginUncertainty self, Seiscomp::Core::Optional< double >::Impl const & minHorizontalUncertainty)"""
|
|
return _datamodel.OriginUncertainty_setMinHorizontalUncertainty(self, minHorizontalUncertainty)
|
|
|
|
def minHorizontalUncertainty(self):
|
|
r"""minHorizontalUncertainty(OriginUncertainty self) -> double"""
|
|
return _datamodel.OriginUncertainty_minHorizontalUncertainty(self)
|
|
|
|
def setMaxHorizontalUncertainty(self, maxHorizontalUncertainty):
|
|
r"""setMaxHorizontalUncertainty(OriginUncertainty self, Seiscomp::Core::Optional< double >::Impl const & maxHorizontalUncertainty)"""
|
|
return _datamodel.OriginUncertainty_setMaxHorizontalUncertainty(self, maxHorizontalUncertainty)
|
|
|
|
def maxHorizontalUncertainty(self):
|
|
r"""maxHorizontalUncertainty(OriginUncertainty self) -> double"""
|
|
return _datamodel.OriginUncertainty_maxHorizontalUncertainty(self)
|
|
|
|
def setAzimuthMaxHorizontalUncertainty(self, azimuthMaxHorizontalUncertainty):
|
|
r"""setAzimuthMaxHorizontalUncertainty(OriginUncertainty self, Seiscomp::Core::Optional< double >::Impl const & azimuthMaxHorizontalUncertainty)"""
|
|
return _datamodel.OriginUncertainty_setAzimuthMaxHorizontalUncertainty(self, azimuthMaxHorizontalUncertainty)
|
|
|
|
def azimuthMaxHorizontalUncertainty(self):
|
|
r"""azimuthMaxHorizontalUncertainty(OriginUncertainty self) -> double"""
|
|
return _datamodel.OriginUncertainty_azimuthMaxHorizontalUncertainty(self)
|
|
|
|
def setConfidenceEllipsoid(self, confidenceEllipsoid):
|
|
r"""setConfidenceEllipsoid(OriginUncertainty self, Seiscomp::Core::Optional< Seiscomp::DataModel::ConfidenceEllipsoid >::Impl const & confidenceEllipsoid)"""
|
|
return _datamodel.OriginUncertainty_setConfidenceEllipsoid(self, confidenceEllipsoid)
|
|
|
|
def confidenceEllipsoid(self, *args):
|
|
r"""
|
|
confidenceEllipsoid(OriginUncertainty self) -> ConfidenceEllipsoid
|
|
confidenceEllipsoid(OriginUncertainty self) -> ConfidenceEllipsoid
|
|
"""
|
|
return _datamodel.OriginUncertainty_confidenceEllipsoid(self, *args)
|
|
|
|
def setPreferredDescription(self, preferredDescription):
|
|
r"""setPreferredDescription(OriginUncertainty self, Seiscomp::Core::Optional< Seiscomp::DataModel::OriginUncertaintyDescription >::Impl const & preferredDescription)"""
|
|
return _datamodel.OriginUncertainty_setPreferredDescription(self, preferredDescription)
|
|
|
|
def preferredDescription(self):
|
|
r"""preferredDescription(OriginUncertainty self) -> Seiscomp::DataModel::OriginUncertaintyDescription"""
|
|
return _datamodel.OriginUncertainty_preferredDescription(self)
|
|
|
|
def setConfidenceLevel(self, confidenceLevel):
|
|
r"""setConfidenceLevel(OriginUncertainty self, Seiscomp::Core::Optional< double >::Impl const & confidenceLevel)"""
|
|
return _datamodel.OriginUncertainty_setConfidenceLevel(self, confidenceLevel)
|
|
|
|
def confidenceLevel(self):
|
|
r"""confidenceLevel(OriginUncertainty self) -> double"""
|
|
return _datamodel.OriginUncertainty_confidenceLevel(self)
|
|
|
|
# Register OriginUncertainty in _datamodel:
|
|
_datamodel.OriginUncertainty_swigregister(OriginUncertainty)
|
|
|
|
def OriginUncertainty_ClassName():
|
|
r"""OriginUncertainty_ClassName() -> char const *"""
|
|
return _datamodel.OriginUncertainty_ClassName()
|
|
|
|
def OriginUncertainty_TypeInfo():
|
|
r"""OriginUncertainty_TypeInfo() -> RTTI"""
|
|
return _datamodel.OriginUncertainty_TypeInfo()
|
|
|
|
def OriginUncertainty_Cast(*args):
|
|
r"""
|
|
OriginUncertainty_Cast(BaseObject o) -> OriginUncertainty
|
|
OriginUncertainty_Cast(Seiscomp::Core::BaseObjectPtr o) -> OriginUncertainty
|
|
"""
|
|
return _datamodel.OriginUncertainty_Cast(*args)
|
|
|
|
def OriginUncertainty_ConstCast(*args):
|
|
r"""
|
|
OriginUncertainty_ConstCast(BaseObject o) -> OriginUncertainty
|
|
OriginUncertainty_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> OriginUncertainty
|
|
"""
|
|
return _datamodel.OriginUncertainty_ConstCast(*args)
|
|
|
|
def OriginUncertainty_Meta():
|
|
r"""OriginUncertainty_Meta() -> MetaObject"""
|
|
return _datamodel.OriginUncertainty_Meta()
|
|
|
|
class Blob(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Blob 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 _datamodel.Blob_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Blob_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Blob self) -> char const *"""
|
|
return _datamodel.Blob_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Blob self) -> RTTI"""
|
|
return _datamodel.Blob_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Blob
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Blob
|
|
"""
|
|
return _datamodel.Blob_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Blob
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Blob
|
|
"""
|
|
return _datamodel.Blob_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Blob self, GenericArchive ar)"""
|
|
return _datamodel.Blob_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Blob_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Blob self) -> MetaObject"""
|
|
return _datamodel.Blob_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Blob self) -> Blob
|
|
__init__(Blob self, Blob other) -> Blob
|
|
"""
|
|
_datamodel.Blob_swiginit(self, _datamodel.new_Blob(*args))
|
|
__swig_destroy__ = _datamodel.delete_Blob
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Blob self, Blob other) -> bool"""
|
|
return _datamodel.Blob___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Blob self, Blob other) -> bool"""
|
|
return _datamodel.Blob___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Blob self, Blob other) -> bool"""
|
|
return _datamodel.Blob_equal(self, other)
|
|
|
|
def setContent(self, content):
|
|
r"""setContent(Blob self, std::string const & content)"""
|
|
return _datamodel.Blob_setContent(self, content)
|
|
|
|
def content(self):
|
|
r"""content(Blob self) -> std::string const &"""
|
|
return _datamodel.Blob_content(self)
|
|
|
|
# Register Blob in _datamodel:
|
|
_datamodel.Blob_swigregister(Blob)
|
|
|
|
def Blob_ClassName():
|
|
r"""Blob_ClassName() -> char const *"""
|
|
return _datamodel.Blob_ClassName()
|
|
|
|
def Blob_TypeInfo():
|
|
r"""Blob_TypeInfo() -> RTTI"""
|
|
return _datamodel.Blob_TypeInfo()
|
|
|
|
def Blob_Cast(*args):
|
|
r"""
|
|
Blob_Cast(BaseObject o) -> Blob
|
|
Blob_Cast(Seiscomp::Core::BaseObjectPtr o) -> Blob
|
|
"""
|
|
return _datamodel.Blob_Cast(*args)
|
|
|
|
def Blob_ConstCast(*args):
|
|
r"""
|
|
Blob_ConstCast(BaseObject o) -> Blob
|
|
Blob_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Blob
|
|
"""
|
|
return _datamodel.Blob_ConstCast(*args)
|
|
|
|
def Blob_Meta():
|
|
r"""Blob_Meta() -> MetaObject"""
|
|
return _datamodel.Blob_Meta()
|
|
|
|
class ArclinkRequestSummary(seiscomp.core.BaseObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ArclinkRequestSummary 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 _datamodel.ArclinkRequestSummary_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ArclinkRequestSummary_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ArclinkRequestSummary self) -> char const *"""
|
|
return _datamodel.ArclinkRequestSummary_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ArclinkRequestSummary self) -> RTTI"""
|
|
return _datamodel.ArclinkRequestSummary_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ArclinkRequestSummary
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkRequestSummary
|
|
"""
|
|
return _datamodel.ArclinkRequestSummary_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ArclinkRequestSummary
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkRequestSummary
|
|
"""
|
|
return _datamodel.ArclinkRequestSummary_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ArclinkRequestSummary self, GenericArchive ar)"""
|
|
return _datamodel.ArclinkRequestSummary_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ArclinkRequestSummary_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ArclinkRequestSummary self) -> MetaObject"""
|
|
return _datamodel.ArclinkRequestSummary_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ArclinkRequestSummary self) -> ArclinkRequestSummary
|
|
__init__(ArclinkRequestSummary self, ArclinkRequestSummary other) -> ArclinkRequestSummary
|
|
"""
|
|
_datamodel.ArclinkRequestSummary_swiginit(self, _datamodel.new_ArclinkRequestSummary(*args))
|
|
__swig_destroy__ = _datamodel.delete_ArclinkRequestSummary
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ArclinkRequestSummary self, ArclinkRequestSummary other) -> bool"""
|
|
return _datamodel.ArclinkRequestSummary___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ArclinkRequestSummary self, ArclinkRequestSummary other) -> bool"""
|
|
return _datamodel.ArclinkRequestSummary___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ArclinkRequestSummary self, ArclinkRequestSummary other) -> bool"""
|
|
return _datamodel.ArclinkRequestSummary_equal(self, other)
|
|
|
|
def setOkLineCount(self, okLineCount):
|
|
r"""setOkLineCount(ArclinkRequestSummary self, int okLineCount)"""
|
|
return _datamodel.ArclinkRequestSummary_setOkLineCount(self, okLineCount)
|
|
|
|
def okLineCount(self):
|
|
r"""okLineCount(ArclinkRequestSummary self) -> int"""
|
|
return _datamodel.ArclinkRequestSummary_okLineCount(self)
|
|
|
|
def setTotalLineCount(self, totalLineCount):
|
|
r"""setTotalLineCount(ArclinkRequestSummary self, int totalLineCount)"""
|
|
return _datamodel.ArclinkRequestSummary_setTotalLineCount(self, totalLineCount)
|
|
|
|
def totalLineCount(self):
|
|
r"""totalLineCount(ArclinkRequestSummary self) -> int"""
|
|
return _datamodel.ArclinkRequestSummary_totalLineCount(self)
|
|
|
|
def setAverageTimeWindow(self, averageTimeWindow):
|
|
r"""setAverageTimeWindow(ArclinkRequestSummary self, int averageTimeWindow)"""
|
|
return _datamodel.ArclinkRequestSummary_setAverageTimeWindow(self, averageTimeWindow)
|
|
|
|
def averageTimeWindow(self):
|
|
r"""averageTimeWindow(ArclinkRequestSummary self) -> int"""
|
|
return _datamodel.ArclinkRequestSummary_averageTimeWindow(self)
|
|
|
|
# Register ArclinkRequestSummary in _datamodel:
|
|
_datamodel.ArclinkRequestSummary_swigregister(ArclinkRequestSummary)
|
|
|
|
def ArclinkRequestSummary_ClassName():
|
|
r"""ArclinkRequestSummary_ClassName() -> char const *"""
|
|
return _datamodel.ArclinkRequestSummary_ClassName()
|
|
|
|
def ArclinkRequestSummary_TypeInfo():
|
|
r"""ArclinkRequestSummary_TypeInfo() -> RTTI"""
|
|
return _datamodel.ArclinkRequestSummary_TypeInfo()
|
|
|
|
def ArclinkRequestSummary_Cast(*args):
|
|
r"""
|
|
ArclinkRequestSummary_Cast(BaseObject o) -> ArclinkRequestSummary
|
|
ArclinkRequestSummary_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkRequestSummary
|
|
"""
|
|
return _datamodel.ArclinkRequestSummary_Cast(*args)
|
|
|
|
def ArclinkRequestSummary_ConstCast(*args):
|
|
r"""
|
|
ArclinkRequestSummary_ConstCast(BaseObject o) -> ArclinkRequestSummary
|
|
ArclinkRequestSummary_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkRequestSummary
|
|
"""
|
|
return _datamodel.ArclinkRequestSummary_ConstCast(*args)
|
|
|
|
def ArclinkRequestSummary_Meta():
|
|
r"""ArclinkRequestSummary_Meta() -> MetaObject"""
|
|
return _datamodel.ArclinkRequestSummary_Meta()
|
|
|
|
class EventDescriptionIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EventDescriptionIndex 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__(EventDescriptionIndex self) -> EventDescriptionIndex
|
|
__init__(EventDescriptionIndex self, Seiscomp::DataModel::EventDescriptionType type) -> EventDescriptionIndex
|
|
__init__(EventDescriptionIndex self, EventDescriptionIndex arg2) -> EventDescriptionIndex
|
|
"""
|
|
_datamodel.EventDescriptionIndex_swiginit(self, _datamodel.new_EventDescriptionIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(EventDescriptionIndex self, EventDescriptionIndex arg2) -> bool"""
|
|
return _datamodel.EventDescriptionIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(EventDescriptionIndex self, EventDescriptionIndex arg2) -> bool"""
|
|
return _datamodel.EventDescriptionIndex___ne__(self, arg2)
|
|
type = property(_datamodel.EventDescriptionIndex_type_get, _datamodel.EventDescriptionIndex_type_set, doc=r"""type : Seiscomp::DataModel::EventDescriptionType""")
|
|
__swig_destroy__ = _datamodel.delete_EventDescriptionIndex
|
|
|
|
# Register EventDescriptionIndex in _datamodel:
|
|
_datamodel.EventDescriptionIndex_swigregister(EventDescriptionIndex)
|
|
|
|
class EventDescription(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EventDescription 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 _datamodel.EventDescription_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.EventDescription_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(EventDescription self) -> char const *"""
|
|
return _datamodel.EventDescription_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(EventDescription self) -> RTTI"""
|
|
return _datamodel.EventDescription_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> EventDescription
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> EventDescription
|
|
"""
|
|
return _datamodel.EventDescription_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> EventDescription
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> EventDescription
|
|
"""
|
|
return _datamodel.EventDescription_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(EventDescription self, GenericArchive ar)"""
|
|
return _datamodel.EventDescription_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.EventDescription_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(EventDescription self) -> MetaObject"""
|
|
return _datamodel.EventDescription_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(EventDescription self) -> EventDescription
|
|
__init__(EventDescription self, EventDescription other) -> EventDescription
|
|
__init__(EventDescription self, std::string const & text) -> EventDescription
|
|
__init__(EventDescription self, std::string const & text, Seiscomp::DataModel::EventDescriptionType type) -> EventDescription
|
|
"""
|
|
_datamodel.EventDescription_swiginit(self, _datamodel.new_EventDescription(*args))
|
|
__swig_destroy__ = _datamodel.delete_EventDescription
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(EventDescription self, EventDescription other) -> bool"""
|
|
return _datamodel.EventDescription___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(EventDescription self, EventDescription other) -> bool"""
|
|
return _datamodel.EventDescription___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(EventDescription self, EventDescription other) -> bool"""
|
|
return _datamodel.EventDescription_equal(self, other)
|
|
|
|
def setText(self, text):
|
|
r"""setText(EventDescription self, std::string const & text)"""
|
|
return _datamodel.EventDescription_setText(self, text)
|
|
|
|
def text(self):
|
|
r"""text(EventDescription self) -> std::string const &"""
|
|
return _datamodel.EventDescription_text(self)
|
|
|
|
def setType(self, type):
|
|
r"""setType(EventDescription self, Seiscomp::DataModel::EventDescriptionType type)"""
|
|
return _datamodel.EventDescription_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(EventDescription self) -> Seiscomp::DataModel::EventDescriptionType"""
|
|
return _datamodel.EventDescription_type(self)
|
|
|
|
def index(self):
|
|
r"""index(EventDescription self) -> EventDescriptionIndex"""
|
|
return _datamodel.EventDescription_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(EventDescription self, EventDescription lhs) -> bool"""
|
|
return _datamodel.EventDescription_equalIndex(self, lhs)
|
|
|
|
def event(self):
|
|
r"""event(EventDescription self) -> Event"""
|
|
return _datamodel.EventDescription_event(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(EventDescription self, Object other) -> bool"""
|
|
return _datamodel.EventDescription_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(EventDescription self, PublicObject parent) -> bool"""
|
|
return _datamodel.EventDescription_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(EventDescription self, PublicObject parent) -> bool"""
|
|
return _datamodel.EventDescription_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(EventDescription self) -> bool"""
|
|
return _datamodel.EventDescription_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(EventDescription self) -> Object"""
|
|
return _datamodel.EventDescription_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(EventDescription self, Visitor visitor)"""
|
|
return _datamodel.EventDescription_accept(self, visitor)
|
|
|
|
# Register EventDescription in _datamodel:
|
|
_datamodel.EventDescription_swigregister(EventDescription)
|
|
|
|
def EventDescription_ClassName():
|
|
r"""EventDescription_ClassName() -> char const *"""
|
|
return _datamodel.EventDescription_ClassName()
|
|
|
|
def EventDescription_TypeInfo():
|
|
r"""EventDescription_TypeInfo() -> RTTI"""
|
|
return _datamodel.EventDescription_TypeInfo()
|
|
|
|
def EventDescription_Cast(*args):
|
|
r"""
|
|
EventDescription_Cast(BaseObject o) -> EventDescription
|
|
EventDescription_Cast(Seiscomp::Core::BaseObjectPtr o) -> EventDescription
|
|
"""
|
|
return _datamodel.EventDescription_Cast(*args)
|
|
|
|
def EventDescription_ConstCast(*args):
|
|
r"""
|
|
EventDescription_ConstCast(BaseObject o) -> EventDescription
|
|
EventDescription_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> EventDescription
|
|
"""
|
|
return _datamodel.EventDescription_ConstCast(*args)
|
|
|
|
def EventDescription_Meta():
|
|
r"""EventDescription_Meta() -> MetaObject"""
|
|
return _datamodel.EventDescription_Meta()
|
|
|
|
class DataUsed(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DataUsed 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 _datamodel.DataUsed_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.DataUsed_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(DataUsed self) -> char const *"""
|
|
return _datamodel.DataUsed_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(DataUsed self) -> RTTI"""
|
|
return _datamodel.DataUsed_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> DataUsed
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> DataUsed
|
|
"""
|
|
return _datamodel.DataUsed_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> DataUsed
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataUsed
|
|
"""
|
|
return _datamodel.DataUsed_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(DataUsed self, GenericArchive ar)"""
|
|
return _datamodel.DataUsed_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.DataUsed_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(DataUsed self) -> MetaObject"""
|
|
return _datamodel.DataUsed_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(DataUsed self) -> DataUsed
|
|
__init__(DataUsed self, DataUsed other) -> DataUsed
|
|
"""
|
|
_datamodel.DataUsed_swiginit(self, _datamodel.new_DataUsed(*args))
|
|
__swig_destroy__ = _datamodel.delete_DataUsed
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(DataUsed self, DataUsed other) -> bool"""
|
|
return _datamodel.DataUsed___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(DataUsed self, DataUsed other) -> bool"""
|
|
return _datamodel.DataUsed___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(DataUsed self, DataUsed other) -> bool"""
|
|
return _datamodel.DataUsed_equal(self, other)
|
|
|
|
def setWaveType(self, waveType):
|
|
r"""setWaveType(DataUsed self, Seiscomp::DataModel::DataUsedWaveType waveType)"""
|
|
return _datamodel.DataUsed_setWaveType(self, waveType)
|
|
|
|
def waveType(self):
|
|
r"""waveType(DataUsed self) -> Seiscomp::DataModel::DataUsedWaveType"""
|
|
return _datamodel.DataUsed_waveType(self)
|
|
|
|
def setStationCount(self, stationCount):
|
|
r"""setStationCount(DataUsed self, int stationCount)"""
|
|
return _datamodel.DataUsed_setStationCount(self, stationCount)
|
|
|
|
def stationCount(self):
|
|
r"""stationCount(DataUsed self) -> int"""
|
|
return _datamodel.DataUsed_stationCount(self)
|
|
|
|
def setComponentCount(self, componentCount):
|
|
r"""setComponentCount(DataUsed self, int componentCount)"""
|
|
return _datamodel.DataUsed_setComponentCount(self, componentCount)
|
|
|
|
def componentCount(self):
|
|
r"""componentCount(DataUsed self) -> int"""
|
|
return _datamodel.DataUsed_componentCount(self)
|
|
|
|
def setShortestPeriod(self, shortestPeriod):
|
|
r"""setShortestPeriod(DataUsed self, Seiscomp::Core::Optional< double >::Impl const & shortestPeriod)"""
|
|
return _datamodel.DataUsed_setShortestPeriod(self, shortestPeriod)
|
|
|
|
def shortestPeriod(self):
|
|
r"""shortestPeriod(DataUsed self) -> double"""
|
|
return _datamodel.DataUsed_shortestPeriod(self)
|
|
|
|
def momentTensor(self):
|
|
r"""momentTensor(DataUsed self) -> MomentTensor"""
|
|
return _datamodel.DataUsed_momentTensor(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(DataUsed self, Object other) -> bool"""
|
|
return _datamodel.DataUsed_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(DataUsed self, PublicObject parent) -> bool"""
|
|
return _datamodel.DataUsed_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(DataUsed self, PublicObject parent) -> bool"""
|
|
return _datamodel.DataUsed_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(DataUsed self) -> bool"""
|
|
return _datamodel.DataUsed_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(DataUsed self) -> Object"""
|
|
return _datamodel.DataUsed_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(DataUsed self, Visitor visitor)"""
|
|
return _datamodel.DataUsed_accept(self, visitor)
|
|
|
|
# Register DataUsed in _datamodel:
|
|
_datamodel.DataUsed_swigregister(DataUsed)
|
|
|
|
def DataUsed_ClassName():
|
|
r"""DataUsed_ClassName() -> char const *"""
|
|
return _datamodel.DataUsed_ClassName()
|
|
|
|
def DataUsed_TypeInfo():
|
|
r"""DataUsed_TypeInfo() -> RTTI"""
|
|
return _datamodel.DataUsed_TypeInfo()
|
|
|
|
def DataUsed_Cast(*args):
|
|
r"""
|
|
DataUsed_Cast(BaseObject o) -> DataUsed
|
|
DataUsed_Cast(Seiscomp::Core::BaseObjectPtr o) -> DataUsed
|
|
"""
|
|
return _datamodel.DataUsed_Cast(*args)
|
|
|
|
def DataUsed_ConstCast(*args):
|
|
r"""
|
|
DataUsed_ConstCast(BaseObject o) -> DataUsed
|
|
DataUsed_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataUsed
|
|
"""
|
|
return _datamodel.DataUsed_ConstCast(*args)
|
|
|
|
def DataUsed_Meta():
|
|
r"""DataUsed_Meta() -> MetaObject"""
|
|
return _datamodel.DataUsed_Meta()
|
|
|
|
class CompositeTime(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::CompositeTime 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 _datamodel.CompositeTime_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.CompositeTime_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(CompositeTime self) -> char const *"""
|
|
return _datamodel.CompositeTime_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(CompositeTime self) -> RTTI"""
|
|
return _datamodel.CompositeTime_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> CompositeTime
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> CompositeTime
|
|
"""
|
|
return _datamodel.CompositeTime_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> CompositeTime
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> CompositeTime
|
|
"""
|
|
return _datamodel.CompositeTime_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(CompositeTime self, GenericArchive ar)"""
|
|
return _datamodel.CompositeTime_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.CompositeTime_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(CompositeTime self) -> MetaObject"""
|
|
return _datamodel.CompositeTime_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(CompositeTime self) -> CompositeTime
|
|
__init__(CompositeTime self, CompositeTime other) -> CompositeTime
|
|
"""
|
|
_datamodel.CompositeTime_swiginit(self, _datamodel.new_CompositeTime(*args))
|
|
__swig_destroy__ = _datamodel.delete_CompositeTime
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(CompositeTime self, CompositeTime other) -> bool"""
|
|
return _datamodel.CompositeTime___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(CompositeTime self, CompositeTime other) -> bool"""
|
|
return _datamodel.CompositeTime___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(CompositeTime self, CompositeTime other) -> bool"""
|
|
return _datamodel.CompositeTime_equal(self, other)
|
|
|
|
def setYear(self, year):
|
|
r"""setYear(CompositeTime self, Seiscomp::Core::Optional< Seiscomp::DataModel::IntegerQuantity >::Impl const & year)"""
|
|
return _datamodel.CompositeTime_setYear(self, year)
|
|
|
|
def year(self, *args):
|
|
r"""
|
|
year(CompositeTime self) -> IntegerQuantity
|
|
year(CompositeTime self) -> IntegerQuantity
|
|
"""
|
|
return _datamodel.CompositeTime_year(self, *args)
|
|
|
|
def setMonth(self, month):
|
|
r"""setMonth(CompositeTime self, Seiscomp::Core::Optional< Seiscomp::DataModel::IntegerQuantity >::Impl const & month)"""
|
|
return _datamodel.CompositeTime_setMonth(self, month)
|
|
|
|
def month(self, *args):
|
|
r"""
|
|
month(CompositeTime self) -> IntegerQuantity
|
|
month(CompositeTime self) -> IntegerQuantity
|
|
"""
|
|
return _datamodel.CompositeTime_month(self, *args)
|
|
|
|
def setDay(self, day):
|
|
r"""setDay(CompositeTime self, Seiscomp::Core::Optional< Seiscomp::DataModel::IntegerQuantity >::Impl const & day)"""
|
|
return _datamodel.CompositeTime_setDay(self, day)
|
|
|
|
def day(self, *args):
|
|
r"""
|
|
day(CompositeTime self) -> IntegerQuantity
|
|
day(CompositeTime self) -> IntegerQuantity
|
|
"""
|
|
return _datamodel.CompositeTime_day(self, *args)
|
|
|
|
def setHour(self, hour):
|
|
r"""setHour(CompositeTime self, Seiscomp::Core::Optional< Seiscomp::DataModel::IntegerQuantity >::Impl const & hour)"""
|
|
return _datamodel.CompositeTime_setHour(self, hour)
|
|
|
|
def hour(self, *args):
|
|
r"""
|
|
hour(CompositeTime self) -> IntegerQuantity
|
|
hour(CompositeTime self) -> IntegerQuantity
|
|
"""
|
|
return _datamodel.CompositeTime_hour(self, *args)
|
|
|
|
def setMinute(self, minute):
|
|
r"""setMinute(CompositeTime self, Seiscomp::Core::Optional< Seiscomp::DataModel::IntegerQuantity >::Impl const & minute)"""
|
|
return _datamodel.CompositeTime_setMinute(self, minute)
|
|
|
|
def minute(self, *args):
|
|
r"""
|
|
minute(CompositeTime self) -> IntegerQuantity
|
|
minute(CompositeTime self) -> IntegerQuantity
|
|
"""
|
|
return _datamodel.CompositeTime_minute(self, *args)
|
|
|
|
def setSecond(self, second):
|
|
r"""setSecond(CompositeTime self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity >::Impl const & second)"""
|
|
return _datamodel.CompositeTime_setSecond(self, second)
|
|
|
|
def second(self, *args):
|
|
r"""
|
|
second(CompositeTime self) -> RealQuantity
|
|
second(CompositeTime self) -> RealQuantity
|
|
"""
|
|
return _datamodel.CompositeTime_second(self, *args)
|
|
|
|
def origin(self):
|
|
r"""origin(CompositeTime self) -> Origin"""
|
|
return _datamodel.CompositeTime_origin(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(CompositeTime self, Object other) -> bool"""
|
|
return _datamodel.CompositeTime_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(CompositeTime self, PublicObject parent) -> bool"""
|
|
return _datamodel.CompositeTime_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(CompositeTime self, PublicObject parent) -> bool"""
|
|
return _datamodel.CompositeTime_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(CompositeTime self) -> bool"""
|
|
return _datamodel.CompositeTime_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(CompositeTime self) -> Object"""
|
|
return _datamodel.CompositeTime_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(CompositeTime self, Visitor visitor)"""
|
|
return _datamodel.CompositeTime_accept(self, visitor)
|
|
|
|
# Register CompositeTime in _datamodel:
|
|
_datamodel.CompositeTime_swigregister(CompositeTime)
|
|
|
|
def CompositeTime_ClassName():
|
|
r"""CompositeTime_ClassName() -> char const *"""
|
|
return _datamodel.CompositeTime_ClassName()
|
|
|
|
def CompositeTime_TypeInfo():
|
|
r"""CompositeTime_TypeInfo() -> RTTI"""
|
|
return _datamodel.CompositeTime_TypeInfo()
|
|
|
|
def CompositeTime_Cast(*args):
|
|
r"""
|
|
CompositeTime_Cast(BaseObject o) -> CompositeTime
|
|
CompositeTime_Cast(Seiscomp::Core::BaseObjectPtr o) -> CompositeTime
|
|
"""
|
|
return _datamodel.CompositeTime_Cast(*args)
|
|
|
|
def CompositeTime_ConstCast(*args):
|
|
r"""
|
|
CompositeTime_ConstCast(BaseObject o) -> CompositeTime
|
|
CompositeTime_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> CompositeTime
|
|
"""
|
|
return _datamodel.CompositeTime_ConstCast(*args)
|
|
|
|
def CompositeTime_Meta():
|
|
r"""CompositeTime_Meta() -> MetaObject"""
|
|
return _datamodel.CompositeTime_Meta()
|
|
|
|
class PickReferenceIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::PickReferenceIndex 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__(PickReferenceIndex self) -> PickReferenceIndex
|
|
__init__(PickReferenceIndex self, std::string const & pickID) -> PickReferenceIndex
|
|
__init__(PickReferenceIndex self, PickReferenceIndex arg2) -> PickReferenceIndex
|
|
"""
|
|
_datamodel.PickReferenceIndex_swiginit(self, _datamodel.new_PickReferenceIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(PickReferenceIndex self, PickReferenceIndex arg2) -> bool"""
|
|
return _datamodel.PickReferenceIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(PickReferenceIndex self, PickReferenceIndex arg2) -> bool"""
|
|
return _datamodel.PickReferenceIndex___ne__(self, arg2)
|
|
pickID = property(_datamodel.PickReferenceIndex_pickID_get, _datamodel.PickReferenceIndex_pickID_set, doc=r"""pickID : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_PickReferenceIndex
|
|
|
|
# Register PickReferenceIndex in _datamodel:
|
|
_datamodel.PickReferenceIndex_swigregister(PickReferenceIndex)
|
|
|
|
class PickReference(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::PickReference 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 _datamodel.PickReference_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.PickReference_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(PickReference self) -> char const *"""
|
|
return _datamodel.PickReference_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(PickReference self) -> RTTI"""
|
|
return _datamodel.PickReference_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> PickReference
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> PickReference
|
|
"""
|
|
return _datamodel.PickReference_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> PickReference
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> PickReference
|
|
"""
|
|
return _datamodel.PickReference_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(PickReference self, GenericArchive ar)"""
|
|
return _datamodel.PickReference_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.PickReference_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(PickReference self) -> MetaObject"""
|
|
return _datamodel.PickReference_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(PickReference self) -> PickReference
|
|
__init__(PickReference self, PickReference other) -> PickReference
|
|
__init__(PickReference self, std::string const & pickID) -> PickReference
|
|
"""
|
|
_datamodel.PickReference_swiginit(self, _datamodel.new_PickReference(*args))
|
|
__swig_destroy__ = _datamodel.delete_PickReference
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(PickReference self, PickReference other) -> bool"""
|
|
return _datamodel.PickReference___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(PickReference self, PickReference other) -> bool"""
|
|
return _datamodel.PickReference___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(PickReference self, PickReference other) -> bool"""
|
|
return _datamodel.PickReference_equal(self, other)
|
|
|
|
def setPickID(self, pickID):
|
|
r"""setPickID(PickReference self, std::string const & pickID)"""
|
|
return _datamodel.PickReference_setPickID(self, pickID)
|
|
|
|
def pickID(self):
|
|
r"""pickID(PickReference self) -> std::string const &"""
|
|
return _datamodel.PickReference_pickID(self)
|
|
|
|
def index(self):
|
|
r"""index(PickReference self) -> PickReferenceIndex"""
|
|
return _datamodel.PickReference_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(PickReference self, PickReference lhs) -> bool"""
|
|
return _datamodel.PickReference_equalIndex(self, lhs)
|
|
|
|
def reading(self):
|
|
r"""reading(PickReference self) -> Reading"""
|
|
return _datamodel.PickReference_reading(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(PickReference self, Object other) -> bool"""
|
|
return _datamodel.PickReference_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(PickReference self, PublicObject parent) -> bool"""
|
|
return _datamodel.PickReference_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(PickReference self, PublicObject parent) -> bool"""
|
|
return _datamodel.PickReference_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(PickReference self) -> bool"""
|
|
return _datamodel.PickReference_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(PickReference self) -> Object"""
|
|
return _datamodel.PickReference_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(PickReference self, Visitor visitor)"""
|
|
return _datamodel.PickReference_accept(self, visitor)
|
|
|
|
# Register PickReference in _datamodel:
|
|
_datamodel.PickReference_swigregister(PickReference)
|
|
|
|
def PickReference_ClassName():
|
|
r"""PickReference_ClassName() -> char const *"""
|
|
return _datamodel.PickReference_ClassName()
|
|
|
|
def PickReference_TypeInfo():
|
|
r"""PickReference_TypeInfo() -> RTTI"""
|
|
return _datamodel.PickReference_TypeInfo()
|
|
|
|
def PickReference_Cast(*args):
|
|
r"""
|
|
PickReference_Cast(BaseObject o) -> PickReference
|
|
PickReference_Cast(Seiscomp::Core::BaseObjectPtr o) -> PickReference
|
|
"""
|
|
return _datamodel.PickReference_Cast(*args)
|
|
|
|
def PickReference_ConstCast(*args):
|
|
r"""
|
|
PickReference_ConstCast(BaseObject o) -> PickReference
|
|
PickReference_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> PickReference
|
|
"""
|
|
return _datamodel.PickReference_ConstCast(*args)
|
|
|
|
def PickReference_Meta():
|
|
r"""PickReference_Meta() -> MetaObject"""
|
|
return _datamodel.PickReference_Meta()
|
|
|
|
class AmplitudeReferenceIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::AmplitudeReferenceIndex 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__(AmplitudeReferenceIndex self) -> AmplitudeReferenceIndex
|
|
__init__(AmplitudeReferenceIndex self, std::string const & amplitudeID) -> AmplitudeReferenceIndex
|
|
__init__(AmplitudeReferenceIndex self, AmplitudeReferenceIndex arg2) -> AmplitudeReferenceIndex
|
|
"""
|
|
_datamodel.AmplitudeReferenceIndex_swiginit(self, _datamodel.new_AmplitudeReferenceIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(AmplitudeReferenceIndex self, AmplitudeReferenceIndex arg2) -> bool"""
|
|
return _datamodel.AmplitudeReferenceIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(AmplitudeReferenceIndex self, AmplitudeReferenceIndex arg2) -> bool"""
|
|
return _datamodel.AmplitudeReferenceIndex___ne__(self, arg2)
|
|
amplitudeID = property(_datamodel.AmplitudeReferenceIndex_amplitudeID_get, _datamodel.AmplitudeReferenceIndex_amplitudeID_set, doc=r"""amplitudeID : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_AmplitudeReferenceIndex
|
|
|
|
# Register AmplitudeReferenceIndex in _datamodel:
|
|
_datamodel.AmplitudeReferenceIndex_swigregister(AmplitudeReferenceIndex)
|
|
|
|
class AmplitudeReference(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::AmplitudeReference 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 _datamodel.AmplitudeReference_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.AmplitudeReference_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(AmplitudeReference self) -> char const *"""
|
|
return _datamodel.AmplitudeReference_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(AmplitudeReference self) -> RTTI"""
|
|
return _datamodel.AmplitudeReference_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> AmplitudeReference
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> AmplitudeReference
|
|
"""
|
|
return _datamodel.AmplitudeReference_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> AmplitudeReference
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AmplitudeReference
|
|
"""
|
|
return _datamodel.AmplitudeReference_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(AmplitudeReference self, GenericArchive ar)"""
|
|
return _datamodel.AmplitudeReference_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.AmplitudeReference_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(AmplitudeReference self) -> MetaObject"""
|
|
return _datamodel.AmplitudeReference_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(AmplitudeReference self) -> AmplitudeReference
|
|
__init__(AmplitudeReference self, AmplitudeReference other) -> AmplitudeReference
|
|
__init__(AmplitudeReference self, std::string const & amplitudeID) -> AmplitudeReference
|
|
"""
|
|
_datamodel.AmplitudeReference_swiginit(self, _datamodel.new_AmplitudeReference(*args))
|
|
__swig_destroy__ = _datamodel.delete_AmplitudeReference
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(AmplitudeReference self, AmplitudeReference other) -> bool"""
|
|
return _datamodel.AmplitudeReference___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(AmplitudeReference self, AmplitudeReference other) -> bool"""
|
|
return _datamodel.AmplitudeReference___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(AmplitudeReference self, AmplitudeReference other) -> bool"""
|
|
return _datamodel.AmplitudeReference_equal(self, other)
|
|
|
|
def setAmplitudeID(self, amplitudeID):
|
|
r"""setAmplitudeID(AmplitudeReference self, std::string const & amplitudeID)"""
|
|
return _datamodel.AmplitudeReference_setAmplitudeID(self, amplitudeID)
|
|
|
|
def amplitudeID(self):
|
|
r"""amplitudeID(AmplitudeReference self) -> std::string const &"""
|
|
return _datamodel.AmplitudeReference_amplitudeID(self)
|
|
|
|
def index(self):
|
|
r"""index(AmplitudeReference self) -> AmplitudeReferenceIndex"""
|
|
return _datamodel.AmplitudeReference_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(AmplitudeReference self, AmplitudeReference lhs) -> bool"""
|
|
return _datamodel.AmplitudeReference_equalIndex(self, lhs)
|
|
|
|
def reading(self):
|
|
r"""reading(AmplitudeReference self) -> Reading"""
|
|
return _datamodel.AmplitudeReference_reading(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(AmplitudeReference self, Object other) -> bool"""
|
|
return _datamodel.AmplitudeReference_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(AmplitudeReference self, PublicObject parent) -> bool"""
|
|
return _datamodel.AmplitudeReference_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(AmplitudeReference self, PublicObject parent) -> bool"""
|
|
return _datamodel.AmplitudeReference_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(AmplitudeReference self) -> bool"""
|
|
return _datamodel.AmplitudeReference_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(AmplitudeReference self) -> Object"""
|
|
return _datamodel.AmplitudeReference_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(AmplitudeReference self, Visitor visitor)"""
|
|
return _datamodel.AmplitudeReference_accept(self, visitor)
|
|
|
|
# Register AmplitudeReference in _datamodel:
|
|
_datamodel.AmplitudeReference_swigregister(AmplitudeReference)
|
|
|
|
def AmplitudeReference_ClassName():
|
|
r"""AmplitudeReference_ClassName() -> char const *"""
|
|
return _datamodel.AmplitudeReference_ClassName()
|
|
|
|
def AmplitudeReference_TypeInfo():
|
|
r"""AmplitudeReference_TypeInfo() -> RTTI"""
|
|
return _datamodel.AmplitudeReference_TypeInfo()
|
|
|
|
def AmplitudeReference_Cast(*args):
|
|
r"""
|
|
AmplitudeReference_Cast(BaseObject o) -> AmplitudeReference
|
|
AmplitudeReference_Cast(Seiscomp::Core::BaseObjectPtr o) -> AmplitudeReference
|
|
"""
|
|
return _datamodel.AmplitudeReference_Cast(*args)
|
|
|
|
def AmplitudeReference_ConstCast(*args):
|
|
r"""
|
|
AmplitudeReference_ConstCast(BaseObject o) -> AmplitudeReference
|
|
AmplitudeReference_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AmplitudeReference
|
|
"""
|
|
return _datamodel.AmplitudeReference_ConstCast(*args)
|
|
|
|
def AmplitudeReference_Meta():
|
|
r"""AmplitudeReference_Meta() -> MetaObject"""
|
|
return _datamodel.AmplitudeReference_Meta()
|
|
|
|
class Reading(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Reading 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 _datamodel.Reading_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Reading_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Reading self) -> char const *"""
|
|
return _datamodel.Reading_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Reading self) -> RTTI"""
|
|
return _datamodel.Reading_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Reading
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Reading
|
|
"""
|
|
return _datamodel.Reading_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Reading
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Reading
|
|
"""
|
|
return _datamodel.Reading_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Reading self, GenericArchive ar)"""
|
|
return _datamodel.Reading_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Reading_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Reading self) -> MetaObject"""
|
|
return _datamodel.Reading_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Reading self, Reading other) -> Reading
|
|
__init__(Reading self, std::string const & publicID) -> Reading
|
|
"""
|
|
_datamodel.Reading_swiginit(self, _datamodel.new_Reading(*args))
|
|
__swig_destroy__ = _datamodel.delete_Reading
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> Reading
|
|
Create(std::string const & publicID) -> Reading
|
|
"""
|
|
return _datamodel.Reading_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> Reading"""
|
|
return _datamodel.Reading_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Reading self, Reading other) -> bool"""
|
|
return _datamodel.Reading___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Reading self, Reading other) -> bool"""
|
|
return _datamodel.Reading___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Reading self, Reading other) -> bool"""
|
|
return _datamodel.Reading_equal(self, other)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(Reading self, PickReference obj) -> bool
|
|
add(Reading self, AmplitudeReference obj) -> bool
|
|
"""
|
|
return _datamodel.Reading_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(Reading self, PickReference obj) -> bool
|
|
remove(Reading self, AmplitudeReference obj) -> bool
|
|
"""
|
|
return _datamodel.Reading_remove(self, *args)
|
|
|
|
def removePickReference(self, *args):
|
|
r"""
|
|
removePickReference(Reading self, size_t i) -> bool
|
|
removePickReference(Reading self, PickReferenceIndex i) -> bool
|
|
"""
|
|
return _datamodel.Reading_removePickReference(self, *args)
|
|
|
|
def removeAmplitudeReference(self, *args):
|
|
r"""
|
|
removeAmplitudeReference(Reading self, size_t i) -> bool
|
|
removeAmplitudeReference(Reading self, AmplitudeReferenceIndex i) -> bool
|
|
"""
|
|
return _datamodel.Reading_removeAmplitudeReference(self, *args)
|
|
|
|
def pickReferenceCount(self):
|
|
r"""pickReferenceCount(Reading self) -> size_t"""
|
|
return _datamodel.Reading_pickReferenceCount(self)
|
|
|
|
def amplitudeReferenceCount(self):
|
|
r"""amplitudeReferenceCount(Reading self) -> size_t"""
|
|
return _datamodel.Reading_amplitudeReferenceCount(self)
|
|
|
|
def pickReference(self, *args):
|
|
r"""
|
|
pickReference(Reading self, size_t i) -> PickReference
|
|
pickReference(Reading self, PickReferenceIndex i) -> PickReference
|
|
"""
|
|
return _datamodel.Reading_pickReference(self, *args)
|
|
|
|
def amplitudeReference(self, *args):
|
|
r"""
|
|
amplitudeReference(Reading self, size_t i) -> AmplitudeReference
|
|
amplitudeReference(Reading self, AmplitudeReferenceIndex i) -> AmplitudeReference
|
|
"""
|
|
return _datamodel.Reading_amplitudeReference(self, *args)
|
|
|
|
def eventParameters(self):
|
|
r"""eventParameters(Reading self) -> EventParameters"""
|
|
return _datamodel.Reading_eventParameters(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Reading self, Object other) -> bool"""
|
|
return _datamodel.Reading_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Reading self, PublicObject parent) -> bool"""
|
|
return _datamodel.Reading_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Reading self, PublicObject parent) -> bool"""
|
|
return _datamodel.Reading_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Reading self) -> bool"""
|
|
return _datamodel.Reading_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Reading self) -> Object"""
|
|
return _datamodel.Reading_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Reading self, Object child) -> bool"""
|
|
return _datamodel.Reading_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Reading self, Visitor visitor)"""
|
|
return _datamodel.Reading_accept(self, visitor)
|
|
|
|
# Register Reading in _datamodel:
|
|
_datamodel.Reading_swigregister(Reading)
|
|
|
|
def Reading_ClassName():
|
|
r"""Reading_ClassName() -> char const *"""
|
|
return _datamodel.Reading_ClassName()
|
|
|
|
def Reading_TypeInfo():
|
|
r"""Reading_TypeInfo() -> RTTI"""
|
|
return _datamodel.Reading_TypeInfo()
|
|
|
|
def Reading_Cast(*args):
|
|
r"""
|
|
Reading_Cast(BaseObject o) -> Reading
|
|
Reading_Cast(Seiscomp::Core::BaseObjectPtr o) -> Reading
|
|
"""
|
|
return _datamodel.Reading_Cast(*args)
|
|
|
|
def Reading_ConstCast(*args):
|
|
r"""
|
|
Reading_ConstCast(BaseObject o) -> Reading
|
|
Reading_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Reading
|
|
"""
|
|
return _datamodel.Reading_ConstCast(*args)
|
|
|
|
def Reading_Meta():
|
|
r"""Reading_Meta() -> MetaObject"""
|
|
return _datamodel.Reading_Meta()
|
|
|
|
def Reading_Create(*args):
|
|
r"""
|
|
Reading_Create() -> Reading
|
|
Reading_Create(std::string const & publicID) -> Reading
|
|
"""
|
|
return _datamodel.Reading_Create(*args)
|
|
|
|
def Reading_Find(publicID):
|
|
r"""Reading_Find(std::string const & publicID) -> Reading"""
|
|
return _datamodel.Reading_Find(publicID)
|
|
|
|
class MomentTensorComponentContributionIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::MomentTensorComponentContributionIndex 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__(MomentTensorComponentContributionIndex self) -> MomentTensorComponentContributionIndex
|
|
__init__(MomentTensorComponentContributionIndex self, std::string const & phaseCode, int component) -> MomentTensorComponentContributionIndex
|
|
__init__(MomentTensorComponentContributionIndex self, MomentTensorComponentContributionIndex arg2) -> MomentTensorComponentContributionIndex
|
|
"""
|
|
_datamodel.MomentTensorComponentContributionIndex_swiginit(self, _datamodel.new_MomentTensorComponentContributionIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(MomentTensorComponentContributionIndex self, MomentTensorComponentContributionIndex arg2) -> bool"""
|
|
return _datamodel.MomentTensorComponentContributionIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(MomentTensorComponentContributionIndex self, MomentTensorComponentContributionIndex arg2) -> bool"""
|
|
return _datamodel.MomentTensorComponentContributionIndex___ne__(self, arg2)
|
|
phaseCode = property(_datamodel.MomentTensorComponentContributionIndex_phaseCode_get, _datamodel.MomentTensorComponentContributionIndex_phaseCode_set, doc=r"""phaseCode : std::string""")
|
|
component = property(_datamodel.MomentTensorComponentContributionIndex_component_get, _datamodel.MomentTensorComponentContributionIndex_component_set, doc=r"""component : int""")
|
|
__swig_destroy__ = _datamodel.delete_MomentTensorComponentContributionIndex
|
|
|
|
# Register MomentTensorComponentContributionIndex in _datamodel:
|
|
_datamodel.MomentTensorComponentContributionIndex_swigregister(MomentTensorComponentContributionIndex)
|
|
|
|
class MomentTensorComponentContribution(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::MomentTensorComponentContribution 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 _datamodel.MomentTensorComponentContribution_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.MomentTensorComponentContribution_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(MomentTensorComponentContribution self) -> char const *"""
|
|
return _datamodel.MomentTensorComponentContribution_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(MomentTensorComponentContribution self) -> RTTI"""
|
|
return _datamodel.MomentTensorComponentContribution_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> MomentTensorComponentContribution
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensorComponentContribution
|
|
"""
|
|
return _datamodel.MomentTensorComponentContribution_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> MomentTensorComponentContribution
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensorComponentContribution
|
|
"""
|
|
return _datamodel.MomentTensorComponentContribution_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(MomentTensorComponentContribution self, GenericArchive ar)"""
|
|
return _datamodel.MomentTensorComponentContribution_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.MomentTensorComponentContribution_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(MomentTensorComponentContribution self) -> MetaObject"""
|
|
return _datamodel.MomentTensorComponentContribution_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(MomentTensorComponentContribution self) -> MomentTensorComponentContribution
|
|
__init__(MomentTensorComponentContribution self, MomentTensorComponentContribution other) -> MomentTensorComponentContribution
|
|
__init__(MomentTensorComponentContribution self, std::string const & phaseCode) -> MomentTensorComponentContribution
|
|
__init__(MomentTensorComponentContribution self, std::string const & phaseCode, int component, bool active, double weight, double timeShift, double dataTimeWindow, Seiscomp::Core::Optional< double >::Impl const & misfit=Unset, Seiscomp::Core::Optional< double >::Impl const & snr=Unset) -> MomentTensorComponentContribution
|
|
"""
|
|
_datamodel.MomentTensorComponentContribution_swiginit(self, _datamodel.new_MomentTensorComponentContribution(*args))
|
|
__swig_destroy__ = _datamodel.delete_MomentTensorComponentContribution
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(MomentTensorComponentContribution self, MomentTensorComponentContribution other) -> bool"""
|
|
return _datamodel.MomentTensorComponentContribution___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(MomentTensorComponentContribution self, MomentTensorComponentContribution other) -> bool"""
|
|
return _datamodel.MomentTensorComponentContribution___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(MomentTensorComponentContribution self, MomentTensorComponentContribution other) -> bool"""
|
|
return _datamodel.MomentTensorComponentContribution_equal(self, other)
|
|
|
|
def setPhaseCode(self, phaseCode):
|
|
r"""setPhaseCode(MomentTensorComponentContribution self, std::string const & phaseCode)"""
|
|
return _datamodel.MomentTensorComponentContribution_setPhaseCode(self, phaseCode)
|
|
|
|
def phaseCode(self):
|
|
r"""phaseCode(MomentTensorComponentContribution self) -> std::string const &"""
|
|
return _datamodel.MomentTensorComponentContribution_phaseCode(self)
|
|
|
|
def setComponent(self, component):
|
|
r"""setComponent(MomentTensorComponentContribution self, int component)"""
|
|
return _datamodel.MomentTensorComponentContribution_setComponent(self, component)
|
|
|
|
def component(self):
|
|
r"""component(MomentTensorComponentContribution self) -> int"""
|
|
return _datamodel.MomentTensorComponentContribution_component(self)
|
|
|
|
def setActive(self, active):
|
|
r"""setActive(MomentTensorComponentContribution self, bool active)"""
|
|
return _datamodel.MomentTensorComponentContribution_setActive(self, active)
|
|
|
|
def active(self):
|
|
r"""active(MomentTensorComponentContribution self) -> bool"""
|
|
return _datamodel.MomentTensorComponentContribution_active(self)
|
|
|
|
def setWeight(self, weight):
|
|
r"""setWeight(MomentTensorComponentContribution self, double weight)"""
|
|
return _datamodel.MomentTensorComponentContribution_setWeight(self, weight)
|
|
|
|
def weight(self):
|
|
r"""weight(MomentTensorComponentContribution self) -> double"""
|
|
return _datamodel.MomentTensorComponentContribution_weight(self)
|
|
|
|
def setTimeShift(self, timeShift):
|
|
r"""setTimeShift(MomentTensorComponentContribution self, double timeShift)"""
|
|
return _datamodel.MomentTensorComponentContribution_setTimeShift(self, timeShift)
|
|
|
|
def timeShift(self):
|
|
r"""timeShift(MomentTensorComponentContribution self) -> double"""
|
|
return _datamodel.MomentTensorComponentContribution_timeShift(self)
|
|
|
|
def setDataTimeWindow(self, arg2):
|
|
r"""setDataTimeWindow(MomentTensorComponentContribution self, vectord arg2)"""
|
|
return _datamodel.MomentTensorComponentContribution_setDataTimeWindow(self, arg2)
|
|
|
|
def dataTimeWindow(self, *args):
|
|
r"""
|
|
dataTimeWindow(MomentTensorComponentContribution self) -> vectord
|
|
dataTimeWindow(MomentTensorComponentContribution self) -> vectord
|
|
"""
|
|
return _datamodel.MomentTensorComponentContribution_dataTimeWindow(self, *args)
|
|
|
|
def setMisfit(self, misfit):
|
|
r"""setMisfit(MomentTensorComponentContribution self, Seiscomp::Core::Optional< double >::Impl const & misfit)"""
|
|
return _datamodel.MomentTensorComponentContribution_setMisfit(self, misfit)
|
|
|
|
def misfit(self):
|
|
r"""misfit(MomentTensorComponentContribution self) -> double"""
|
|
return _datamodel.MomentTensorComponentContribution_misfit(self)
|
|
|
|
def setSnr(self, snr):
|
|
r"""setSnr(MomentTensorComponentContribution self, Seiscomp::Core::Optional< double >::Impl const & snr)"""
|
|
return _datamodel.MomentTensorComponentContribution_setSnr(self, snr)
|
|
|
|
def snr(self):
|
|
r"""snr(MomentTensorComponentContribution self) -> double"""
|
|
return _datamodel.MomentTensorComponentContribution_snr(self)
|
|
|
|
def index(self):
|
|
r"""index(MomentTensorComponentContribution self) -> MomentTensorComponentContributionIndex"""
|
|
return _datamodel.MomentTensorComponentContribution_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(MomentTensorComponentContribution self, MomentTensorComponentContribution lhs) -> bool"""
|
|
return _datamodel.MomentTensorComponentContribution_equalIndex(self, lhs)
|
|
|
|
def momentTensorStationContribution(self):
|
|
r"""momentTensorStationContribution(MomentTensorComponentContribution self) -> MomentTensorStationContribution"""
|
|
return _datamodel.MomentTensorComponentContribution_momentTensorStationContribution(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(MomentTensorComponentContribution self, Object other) -> bool"""
|
|
return _datamodel.MomentTensorComponentContribution_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(MomentTensorComponentContribution self, PublicObject parent) -> bool"""
|
|
return _datamodel.MomentTensorComponentContribution_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(MomentTensorComponentContribution self, PublicObject parent) -> bool"""
|
|
return _datamodel.MomentTensorComponentContribution_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(MomentTensorComponentContribution self) -> bool"""
|
|
return _datamodel.MomentTensorComponentContribution_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(MomentTensorComponentContribution self) -> Object"""
|
|
return _datamodel.MomentTensorComponentContribution_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(MomentTensorComponentContribution self, Visitor visitor)"""
|
|
return _datamodel.MomentTensorComponentContribution_accept(self, visitor)
|
|
|
|
# Register MomentTensorComponentContribution in _datamodel:
|
|
_datamodel.MomentTensorComponentContribution_swigregister(MomentTensorComponentContribution)
|
|
|
|
def MomentTensorComponentContribution_ClassName():
|
|
r"""MomentTensorComponentContribution_ClassName() -> char const *"""
|
|
return _datamodel.MomentTensorComponentContribution_ClassName()
|
|
|
|
def MomentTensorComponentContribution_TypeInfo():
|
|
r"""MomentTensorComponentContribution_TypeInfo() -> RTTI"""
|
|
return _datamodel.MomentTensorComponentContribution_TypeInfo()
|
|
|
|
def MomentTensorComponentContribution_Cast(*args):
|
|
r"""
|
|
MomentTensorComponentContribution_Cast(BaseObject o) -> MomentTensorComponentContribution
|
|
MomentTensorComponentContribution_Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensorComponentContribution
|
|
"""
|
|
return _datamodel.MomentTensorComponentContribution_Cast(*args)
|
|
|
|
def MomentTensorComponentContribution_ConstCast(*args):
|
|
r"""
|
|
MomentTensorComponentContribution_ConstCast(BaseObject o) -> MomentTensorComponentContribution
|
|
MomentTensorComponentContribution_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensorComponentContribution
|
|
"""
|
|
return _datamodel.MomentTensorComponentContribution_ConstCast(*args)
|
|
|
|
def MomentTensorComponentContribution_Meta():
|
|
r"""MomentTensorComponentContribution_Meta() -> MetaObject"""
|
|
return _datamodel.MomentTensorComponentContribution_Meta()
|
|
|
|
class MomentTensorStationContribution(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::MomentTensorStationContribution 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 _datamodel.MomentTensorStationContribution_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.MomentTensorStationContribution_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(MomentTensorStationContribution self) -> char const *"""
|
|
return _datamodel.MomentTensorStationContribution_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(MomentTensorStationContribution self) -> RTTI"""
|
|
return _datamodel.MomentTensorStationContribution_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> MomentTensorStationContribution
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensorStationContribution
|
|
"""
|
|
return _datamodel.MomentTensorStationContribution_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> MomentTensorStationContribution
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensorStationContribution
|
|
"""
|
|
return _datamodel.MomentTensorStationContribution_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(MomentTensorStationContribution self, GenericArchive ar)"""
|
|
return _datamodel.MomentTensorStationContribution_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.MomentTensorStationContribution_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(MomentTensorStationContribution self) -> MetaObject"""
|
|
return _datamodel.MomentTensorStationContribution_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(MomentTensorStationContribution self, MomentTensorStationContribution other) -> MomentTensorStationContribution
|
|
__init__(MomentTensorStationContribution self, std::string const & publicID) -> MomentTensorStationContribution
|
|
"""
|
|
_datamodel.MomentTensorStationContribution_swiginit(self, _datamodel.new_MomentTensorStationContribution(*args))
|
|
__swig_destroy__ = _datamodel.delete_MomentTensorStationContribution
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> MomentTensorStationContribution
|
|
Create(std::string const & publicID) -> MomentTensorStationContribution
|
|
"""
|
|
return _datamodel.MomentTensorStationContribution_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> MomentTensorStationContribution"""
|
|
return _datamodel.MomentTensorStationContribution_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(MomentTensorStationContribution self, MomentTensorStationContribution other) -> bool"""
|
|
return _datamodel.MomentTensorStationContribution___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(MomentTensorStationContribution self, MomentTensorStationContribution other) -> bool"""
|
|
return _datamodel.MomentTensorStationContribution___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(MomentTensorStationContribution self, MomentTensorStationContribution other) -> bool"""
|
|
return _datamodel.MomentTensorStationContribution_equal(self, other)
|
|
|
|
def setActive(self, active):
|
|
r"""setActive(MomentTensorStationContribution self, bool active)"""
|
|
return _datamodel.MomentTensorStationContribution_setActive(self, active)
|
|
|
|
def active(self):
|
|
r"""active(MomentTensorStationContribution self) -> bool"""
|
|
return _datamodel.MomentTensorStationContribution_active(self)
|
|
|
|
def setWaveformID(self, waveformID):
|
|
r"""setWaveformID(MomentTensorStationContribution self, Seiscomp::Core::Optional< Seiscomp::DataModel::WaveformStreamID >::Impl const & waveformID)"""
|
|
return _datamodel.MomentTensorStationContribution_setWaveformID(self, waveformID)
|
|
|
|
def waveformID(self, *args):
|
|
r"""
|
|
waveformID(MomentTensorStationContribution self) -> WaveformStreamID
|
|
waveformID(MomentTensorStationContribution self) -> WaveformStreamID
|
|
"""
|
|
return _datamodel.MomentTensorStationContribution_waveformID(self, *args)
|
|
|
|
def setWeight(self, weight):
|
|
r"""setWeight(MomentTensorStationContribution self, Seiscomp::Core::Optional< double >::Impl const & weight)"""
|
|
return _datamodel.MomentTensorStationContribution_setWeight(self, weight)
|
|
|
|
def weight(self):
|
|
r"""weight(MomentTensorStationContribution self) -> double"""
|
|
return _datamodel.MomentTensorStationContribution_weight(self)
|
|
|
|
def setTimeShift(self, timeShift):
|
|
r"""setTimeShift(MomentTensorStationContribution self, Seiscomp::Core::Optional< double >::Impl const & timeShift)"""
|
|
return _datamodel.MomentTensorStationContribution_setTimeShift(self, timeShift)
|
|
|
|
def timeShift(self):
|
|
r"""timeShift(MomentTensorStationContribution self) -> double"""
|
|
return _datamodel.MomentTensorStationContribution_timeShift(self)
|
|
|
|
def add(self, obj):
|
|
r"""add(MomentTensorStationContribution self, MomentTensorComponentContribution obj) -> bool"""
|
|
return _datamodel.MomentTensorStationContribution_add(self, obj)
|
|
|
|
def remove(self, obj):
|
|
r"""remove(MomentTensorStationContribution self, MomentTensorComponentContribution obj) -> bool"""
|
|
return _datamodel.MomentTensorStationContribution_remove(self, obj)
|
|
|
|
def removeMomentTensorComponentContribution(self, *args):
|
|
r"""
|
|
removeMomentTensorComponentContribution(MomentTensorStationContribution self, size_t i) -> bool
|
|
removeMomentTensorComponentContribution(MomentTensorStationContribution self, MomentTensorComponentContributionIndex i) -> bool
|
|
"""
|
|
return _datamodel.MomentTensorStationContribution_removeMomentTensorComponentContribution(self, *args)
|
|
|
|
def momentTensorComponentContributionCount(self):
|
|
r"""momentTensorComponentContributionCount(MomentTensorStationContribution self) -> size_t"""
|
|
return _datamodel.MomentTensorStationContribution_momentTensorComponentContributionCount(self)
|
|
|
|
def momentTensorComponentContribution(self, *args):
|
|
r"""
|
|
momentTensorComponentContribution(MomentTensorStationContribution self, size_t i) -> MomentTensorComponentContribution
|
|
momentTensorComponentContribution(MomentTensorStationContribution self, MomentTensorComponentContributionIndex i) -> MomentTensorComponentContribution
|
|
"""
|
|
return _datamodel.MomentTensorStationContribution_momentTensorComponentContribution(self, *args)
|
|
|
|
def momentTensor(self):
|
|
r"""momentTensor(MomentTensorStationContribution self) -> MomentTensor"""
|
|
return _datamodel.MomentTensorStationContribution_momentTensor(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(MomentTensorStationContribution self, Object other) -> bool"""
|
|
return _datamodel.MomentTensorStationContribution_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(MomentTensorStationContribution self, PublicObject parent) -> bool"""
|
|
return _datamodel.MomentTensorStationContribution_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(MomentTensorStationContribution self, PublicObject parent) -> bool"""
|
|
return _datamodel.MomentTensorStationContribution_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(MomentTensorStationContribution self) -> bool"""
|
|
return _datamodel.MomentTensorStationContribution_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(MomentTensorStationContribution self) -> Object"""
|
|
return _datamodel.MomentTensorStationContribution_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(MomentTensorStationContribution self, Object child) -> bool"""
|
|
return _datamodel.MomentTensorStationContribution_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(MomentTensorStationContribution self, Visitor visitor)"""
|
|
return _datamodel.MomentTensorStationContribution_accept(self, visitor)
|
|
|
|
# Register MomentTensorStationContribution in _datamodel:
|
|
_datamodel.MomentTensorStationContribution_swigregister(MomentTensorStationContribution)
|
|
|
|
def MomentTensorStationContribution_ClassName():
|
|
r"""MomentTensorStationContribution_ClassName() -> char const *"""
|
|
return _datamodel.MomentTensorStationContribution_ClassName()
|
|
|
|
def MomentTensorStationContribution_TypeInfo():
|
|
r"""MomentTensorStationContribution_TypeInfo() -> RTTI"""
|
|
return _datamodel.MomentTensorStationContribution_TypeInfo()
|
|
|
|
def MomentTensorStationContribution_Cast(*args):
|
|
r"""
|
|
MomentTensorStationContribution_Cast(BaseObject o) -> MomentTensorStationContribution
|
|
MomentTensorStationContribution_Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensorStationContribution
|
|
"""
|
|
return _datamodel.MomentTensorStationContribution_Cast(*args)
|
|
|
|
def MomentTensorStationContribution_ConstCast(*args):
|
|
r"""
|
|
MomentTensorStationContribution_ConstCast(BaseObject o) -> MomentTensorStationContribution
|
|
MomentTensorStationContribution_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensorStationContribution
|
|
"""
|
|
return _datamodel.MomentTensorStationContribution_ConstCast(*args)
|
|
|
|
def MomentTensorStationContribution_Meta():
|
|
r"""MomentTensorStationContribution_Meta() -> MetaObject"""
|
|
return _datamodel.MomentTensorStationContribution_Meta()
|
|
|
|
def MomentTensorStationContribution_Create(*args):
|
|
r"""
|
|
MomentTensorStationContribution_Create() -> MomentTensorStationContribution
|
|
MomentTensorStationContribution_Create(std::string const & publicID) -> MomentTensorStationContribution
|
|
"""
|
|
return _datamodel.MomentTensorStationContribution_Create(*args)
|
|
|
|
def MomentTensorStationContribution_Find(publicID):
|
|
r"""MomentTensorStationContribution_Find(std::string const & publicID) -> MomentTensorStationContribution"""
|
|
return _datamodel.MomentTensorStationContribution_Find(publicID)
|
|
|
|
class MomentTensorPhaseSettingIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::MomentTensorPhaseSettingIndex 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__(MomentTensorPhaseSettingIndex self) -> MomentTensorPhaseSettingIndex
|
|
__init__(MomentTensorPhaseSettingIndex self, std::string const & code) -> MomentTensorPhaseSettingIndex
|
|
__init__(MomentTensorPhaseSettingIndex self, MomentTensorPhaseSettingIndex arg2) -> MomentTensorPhaseSettingIndex
|
|
"""
|
|
_datamodel.MomentTensorPhaseSettingIndex_swiginit(self, _datamodel.new_MomentTensorPhaseSettingIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(MomentTensorPhaseSettingIndex self, MomentTensorPhaseSettingIndex arg2) -> bool"""
|
|
return _datamodel.MomentTensorPhaseSettingIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(MomentTensorPhaseSettingIndex self, MomentTensorPhaseSettingIndex arg2) -> bool"""
|
|
return _datamodel.MomentTensorPhaseSettingIndex___ne__(self, arg2)
|
|
code = property(_datamodel.MomentTensorPhaseSettingIndex_code_get, _datamodel.MomentTensorPhaseSettingIndex_code_set, doc=r"""code : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_MomentTensorPhaseSettingIndex
|
|
|
|
# Register MomentTensorPhaseSettingIndex in _datamodel:
|
|
_datamodel.MomentTensorPhaseSettingIndex_swigregister(MomentTensorPhaseSettingIndex)
|
|
|
|
class MomentTensorPhaseSetting(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::MomentTensorPhaseSetting 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 _datamodel.MomentTensorPhaseSetting_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.MomentTensorPhaseSetting_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(MomentTensorPhaseSetting self) -> char const *"""
|
|
return _datamodel.MomentTensorPhaseSetting_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(MomentTensorPhaseSetting self) -> RTTI"""
|
|
return _datamodel.MomentTensorPhaseSetting_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> MomentTensorPhaseSetting
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensorPhaseSetting
|
|
"""
|
|
return _datamodel.MomentTensorPhaseSetting_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> MomentTensorPhaseSetting
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensorPhaseSetting
|
|
"""
|
|
return _datamodel.MomentTensorPhaseSetting_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(MomentTensorPhaseSetting self, GenericArchive ar)"""
|
|
return _datamodel.MomentTensorPhaseSetting_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.MomentTensorPhaseSetting_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(MomentTensorPhaseSetting self) -> MetaObject"""
|
|
return _datamodel.MomentTensorPhaseSetting_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(MomentTensorPhaseSetting self) -> MomentTensorPhaseSetting
|
|
__init__(MomentTensorPhaseSetting self, MomentTensorPhaseSetting other) -> MomentTensorPhaseSetting
|
|
__init__(MomentTensorPhaseSetting self, std::string const & code) -> MomentTensorPhaseSetting
|
|
__init__(MomentTensorPhaseSetting self, std::string const & code, double lowerPeriod, double upperPeriod, Seiscomp::Core::Optional< double >::Impl const & minimumSNR=Unset, Seiscomp::Core::Optional< double >::Impl const & maximumTimeShift=Unset) -> MomentTensorPhaseSetting
|
|
"""
|
|
_datamodel.MomentTensorPhaseSetting_swiginit(self, _datamodel.new_MomentTensorPhaseSetting(*args))
|
|
__swig_destroy__ = _datamodel.delete_MomentTensorPhaseSetting
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(MomentTensorPhaseSetting self, MomentTensorPhaseSetting other) -> bool"""
|
|
return _datamodel.MomentTensorPhaseSetting___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(MomentTensorPhaseSetting self, MomentTensorPhaseSetting other) -> bool"""
|
|
return _datamodel.MomentTensorPhaseSetting___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(MomentTensorPhaseSetting self, MomentTensorPhaseSetting other) -> bool"""
|
|
return _datamodel.MomentTensorPhaseSetting_equal(self, other)
|
|
|
|
def setCode(self, code):
|
|
r"""setCode(MomentTensorPhaseSetting self, std::string const & code)"""
|
|
return _datamodel.MomentTensorPhaseSetting_setCode(self, code)
|
|
|
|
def code(self):
|
|
r"""code(MomentTensorPhaseSetting self) -> std::string const &"""
|
|
return _datamodel.MomentTensorPhaseSetting_code(self)
|
|
|
|
def setLowerPeriod(self, lowerPeriod):
|
|
r"""setLowerPeriod(MomentTensorPhaseSetting self, double lowerPeriod)"""
|
|
return _datamodel.MomentTensorPhaseSetting_setLowerPeriod(self, lowerPeriod)
|
|
|
|
def lowerPeriod(self):
|
|
r"""lowerPeriod(MomentTensorPhaseSetting self) -> double"""
|
|
return _datamodel.MomentTensorPhaseSetting_lowerPeriod(self)
|
|
|
|
def setUpperPeriod(self, upperPeriod):
|
|
r"""setUpperPeriod(MomentTensorPhaseSetting self, double upperPeriod)"""
|
|
return _datamodel.MomentTensorPhaseSetting_setUpperPeriod(self, upperPeriod)
|
|
|
|
def upperPeriod(self):
|
|
r"""upperPeriod(MomentTensorPhaseSetting self) -> double"""
|
|
return _datamodel.MomentTensorPhaseSetting_upperPeriod(self)
|
|
|
|
def setMinimumSNR(self, minimumSNR):
|
|
r"""setMinimumSNR(MomentTensorPhaseSetting self, Seiscomp::Core::Optional< double >::Impl const & minimumSNR)"""
|
|
return _datamodel.MomentTensorPhaseSetting_setMinimumSNR(self, minimumSNR)
|
|
|
|
def minimumSNR(self):
|
|
r"""minimumSNR(MomentTensorPhaseSetting self) -> double"""
|
|
return _datamodel.MomentTensorPhaseSetting_minimumSNR(self)
|
|
|
|
def setMaximumTimeShift(self, maximumTimeShift):
|
|
r"""setMaximumTimeShift(MomentTensorPhaseSetting self, Seiscomp::Core::Optional< double >::Impl const & maximumTimeShift)"""
|
|
return _datamodel.MomentTensorPhaseSetting_setMaximumTimeShift(self, maximumTimeShift)
|
|
|
|
def maximumTimeShift(self):
|
|
r"""maximumTimeShift(MomentTensorPhaseSetting self) -> double"""
|
|
return _datamodel.MomentTensorPhaseSetting_maximumTimeShift(self)
|
|
|
|
def index(self):
|
|
r"""index(MomentTensorPhaseSetting self) -> MomentTensorPhaseSettingIndex"""
|
|
return _datamodel.MomentTensorPhaseSetting_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(MomentTensorPhaseSetting self, MomentTensorPhaseSetting lhs) -> bool"""
|
|
return _datamodel.MomentTensorPhaseSetting_equalIndex(self, lhs)
|
|
|
|
def momentTensor(self):
|
|
r"""momentTensor(MomentTensorPhaseSetting self) -> MomentTensor"""
|
|
return _datamodel.MomentTensorPhaseSetting_momentTensor(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(MomentTensorPhaseSetting self, Object other) -> bool"""
|
|
return _datamodel.MomentTensorPhaseSetting_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(MomentTensorPhaseSetting self, PublicObject parent) -> bool"""
|
|
return _datamodel.MomentTensorPhaseSetting_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(MomentTensorPhaseSetting self, PublicObject parent) -> bool"""
|
|
return _datamodel.MomentTensorPhaseSetting_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(MomentTensorPhaseSetting self) -> bool"""
|
|
return _datamodel.MomentTensorPhaseSetting_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(MomentTensorPhaseSetting self) -> Object"""
|
|
return _datamodel.MomentTensorPhaseSetting_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(MomentTensorPhaseSetting self, Visitor visitor)"""
|
|
return _datamodel.MomentTensorPhaseSetting_accept(self, visitor)
|
|
|
|
# Register MomentTensorPhaseSetting in _datamodel:
|
|
_datamodel.MomentTensorPhaseSetting_swigregister(MomentTensorPhaseSetting)
|
|
|
|
def MomentTensorPhaseSetting_ClassName():
|
|
r"""MomentTensorPhaseSetting_ClassName() -> char const *"""
|
|
return _datamodel.MomentTensorPhaseSetting_ClassName()
|
|
|
|
def MomentTensorPhaseSetting_TypeInfo():
|
|
r"""MomentTensorPhaseSetting_TypeInfo() -> RTTI"""
|
|
return _datamodel.MomentTensorPhaseSetting_TypeInfo()
|
|
|
|
def MomentTensorPhaseSetting_Cast(*args):
|
|
r"""
|
|
MomentTensorPhaseSetting_Cast(BaseObject o) -> MomentTensorPhaseSetting
|
|
MomentTensorPhaseSetting_Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensorPhaseSetting
|
|
"""
|
|
return _datamodel.MomentTensorPhaseSetting_Cast(*args)
|
|
|
|
def MomentTensorPhaseSetting_ConstCast(*args):
|
|
r"""
|
|
MomentTensorPhaseSetting_ConstCast(BaseObject o) -> MomentTensorPhaseSetting
|
|
MomentTensorPhaseSetting_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensorPhaseSetting
|
|
"""
|
|
return _datamodel.MomentTensorPhaseSetting_ConstCast(*args)
|
|
|
|
def MomentTensorPhaseSetting_Meta():
|
|
r"""MomentTensorPhaseSetting_Meta() -> MetaObject"""
|
|
return _datamodel.MomentTensorPhaseSetting_Meta()
|
|
|
|
class MomentTensor(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::MomentTensor 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 _datamodel.MomentTensor_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.MomentTensor_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(MomentTensor self) -> char const *"""
|
|
return _datamodel.MomentTensor_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(MomentTensor self) -> RTTI"""
|
|
return _datamodel.MomentTensor_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> MomentTensor
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensor
|
|
"""
|
|
return _datamodel.MomentTensor_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> MomentTensor
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensor
|
|
"""
|
|
return _datamodel.MomentTensor_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(MomentTensor self, GenericArchive ar)"""
|
|
return _datamodel.MomentTensor_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.MomentTensor_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(MomentTensor self) -> MetaObject"""
|
|
return _datamodel.MomentTensor_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(MomentTensor self, MomentTensor other) -> MomentTensor
|
|
__init__(MomentTensor self, std::string const & publicID) -> MomentTensor
|
|
"""
|
|
_datamodel.MomentTensor_swiginit(self, _datamodel.new_MomentTensor(*args))
|
|
__swig_destroy__ = _datamodel.delete_MomentTensor
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> MomentTensor
|
|
Create(std::string const & publicID) -> MomentTensor
|
|
"""
|
|
return _datamodel.MomentTensor_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> MomentTensor"""
|
|
return _datamodel.MomentTensor_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(MomentTensor self, MomentTensor other) -> bool"""
|
|
return _datamodel.MomentTensor___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(MomentTensor self, MomentTensor other) -> bool"""
|
|
return _datamodel.MomentTensor___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(MomentTensor self, MomentTensor other) -> bool"""
|
|
return _datamodel.MomentTensor_equal(self, other)
|
|
|
|
def setDerivedOriginID(self, derivedOriginID):
|
|
r"""setDerivedOriginID(MomentTensor self, std::string const & derivedOriginID)"""
|
|
return _datamodel.MomentTensor_setDerivedOriginID(self, derivedOriginID)
|
|
|
|
def derivedOriginID(self):
|
|
r"""derivedOriginID(MomentTensor self) -> std::string const &"""
|
|
return _datamodel.MomentTensor_derivedOriginID(self)
|
|
|
|
def setMomentMagnitudeID(self, momentMagnitudeID):
|
|
r"""setMomentMagnitudeID(MomentTensor self, std::string const & momentMagnitudeID)"""
|
|
return _datamodel.MomentTensor_setMomentMagnitudeID(self, momentMagnitudeID)
|
|
|
|
def momentMagnitudeID(self):
|
|
r"""momentMagnitudeID(MomentTensor self) -> std::string const &"""
|
|
return _datamodel.MomentTensor_momentMagnitudeID(self)
|
|
|
|
def setScalarMoment(self, scalarMoment):
|
|
r"""setScalarMoment(MomentTensor self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity >::Impl const & scalarMoment)"""
|
|
return _datamodel.MomentTensor_setScalarMoment(self, scalarMoment)
|
|
|
|
def scalarMoment(self, *args):
|
|
r"""
|
|
scalarMoment(MomentTensor self) -> RealQuantity
|
|
scalarMoment(MomentTensor self) -> RealQuantity
|
|
"""
|
|
return _datamodel.MomentTensor_scalarMoment(self, *args)
|
|
|
|
def setTensor(self, tensor):
|
|
r"""setTensor(MomentTensor self, Seiscomp::Core::Optional< Seiscomp::DataModel::Tensor >::Impl const & tensor)"""
|
|
return _datamodel.MomentTensor_setTensor(self, tensor)
|
|
|
|
def tensor(self, *args):
|
|
r"""
|
|
tensor(MomentTensor self) -> Tensor
|
|
tensor(MomentTensor self) -> Tensor
|
|
"""
|
|
return _datamodel.MomentTensor_tensor(self, *args)
|
|
|
|
def setVariance(self, variance):
|
|
r"""setVariance(MomentTensor self, Seiscomp::Core::Optional< double >::Impl const & variance)"""
|
|
return _datamodel.MomentTensor_setVariance(self, variance)
|
|
|
|
def variance(self):
|
|
r"""variance(MomentTensor self) -> double"""
|
|
return _datamodel.MomentTensor_variance(self)
|
|
|
|
def setVarianceReduction(self, varianceReduction):
|
|
r"""setVarianceReduction(MomentTensor self, Seiscomp::Core::Optional< double >::Impl const & varianceReduction)"""
|
|
return _datamodel.MomentTensor_setVarianceReduction(self, varianceReduction)
|
|
|
|
def varianceReduction(self):
|
|
r"""varianceReduction(MomentTensor self) -> double"""
|
|
return _datamodel.MomentTensor_varianceReduction(self)
|
|
|
|
def setDoubleCouple(self, doubleCouple):
|
|
r"""setDoubleCouple(MomentTensor self, Seiscomp::Core::Optional< double >::Impl const & doubleCouple)"""
|
|
return _datamodel.MomentTensor_setDoubleCouple(self, doubleCouple)
|
|
|
|
def doubleCouple(self):
|
|
r"""doubleCouple(MomentTensor self) -> double"""
|
|
return _datamodel.MomentTensor_doubleCouple(self)
|
|
|
|
def setClvd(self, clvd):
|
|
r"""setClvd(MomentTensor self, Seiscomp::Core::Optional< double >::Impl const & clvd)"""
|
|
return _datamodel.MomentTensor_setClvd(self, clvd)
|
|
|
|
def clvd(self):
|
|
r"""clvd(MomentTensor self) -> double"""
|
|
return _datamodel.MomentTensor_clvd(self)
|
|
|
|
def setIso(self, iso):
|
|
r"""setIso(MomentTensor self, Seiscomp::Core::Optional< double >::Impl const & iso)"""
|
|
return _datamodel.MomentTensor_setIso(self, iso)
|
|
|
|
def iso(self):
|
|
r"""iso(MomentTensor self) -> double"""
|
|
return _datamodel.MomentTensor_iso(self)
|
|
|
|
def setGreensFunctionID(self, greensFunctionID):
|
|
r"""setGreensFunctionID(MomentTensor self, std::string const & greensFunctionID)"""
|
|
return _datamodel.MomentTensor_setGreensFunctionID(self, greensFunctionID)
|
|
|
|
def greensFunctionID(self):
|
|
r"""greensFunctionID(MomentTensor self) -> std::string const &"""
|
|
return _datamodel.MomentTensor_greensFunctionID(self)
|
|
|
|
def setFilterID(self, filterID):
|
|
r"""setFilterID(MomentTensor self, std::string const & filterID)"""
|
|
return _datamodel.MomentTensor_setFilterID(self, filterID)
|
|
|
|
def filterID(self):
|
|
r"""filterID(MomentTensor self) -> std::string const &"""
|
|
return _datamodel.MomentTensor_filterID(self)
|
|
|
|
def setSourceTimeFunction(self, sourceTimeFunction):
|
|
r"""setSourceTimeFunction(MomentTensor self, Seiscomp::Core::Optional< Seiscomp::DataModel::SourceTimeFunction >::Impl const & sourceTimeFunction)"""
|
|
return _datamodel.MomentTensor_setSourceTimeFunction(self, sourceTimeFunction)
|
|
|
|
def sourceTimeFunction(self, *args):
|
|
r"""
|
|
sourceTimeFunction(MomentTensor self) -> SourceTimeFunction
|
|
sourceTimeFunction(MomentTensor self) -> SourceTimeFunction
|
|
"""
|
|
return _datamodel.MomentTensor_sourceTimeFunction(self, *args)
|
|
|
|
def setMethodID(self, methodID):
|
|
r"""setMethodID(MomentTensor self, std::string const & methodID)"""
|
|
return _datamodel.MomentTensor_setMethodID(self, methodID)
|
|
|
|
def methodID(self):
|
|
r"""methodID(MomentTensor self) -> std::string const &"""
|
|
return _datamodel.MomentTensor_methodID(self)
|
|
|
|
def setMethod(self, method):
|
|
r"""setMethod(MomentTensor self, Seiscomp::Core::Optional< Seiscomp::DataModel::MomentTensorMethod >::Impl const & method)"""
|
|
return _datamodel.MomentTensor_setMethod(self, method)
|
|
|
|
def method(self):
|
|
r"""method(MomentTensor self) -> Seiscomp::DataModel::MomentTensorMethod"""
|
|
return _datamodel.MomentTensor_method(self)
|
|
|
|
def setStatus(self, status):
|
|
r"""setStatus(MomentTensor self, Seiscomp::Core::Optional< Seiscomp::DataModel::MomentTensorStatus >::Impl const & status)"""
|
|
return _datamodel.MomentTensor_setStatus(self, status)
|
|
|
|
def status(self):
|
|
r"""status(MomentTensor self) -> Seiscomp::DataModel::MomentTensorStatus"""
|
|
return _datamodel.MomentTensor_status(self)
|
|
|
|
def setCmtName(self, cmtName):
|
|
r"""setCmtName(MomentTensor self, std::string const & cmtName)"""
|
|
return _datamodel.MomentTensor_setCmtName(self, cmtName)
|
|
|
|
def cmtName(self):
|
|
r"""cmtName(MomentTensor self) -> std::string const &"""
|
|
return _datamodel.MomentTensor_cmtName(self)
|
|
|
|
def setCmtVersion(self, cmtVersion):
|
|
r"""setCmtVersion(MomentTensor self, std::string const & cmtVersion)"""
|
|
return _datamodel.MomentTensor_setCmtVersion(self, cmtVersion)
|
|
|
|
def cmtVersion(self):
|
|
r"""cmtVersion(MomentTensor self) -> std::string const &"""
|
|
return _datamodel.MomentTensor_cmtVersion(self)
|
|
|
|
def setCreationInfo(self, creationInfo):
|
|
r"""setCreationInfo(MomentTensor self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
|
|
return _datamodel.MomentTensor_setCreationInfo(self, creationInfo)
|
|
|
|
def creationInfo(self, *args):
|
|
r"""
|
|
creationInfo(MomentTensor self) -> CreationInfo
|
|
creationInfo(MomentTensor self) -> CreationInfo
|
|
"""
|
|
return _datamodel.MomentTensor_creationInfo(self, *args)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(MomentTensor self, Comment obj) -> bool
|
|
add(MomentTensor self, DataUsed obj) -> bool
|
|
add(MomentTensor self, MomentTensorPhaseSetting obj) -> bool
|
|
add(MomentTensor self, MomentTensorStationContribution obj) -> bool
|
|
"""
|
|
return _datamodel.MomentTensor_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(MomentTensor self, Comment obj) -> bool
|
|
remove(MomentTensor self, DataUsed obj) -> bool
|
|
remove(MomentTensor self, MomentTensorPhaseSetting obj) -> bool
|
|
remove(MomentTensor self, MomentTensorStationContribution obj) -> bool
|
|
"""
|
|
return _datamodel.MomentTensor_remove(self, *args)
|
|
|
|
def removeComment(self, *args):
|
|
r"""
|
|
removeComment(MomentTensor self, size_t i) -> bool
|
|
removeComment(MomentTensor self, CommentIndex i) -> bool
|
|
"""
|
|
return _datamodel.MomentTensor_removeComment(self, *args)
|
|
|
|
def removeDataUsed(self, i):
|
|
r"""removeDataUsed(MomentTensor self, size_t i) -> bool"""
|
|
return _datamodel.MomentTensor_removeDataUsed(self, i)
|
|
|
|
def removeMomentTensorPhaseSetting(self, *args):
|
|
r"""
|
|
removeMomentTensorPhaseSetting(MomentTensor self, size_t i) -> bool
|
|
removeMomentTensorPhaseSetting(MomentTensor self, MomentTensorPhaseSettingIndex i) -> bool
|
|
"""
|
|
return _datamodel.MomentTensor_removeMomentTensorPhaseSetting(self, *args)
|
|
|
|
def removeMomentTensorStationContribution(self, i):
|
|
r"""removeMomentTensorStationContribution(MomentTensor self, size_t i) -> bool"""
|
|
return _datamodel.MomentTensor_removeMomentTensorStationContribution(self, i)
|
|
|
|
def commentCount(self):
|
|
r"""commentCount(MomentTensor self) -> size_t"""
|
|
return _datamodel.MomentTensor_commentCount(self)
|
|
|
|
def dataUsedCount(self):
|
|
r"""dataUsedCount(MomentTensor self) -> size_t"""
|
|
return _datamodel.MomentTensor_dataUsedCount(self)
|
|
|
|
def momentTensorPhaseSettingCount(self):
|
|
r"""momentTensorPhaseSettingCount(MomentTensor self) -> size_t"""
|
|
return _datamodel.MomentTensor_momentTensorPhaseSettingCount(self)
|
|
|
|
def momentTensorStationContributionCount(self):
|
|
r"""momentTensorStationContributionCount(MomentTensor self) -> size_t"""
|
|
return _datamodel.MomentTensor_momentTensorStationContributionCount(self)
|
|
|
|
def comment(self, *args):
|
|
r"""
|
|
comment(MomentTensor self, size_t i) -> Comment
|
|
comment(MomentTensor self, CommentIndex i) -> Comment
|
|
"""
|
|
return _datamodel.MomentTensor_comment(self, *args)
|
|
|
|
def dataUsed(self, i):
|
|
r"""dataUsed(MomentTensor self, size_t i) -> DataUsed"""
|
|
return _datamodel.MomentTensor_dataUsed(self, i)
|
|
|
|
def momentTensorPhaseSetting(self, *args):
|
|
r"""
|
|
momentTensorPhaseSetting(MomentTensor self, size_t i) -> MomentTensorPhaseSetting
|
|
momentTensorPhaseSetting(MomentTensor self, MomentTensorPhaseSettingIndex i) -> MomentTensorPhaseSetting
|
|
"""
|
|
return _datamodel.MomentTensor_momentTensorPhaseSetting(self, *args)
|
|
|
|
def momentTensorStationContribution(self, i):
|
|
r"""momentTensorStationContribution(MomentTensor self, size_t i) -> MomentTensorStationContribution"""
|
|
return _datamodel.MomentTensor_momentTensorStationContribution(self, i)
|
|
|
|
def findDataUsed(self, dataUsed):
|
|
r"""findDataUsed(MomentTensor self, DataUsed dataUsed) -> DataUsed"""
|
|
return _datamodel.MomentTensor_findDataUsed(self, dataUsed)
|
|
|
|
def findMomentTensorStationContribution(self, publicID):
|
|
r"""findMomentTensorStationContribution(MomentTensor self, std::string const & publicID) -> MomentTensorStationContribution"""
|
|
return _datamodel.MomentTensor_findMomentTensorStationContribution(self, publicID)
|
|
|
|
def focalMechanism(self):
|
|
r"""focalMechanism(MomentTensor self) -> FocalMechanism"""
|
|
return _datamodel.MomentTensor_focalMechanism(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(MomentTensor self, Object other) -> bool"""
|
|
return _datamodel.MomentTensor_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(MomentTensor self, PublicObject parent) -> bool"""
|
|
return _datamodel.MomentTensor_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(MomentTensor self, PublicObject parent) -> bool"""
|
|
return _datamodel.MomentTensor_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(MomentTensor self) -> bool"""
|
|
return _datamodel.MomentTensor_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(MomentTensor self) -> Object"""
|
|
return _datamodel.MomentTensor_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(MomentTensor self, Object child) -> bool"""
|
|
return _datamodel.MomentTensor_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(MomentTensor self, Visitor visitor)"""
|
|
return _datamodel.MomentTensor_accept(self, visitor)
|
|
|
|
# Register MomentTensor in _datamodel:
|
|
_datamodel.MomentTensor_swigregister(MomentTensor)
|
|
|
|
def MomentTensor_ClassName():
|
|
r"""MomentTensor_ClassName() -> char const *"""
|
|
return _datamodel.MomentTensor_ClassName()
|
|
|
|
def MomentTensor_TypeInfo():
|
|
r"""MomentTensor_TypeInfo() -> RTTI"""
|
|
return _datamodel.MomentTensor_TypeInfo()
|
|
|
|
def MomentTensor_Cast(*args):
|
|
r"""
|
|
MomentTensor_Cast(BaseObject o) -> MomentTensor
|
|
MomentTensor_Cast(Seiscomp::Core::BaseObjectPtr o) -> MomentTensor
|
|
"""
|
|
return _datamodel.MomentTensor_Cast(*args)
|
|
|
|
def MomentTensor_ConstCast(*args):
|
|
r"""
|
|
MomentTensor_ConstCast(BaseObject o) -> MomentTensor
|
|
MomentTensor_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MomentTensor
|
|
"""
|
|
return _datamodel.MomentTensor_ConstCast(*args)
|
|
|
|
def MomentTensor_Meta():
|
|
r"""MomentTensor_Meta() -> MetaObject"""
|
|
return _datamodel.MomentTensor_Meta()
|
|
|
|
def MomentTensor_Create(*args):
|
|
r"""
|
|
MomentTensor_Create() -> MomentTensor
|
|
MomentTensor_Create(std::string const & publicID) -> MomentTensor
|
|
"""
|
|
return _datamodel.MomentTensor_Create(*args)
|
|
|
|
def MomentTensor_Find(publicID):
|
|
r"""MomentTensor_Find(std::string const & publicID) -> MomentTensor"""
|
|
return _datamodel.MomentTensor_Find(publicID)
|
|
|
|
class FocalMechanism(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::FocalMechanism 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 _datamodel.FocalMechanism_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.FocalMechanism_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(FocalMechanism self) -> char const *"""
|
|
return _datamodel.FocalMechanism_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(FocalMechanism self) -> RTTI"""
|
|
return _datamodel.FocalMechanism_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> FocalMechanism
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> FocalMechanism
|
|
"""
|
|
return _datamodel.FocalMechanism_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> FocalMechanism
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> FocalMechanism
|
|
"""
|
|
return _datamodel.FocalMechanism_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(FocalMechanism self, GenericArchive ar)"""
|
|
return _datamodel.FocalMechanism_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.FocalMechanism_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(FocalMechanism self) -> MetaObject"""
|
|
return _datamodel.FocalMechanism_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(FocalMechanism self, FocalMechanism other) -> FocalMechanism
|
|
__init__(FocalMechanism self, std::string const & publicID) -> FocalMechanism
|
|
"""
|
|
_datamodel.FocalMechanism_swiginit(self, _datamodel.new_FocalMechanism(*args))
|
|
__swig_destroy__ = _datamodel.delete_FocalMechanism
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> FocalMechanism
|
|
Create(std::string const & publicID) -> FocalMechanism
|
|
"""
|
|
return _datamodel.FocalMechanism_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> FocalMechanism"""
|
|
return _datamodel.FocalMechanism_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(FocalMechanism self, FocalMechanism other) -> bool"""
|
|
return _datamodel.FocalMechanism___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(FocalMechanism self, FocalMechanism other) -> bool"""
|
|
return _datamodel.FocalMechanism___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(FocalMechanism self, FocalMechanism other) -> bool"""
|
|
return _datamodel.FocalMechanism_equal(self, other)
|
|
|
|
def setTriggeringOriginID(self, triggeringOriginID):
|
|
r"""setTriggeringOriginID(FocalMechanism self, std::string const & triggeringOriginID)"""
|
|
return _datamodel.FocalMechanism_setTriggeringOriginID(self, triggeringOriginID)
|
|
|
|
def triggeringOriginID(self):
|
|
r"""triggeringOriginID(FocalMechanism self) -> std::string const &"""
|
|
return _datamodel.FocalMechanism_triggeringOriginID(self)
|
|
|
|
def setNodalPlanes(self, nodalPlanes):
|
|
r"""setNodalPlanes(FocalMechanism self, Seiscomp::Core::Optional< Seiscomp::DataModel::NodalPlanes >::Impl const & nodalPlanes)"""
|
|
return _datamodel.FocalMechanism_setNodalPlanes(self, nodalPlanes)
|
|
|
|
def nodalPlanes(self, *args):
|
|
r"""
|
|
nodalPlanes(FocalMechanism self) -> NodalPlanes
|
|
nodalPlanes(FocalMechanism self) -> NodalPlanes
|
|
"""
|
|
return _datamodel.FocalMechanism_nodalPlanes(self, *args)
|
|
|
|
def setPrincipalAxes(self, principalAxes):
|
|
r"""setPrincipalAxes(FocalMechanism self, Seiscomp::Core::Optional< Seiscomp::DataModel::PrincipalAxes >::Impl const & principalAxes)"""
|
|
return _datamodel.FocalMechanism_setPrincipalAxes(self, principalAxes)
|
|
|
|
def principalAxes(self, *args):
|
|
r"""
|
|
principalAxes(FocalMechanism self) -> PrincipalAxes
|
|
principalAxes(FocalMechanism self) -> PrincipalAxes
|
|
"""
|
|
return _datamodel.FocalMechanism_principalAxes(self, *args)
|
|
|
|
def setAzimuthalGap(self, azimuthalGap):
|
|
r"""setAzimuthalGap(FocalMechanism self, Seiscomp::Core::Optional< double >::Impl const & azimuthalGap)"""
|
|
return _datamodel.FocalMechanism_setAzimuthalGap(self, azimuthalGap)
|
|
|
|
def azimuthalGap(self):
|
|
r"""azimuthalGap(FocalMechanism self) -> double"""
|
|
return _datamodel.FocalMechanism_azimuthalGap(self)
|
|
|
|
def setStationPolarityCount(self, stationPolarityCount):
|
|
r"""setStationPolarityCount(FocalMechanism self, Seiscomp::Core::Optional< int >::Impl const & stationPolarityCount)"""
|
|
return _datamodel.FocalMechanism_setStationPolarityCount(self, stationPolarityCount)
|
|
|
|
def stationPolarityCount(self):
|
|
r"""stationPolarityCount(FocalMechanism self) -> int"""
|
|
return _datamodel.FocalMechanism_stationPolarityCount(self)
|
|
|
|
def setMisfit(self, misfit):
|
|
r"""setMisfit(FocalMechanism self, Seiscomp::Core::Optional< double >::Impl const & misfit)"""
|
|
return _datamodel.FocalMechanism_setMisfit(self, misfit)
|
|
|
|
def misfit(self):
|
|
r"""misfit(FocalMechanism self) -> double"""
|
|
return _datamodel.FocalMechanism_misfit(self)
|
|
|
|
def setStationDistributionRatio(self, stationDistributionRatio):
|
|
r"""setStationDistributionRatio(FocalMechanism self, Seiscomp::Core::Optional< double >::Impl const & stationDistributionRatio)"""
|
|
return _datamodel.FocalMechanism_setStationDistributionRatio(self, stationDistributionRatio)
|
|
|
|
def stationDistributionRatio(self):
|
|
r"""stationDistributionRatio(FocalMechanism self) -> double"""
|
|
return _datamodel.FocalMechanism_stationDistributionRatio(self)
|
|
|
|
def setMethodID(self, methodID):
|
|
r"""setMethodID(FocalMechanism self, std::string const & methodID)"""
|
|
return _datamodel.FocalMechanism_setMethodID(self, methodID)
|
|
|
|
def methodID(self):
|
|
r"""methodID(FocalMechanism self) -> std::string const &"""
|
|
return _datamodel.FocalMechanism_methodID(self)
|
|
|
|
def setEvaluationMode(self, evaluationMode):
|
|
r"""setEvaluationMode(FocalMechanism self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationMode >::Impl const & evaluationMode)"""
|
|
return _datamodel.FocalMechanism_setEvaluationMode(self, evaluationMode)
|
|
|
|
def evaluationMode(self):
|
|
r"""evaluationMode(FocalMechanism self) -> Seiscomp::DataModel::EvaluationMode"""
|
|
return _datamodel.FocalMechanism_evaluationMode(self)
|
|
|
|
def setEvaluationStatus(self, evaluationStatus):
|
|
r"""setEvaluationStatus(FocalMechanism self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationStatus >::Impl const & evaluationStatus)"""
|
|
return _datamodel.FocalMechanism_setEvaluationStatus(self, evaluationStatus)
|
|
|
|
def evaluationStatus(self):
|
|
r"""evaluationStatus(FocalMechanism self) -> Seiscomp::DataModel::EvaluationStatus"""
|
|
return _datamodel.FocalMechanism_evaluationStatus(self)
|
|
|
|
def setCreationInfo(self, creationInfo):
|
|
r"""setCreationInfo(FocalMechanism self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
|
|
return _datamodel.FocalMechanism_setCreationInfo(self, creationInfo)
|
|
|
|
def creationInfo(self, *args):
|
|
r"""
|
|
creationInfo(FocalMechanism self) -> CreationInfo
|
|
creationInfo(FocalMechanism self) -> CreationInfo
|
|
"""
|
|
return _datamodel.FocalMechanism_creationInfo(self, *args)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(FocalMechanism self, Comment obj) -> bool
|
|
add(FocalMechanism self, MomentTensor obj) -> bool
|
|
"""
|
|
return _datamodel.FocalMechanism_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(FocalMechanism self, Comment obj) -> bool
|
|
remove(FocalMechanism self, MomentTensor obj) -> bool
|
|
"""
|
|
return _datamodel.FocalMechanism_remove(self, *args)
|
|
|
|
def removeComment(self, *args):
|
|
r"""
|
|
removeComment(FocalMechanism self, size_t i) -> bool
|
|
removeComment(FocalMechanism self, CommentIndex i) -> bool
|
|
"""
|
|
return _datamodel.FocalMechanism_removeComment(self, *args)
|
|
|
|
def removeMomentTensor(self, i):
|
|
r"""removeMomentTensor(FocalMechanism self, size_t i) -> bool"""
|
|
return _datamodel.FocalMechanism_removeMomentTensor(self, i)
|
|
|
|
def commentCount(self):
|
|
r"""commentCount(FocalMechanism self) -> size_t"""
|
|
return _datamodel.FocalMechanism_commentCount(self)
|
|
|
|
def momentTensorCount(self):
|
|
r"""momentTensorCount(FocalMechanism self) -> size_t"""
|
|
return _datamodel.FocalMechanism_momentTensorCount(self)
|
|
|
|
def comment(self, *args):
|
|
r"""
|
|
comment(FocalMechanism self, size_t i) -> Comment
|
|
comment(FocalMechanism self, CommentIndex i) -> Comment
|
|
"""
|
|
return _datamodel.FocalMechanism_comment(self, *args)
|
|
|
|
def momentTensor(self, i):
|
|
r"""momentTensor(FocalMechanism self, size_t i) -> MomentTensor"""
|
|
return _datamodel.FocalMechanism_momentTensor(self, i)
|
|
|
|
def findMomentTensor(self, publicID):
|
|
r"""findMomentTensor(FocalMechanism self, std::string const & publicID) -> MomentTensor"""
|
|
return _datamodel.FocalMechanism_findMomentTensor(self, publicID)
|
|
|
|
def eventParameters(self):
|
|
r"""eventParameters(FocalMechanism self) -> EventParameters"""
|
|
return _datamodel.FocalMechanism_eventParameters(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(FocalMechanism self, Object other) -> bool"""
|
|
return _datamodel.FocalMechanism_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(FocalMechanism self, PublicObject parent) -> bool"""
|
|
return _datamodel.FocalMechanism_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(FocalMechanism self, PublicObject parent) -> bool"""
|
|
return _datamodel.FocalMechanism_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(FocalMechanism self) -> bool"""
|
|
return _datamodel.FocalMechanism_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(FocalMechanism self) -> Object"""
|
|
return _datamodel.FocalMechanism_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(FocalMechanism self, Object child) -> bool"""
|
|
return _datamodel.FocalMechanism_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(FocalMechanism self, Visitor visitor)"""
|
|
return _datamodel.FocalMechanism_accept(self, visitor)
|
|
|
|
# Register FocalMechanism in _datamodel:
|
|
_datamodel.FocalMechanism_swigregister(FocalMechanism)
|
|
|
|
def FocalMechanism_ClassName():
|
|
r"""FocalMechanism_ClassName() -> char const *"""
|
|
return _datamodel.FocalMechanism_ClassName()
|
|
|
|
def FocalMechanism_TypeInfo():
|
|
r"""FocalMechanism_TypeInfo() -> RTTI"""
|
|
return _datamodel.FocalMechanism_TypeInfo()
|
|
|
|
def FocalMechanism_Cast(*args):
|
|
r"""
|
|
FocalMechanism_Cast(BaseObject o) -> FocalMechanism
|
|
FocalMechanism_Cast(Seiscomp::Core::BaseObjectPtr o) -> FocalMechanism
|
|
"""
|
|
return _datamodel.FocalMechanism_Cast(*args)
|
|
|
|
def FocalMechanism_ConstCast(*args):
|
|
r"""
|
|
FocalMechanism_ConstCast(BaseObject o) -> FocalMechanism
|
|
FocalMechanism_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> FocalMechanism
|
|
"""
|
|
return _datamodel.FocalMechanism_ConstCast(*args)
|
|
|
|
def FocalMechanism_Meta():
|
|
r"""FocalMechanism_Meta() -> MetaObject"""
|
|
return _datamodel.FocalMechanism_Meta()
|
|
|
|
def FocalMechanism_Create(*args):
|
|
r"""
|
|
FocalMechanism_Create() -> FocalMechanism
|
|
FocalMechanism_Create(std::string const & publicID) -> FocalMechanism
|
|
"""
|
|
return _datamodel.FocalMechanism_Create(*args)
|
|
|
|
def FocalMechanism_Find(publicID):
|
|
r"""FocalMechanism_Find(std::string const & publicID) -> FocalMechanism"""
|
|
return _datamodel.FocalMechanism_Find(publicID)
|
|
|
|
class Amplitude(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Amplitude 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 _datamodel.Amplitude_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Amplitude_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Amplitude self) -> char const *"""
|
|
return _datamodel.Amplitude_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Amplitude self) -> RTTI"""
|
|
return _datamodel.Amplitude_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Amplitude
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Amplitude
|
|
"""
|
|
return _datamodel.Amplitude_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Amplitude
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Amplitude
|
|
"""
|
|
return _datamodel.Amplitude_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Amplitude self, GenericArchive ar)"""
|
|
return _datamodel.Amplitude_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Amplitude_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Amplitude self) -> MetaObject"""
|
|
return _datamodel.Amplitude_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Amplitude self, Amplitude other) -> Amplitude
|
|
__init__(Amplitude self, std::string const & publicID) -> Amplitude
|
|
"""
|
|
_datamodel.Amplitude_swiginit(self, _datamodel.new_Amplitude(*args))
|
|
__swig_destroy__ = _datamodel.delete_Amplitude
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> Amplitude
|
|
Create(std::string const & publicID) -> Amplitude
|
|
"""
|
|
return _datamodel.Amplitude_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> Amplitude"""
|
|
return _datamodel.Amplitude_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Amplitude self, Amplitude other) -> bool"""
|
|
return _datamodel.Amplitude___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Amplitude self, Amplitude other) -> bool"""
|
|
return _datamodel.Amplitude___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Amplitude self, Amplitude other) -> bool"""
|
|
return _datamodel.Amplitude_equal(self, other)
|
|
|
|
def setType(self, type):
|
|
r"""setType(Amplitude self, std::string const & type)"""
|
|
return _datamodel.Amplitude_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(Amplitude self) -> std::string const &"""
|
|
return _datamodel.Amplitude_type(self)
|
|
|
|
def setAmplitude(self, amplitude):
|
|
r"""setAmplitude(Amplitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity >::Impl const & amplitude)"""
|
|
return _datamodel.Amplitude_setAmplitude(self, amplitude)
|
|
|
|
def amplitude(self, *args):
|
|
r"""
|
|
amplitude(Amplitude self) -> RealQuantity
|
|
amplitude(Amplitude self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Amplitude_amplitude(self, *args)
|
|
|
|
def setTimeWindow(self, timeWindow):
|
|
r"""setTimeWindow(Amplitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::TimeWindow >::Impl const & timeWindow)"""
|
|
return _datamodel.Amplitude_setTimeWindow(self, timeWindow)
|
|
|
|
def timeWindow(self, *args):
|
|
r"""
|
|
timeWindow(Amplitude self) -> TimeWindow
|
|
timeWindow(Amplitude self) -> TimeWindow
|
|
"""
|
|
return _datamodel.Amplitude_timeWindow(self, *args)
|
|
|
|
def setPeriod(self, period):
|
|
r"""setPeriod(Amplitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity >::Impl const & period)"""
|
|
return _datamodel.Amplitude_setPeriod(self, period)
|
|
|
|
def period(self, *args):
|
|
r"""
|
|
period(Amplitude self) -> RealQuantity
|
|
period(Amplitude self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Amplitude_period(self, *args)
|
|
|
|
def setSnr(self, snr):
|
|
r"""setSnr(Amplitude self, Seiscomp::Core::Optional< double >::Impl const & snr)"""
|
|
return _datamodel.Amplitude_setSnr(self, snr)
|
|
|
|
def snr(self):
|
|
r"""snr(Amplitude self) -> double"""
|
|
return _datamodel.Amplitude_snr(self)
|
|
|
|
def setUnit(self, unit):
|
|
r"""setUnit(Amplitude self, std::string const & unit)"""
|
|
return _datamodel.Amplitude_setUnit(self, unit)
|
|
|
|
def unit(self):
|
|
r"""unit(Amplitude self) -> std::string const &"""
|
|
return _datamodel.Amplitude_unit(self)
|
|
|
|
def setPickID(self, pickID):
|
|
r"""setPickID(Amplitude self, std::string const & pickID)"""
|
|
return _datamodel.Amplitude_setPickID(self, pickID)
|
|
|
|
def pickID(self):
|
|
r"""pickID(Amplitude self) -> std::string const &"""
|
|
return _datamodel.Amplitude_pickID(self)
|
|
|
|
def setWaveformID(self, waveformID):
|
|
r"""setWaveformID(Amplitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::WaveformStreamID >::Impl const & waveformID)"""
|
|
return _datamodel.Amplitude_setWaveformID(self, waveformID)
|
|
|
|
def waveformID(self, *args):
|
|
r"""
|
|
waveformID(Amplitude self) -> WaveformStreamID
|
|
waveformID(Amplitude self) -> WaveformStreamID
|
|
"""
|
|
return _datamodel.Amplitude_waveformID(self, *args)
|
|
|
|
def setFilterID(self, filterID):
|
|
r"""setFilterID(Amplitude self, std::string const & filterID)"""
|
|
return _datamodel.Amplitude_setFilterID(self, filterID)
|
|
|
|
def filterID(self):
|
|
r"""filterID(Amplitude self) -> std::string const &"""
|
|
return _datamodel.Amplitude_filterID(self)
|
|
|
|
def setMethodID(self, methodID):
|
|
r"""setMethodID(Amplitude self, std::string const & methodID)"""
|
|
return _datamodel.Amplitude_setMethodID(self, methodID)
|
|
|
|
def methodID(self):
|
|
r"""methodID(Amplitude self) -> std::string const &"""
|
|
return _datamodel.Amplitude_methodID(self)
|
|
|
|
def setScalingTime(self, scalingTime):
|
|
r"""setScalingTime(Amplitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::TimeQuantity >::Impl const & scalingTime)"""
|
|
return _datamodel.Amplitude_setScalingTime(self, scalingTime)
|
|
|
|
def scalingTime(self, *args):
|
|
r"""
|
|
scalingTime(Amplitude self) -> TimeQuantity
|
|
scalingTime(Amplitude self) -> TimeQuantity
|
|
"""
|
|
return _datamodel.Amplitude_scalingTime(self, *args)
|
|
|
|
def setMagnitudeHint(self, magnitudeHint):
|
|
r"""setMagnitudeHint(Amplitude self, std::string const & magnitudeHint)"""
|
|
return _datamodel.Amplitude_setMagnitudeHint(self, magnitudeHint)
|
|
|
|
def magnitudeHint(self):
|
|
r"""magnitudeHint(Amplitude self) -> std::string const &"""
|
|
return _datamodel.Amplitude_magnitudeHint(self)
|
|
|
|
def setEvaluationMode(self, evaluationMode):
|
|
r"""setEvaluationMode(Amplitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationMode >::Impl const & evaluationMode)"""
|
|
return _datamodel.Amplitude_setEvaluationMode(self, evaluationMode)
|
|
|
|
def evaluationMode(self):
|
|
r"""evaluationMode(Amplitude self) -> Seiscomp::DataModel::EvaluationMode"""
|
|
return _datamodel.Amplitude_evaluationMode(self)
|
|
|
|
def setCreationInfo(self, creationInfo):
|
|
r"""setCreationInfo(Amplitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
|
|
return _datamodel.Amplitude_setCreationInfo(self, creationInfo)
|
|
|
|
def creationInfo(self, *args):
|
|
r"""
|
|
creationInfo(Amplitude self) -> CreationInfo
|
|
creationInfo(Amplitude self) -> CreationInfo
|
|
"""
|
|
return _datamodel.Amplitude_creationInfo(self, *args)
|
|
|
|
def add(self, obj):
|
|
r"""add(Amplitude self, Comment obj) -> bool"""
|
|
return _datamodel.Amplitude_add(self, obj)
|
|
|
|
def remove(self, obj):
|
|
r"""remove(Amplitude self, Comment obj) -> bool"""
|
|
return _datamodel.Amplitude_remove(self, obj)
|
|
|
|
def removeComment(self, *args):
|
|
r"""
|
|
removeComment(Amplitude self, size_t i) -> bool
|
|
removeComment(Amplitude self, CommentIndex i) -> bool
|
|
"""
|
|
return _datamodel.Amplitude_removeComment(self, *args)
|
|
|
|
def commentCount(self):
|
|
r"""commentCount(Amplitude self) -> size_t"""
|
|
return _datamodel.Amplitude_commentCount(self)
|
|
|
|
def comment(self, *args):
|
|
r"""
|
|
comment(Amplitude self, size_t i) -> Comment
|
|
comment(Amplitude self, CommentIndex i) -> Comment
|
|
"""
|
|
return _datamodel.Amplitude_comment(self, *args)
|
|
|
|
def eventParameters(self):
|
|
r"""eventParameters(Amplitude self) -> EventParameters"""
|
|
return _datamodel.Amplitude_eventParameters(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Amplitude self, Object other) -> bool"""
|
|
return _datamodel.Amplitude_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Amplitude self, PublicObject parent) -> bool"""
|
|
return _datamodel.Amplitude_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Amplitude self, PublicObject parent) -> bool"""
|
|
return _datamodel.Amplitude_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Amplitude self) -> bool"""
|
|
return _datamodel.Amplitude_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Amplitude self) -> Object"""
|
|
return _datamodel.Amplitude_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Amplitude self, Object child) -> bool"""
|
|
return _datamodel.Amplitude_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Amplitude self, Visitor visitor)"""
|
|
return _datamodel.Amplitude_accept(self, visitor)
|
|
|
|
# Register Amplitude in _datamodel:
|
|
_datamodel.Amplitude_swigregister(Amplitude)
|
|
|
|
def Amplitude_ClassName():
|
|
r"""Amplitude_ClassName() -> char const *"""
|
|
return _datamodel.Amplitude_ClassName()
|
|
|
|
def Amplitude_TypeInfo():
|
|
r"""Amplitude_TypeInfo() -> RTTI"""
|
|
return _datamodel.Amplitude_TypeInfo()
|
|
|
|
def Amplitude_Cast(*args):
|
|
r"""
|
|
Amplitude_Cast(BaseObject o) -> Amplitude
|
|
Amplitude_Cast(Seiscomp::Core::BaseObjectPtr o) -> Amplitude
|
|
"""
|
|
return _datamodel.Amplitude_Cast(*args)
|
|
|
|
def Amplitude_ConstCast(*args):
|
|
r"""
|
|
Amplitude_ConstCast(BaseObject o) -> Amplitude
|
|
Amplitude_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Amplitude
|
|
"""
|
|
return _datamodel.Amplitude_ConstCast(*args)
|
|
|
|
def Amplitude_Meta():
|
|
r"""Amplitude_Meta() -> MetaObject"""
|
|
return _datamodel.Amplitude_Meta()
|
|
|
|
def Amplitude_Create(*args):
|
|
r"""
|
|
Amplitude_Create() -> Amplitude
|
|
Amplitude_Create(std::string const & publicID) -> Amplitude
|
|
"""
|
|
return _datamodel.Amplitude_Create(*args)
|
|
|
|
def Amplitude_Find(publicID):
|
|
r"""Amplitude_Find(std::string const & publicID) -> Amplitude"""
|
|
return _datamodel.Amplitude_Find(publicID)
|
|
|
|
class StationMagnitudeContributionIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::StationMagnitudeContributionIndex 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__(StationMagnitudeContributionIndex self) -> StationMagnitudeContributionIndex
|
|
__init__(StationMagnitudeContributionIndex self, std::string const & stationMagnitudeID) -> StationMagnitudeContributionIndex
|
|
__init__(StationMagnitudeContributionIndex self, StationMagnitudeContributionIndex arg2) -> StationMagnitudeContributionIndex
|
|
"""
|
|
_datamodel.StationMagnitudeContributionIndex_swiginit(self, _datamodel.new_StationMagnitudeContributionIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(StationMagnitudeContributionIndex self, StationMagnitudeContributionIndex arg2) -> bool"""
|
|
return _datamodel.StationMagnitudeContributionIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(StationMagnitudeContributionIndex self, StationMagnitudeContributionIndex arg2) -> bool"""
|
|
return _datamodel.StationMagnitudeContributionIndex___ne__(self, arg2)
|
|
stationMagnitudeID = property(_datamodel.StationMagnitudeContributionIndex_stationMagnitudeID_get, _datamodel.StationMagnitudeContributionIndex_stationMagnitudeID_set, doc=r"""stationMagnitudeID : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_StationMagnitudeContributionIndex
|
|
|
|
# Register StationMagnitudeContributionIndex in _datamodel:
|
|
_datamodel.StationMagnitudeContributionIndex_swigregister(StationMagnitudeContributionIndex)
|
|
|
|
class StationMagnitudeContribution(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::StationMagnitudeContribution 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 _datamodel.StationMagnitudeContribution_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.StationMagnitudeContribution_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(StationMagnitudeContribution self) -> char const *"""
|
|
return _datamodel.StationMagnitudeContribution_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(StationMagnitudeContribution self) -> RTTI"""
|
|
return _datamodel.StationMagnitudeContribution_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> StationMagnitudeContribution
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> StationMagnitudeContribution
|
|
"""
|
|
return _datamodel.StationMagnitudeContribution_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> StationMagnitudeContribution
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationMagnitudeContribution
|
|
"""
|
|
return _datamodel.StationMagnitudeContribution_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(StationMagnitudeContribution self, GenericArchive ar)"""
|
|
return _datamodel.StationMagnitudeContribution_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.StationMagnitudeContribution_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(StationMagnitudeContribution self) -> MetaObject"""
|
|
return _datamodel.StationMagnitudeContribution_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(StationMagnitudeContribution self) -> StationMagnitudeContribution
|
|
__init__(StationMagnitudeContribution self, StationMagnitudeContribution other) -> StationMagnitudeContribution
|
|
__init__(StationMagnitudeContribution self, std::string const & stationMagnitudeID, Seiscomp::Core::Optional< double >::Impl const & residual=Unset, Seiscomp::Core::Optional< double >::Impl const & weight=Unset) -> StationMagnitudeContribution
|
|
"""
|
|
_datamodel.StationMagnitudeContribution_swiginit(self, _datamodel.new_StationMagnitudeContribution(*args))
|
|
__swig_destroy__ = _datamodel.delete_StationMagnitudeContribution
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(StationMagnitudeContribution self, StationMagnitudeContribution other) -> bool"""
|
|
return _datamodel.StationMagnitudeContribution___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(StationMagnitudeContribution self, StationMagnitudeContribution other) -> bool"""
|
|
return _datamodel.StationMagnitudeContribution___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(StationMagnitudeContribution self, StationMagnitudeContribution other) -> bool"""
|
|
return _datamodel.StationMagnitudeContribution_equal(self, other)
|
|
|
|
def setStationMagnitudeID(self, stationMagnitudeID):
|
|
r"""setStationMagnitudeID(StationMagnitudeContribution self, std::string const & stationMagnitudeID)"""
|
|
return _datamodel.StationMagnitudeContribution_setStationMagnitudeID(self, stationMagnitudeID)
|
|
|
|
def stationMagnitudeID(self):
|
|
r"""stationMagnitudeID(StationMagnitudeContribution self) -> std::string const &"""
|
|
return _datamodel.StationMagnitudeContribution_stationMagnitudeID(self)
|
|
|
|
def setResidual(self, residual):
|
|
r"""setResidual(StationMagnitudeContribution self, Seiscomp::Core::Optional< double >::Impl const & residual)"""
|
|
return _datamodel.StationMagnitudeContribution_setResidual(self, residual)
|
|
|
|
def residual(self):
|
|
r"""residual(StationMagnitudeContribution self) -> double"""
|
|
return _datamodel.StationMagnitudeContribution_residual(self)
|
|
|
|
def setWeight(self, weight):
|
|
r"""setWeight(StationMagnitudeContribution self, Seiscomp::Core::Optional< double >::Impl const & weight)"""
|
|
return _datamodel.StationMagnitudeContribution_setWeight(self, weight)
|
|
|
|
def weight(self):
|
|
r"""weight(StationMagnitudeContribution self) -> double"""
|
|
return _datamodel.StationMagnitudeContribution_weight(self)
|
|
|
|
def index(self):
|
|
r"""index(StationMagnitudeContribution self) -> StationMagnitudeContributionIndex"""
|
|
return _datamodel.StationMagnitudeContribution_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(StationMagnitudeContribution self, StationMagnitudeContribution lhs) -> bool"""
|
|
return _datamodel.StationMagnitudeContribution_equalIndex(self, lhs)
|
|
|
|
def magnitude(self):
|
|
r"""magnitude(StationMagnitudeContribution self) -> Magnitude"""
|
|
return _datamodel.StationMagnitudeContribution_magnitude(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(StationMagnitudeContribution self, Object other) -> bool"""
|
|
return _datamodel.StationMagnitudeContribution_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(StationMagnitudeContribution self, PublicObject parent) -> bool"""
|
|
return _datamodel.StationMagnitudeContribution_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(StationMagnitudeContribution self, PublicObject parent) -> bool"""
|
|
return _datamodel.StationMagnitudeContribution_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(StationMagnitudeContribution self) -> bool"""
|
|
return _datamodel.StationMagnitudeContribution_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(StationMagnitudeContribution self) -> Object"""
|
|
return _datamodel.StationMagnitudeContribution_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(StationMagnitudeContribution self, Visitor visitor)"""
|
|
return _datamodel.StationMagnitudeContribution_accept(self, visitor)
|
|
|
|
# Register StationMagnitudeContribution in _datamodel:
|
|
_datamodel.StationMagnitudeContribution_swigregister(StationMagnitudeContribution)
|
|
|
|
def StationMagnitudeContribution_ClassName():
|
|
r"""StationMagnitudeContribution_ClassName() -> char const *"""
|
|
return _datamodel.StationMagnitudeContribution_ClassName()
|
|
|
|
def StationMagnitudeContribution_TypeInfo():
|
|
r"""StationMagnitudeContribution_TypeInfo() -> RTTI"""
|
|
return _datamodel.StationMagnitudeContribution_TypeInfo()
|
|
|
|
def StationMagnitudeContribution_Cast(*args):
|
|
r"""
|
|
StationMagnitudeContribution_Cast(BaseObject o) -> StationMagnitudeContribution
|
|
StationMagnitudeContribution_Cast(Seiscomp::Core::BaseObjectPtr o) -> StationMagnitudeContribution
|
|
"""
|
|
return _datamodel.StationMagnitudeContribution_Cast(*args)
|
|
|
|
def StationMagnitudeContribution_ConstCast(*args):
|
|
r"""
|
|
StationMagnitudeContribution_ConstCast(BaseObject o) -> StationMagnitudeContribution
|
|
StationMagnitudeContribution_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationMagnitudeContribution
|
|
"""
|
|
return _datamodel.StationMagnitudeContribution_ConstCast(*args)
|
|
|
|
def StationMagnitudeContribution_Meta():
|
|
r"""StationMagnitudeContribution_Meta() -> MetaObject"""
|
|
return _datamodel.StationMagnitudeContribution_Meta()
|
|
|
|
class Magnitude(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Magnitude 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 _datamodel.Magnitude_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Magnitude_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Magnitude self) -> char const *"""
|
|
return _datamodel.Magnitude_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Magnitude self) -> RTTI"""
|
|
return _datamodel.Magnitude_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Magnitude
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Magnitude
|
|
"""
|
|
return _datamodel.Magnitude_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Magnitude
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Magnitude
|
|
"""
|
|
return _datamodel.Magnitude_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Magnitude self, GenericArchive ar)"""
|
|
return _datamodel.Magnitude_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Magnitude_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Magnitude self) -> MetaObject"""
|
|
return _datamodel.Magnitude_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Magnitude self, Magnitude other) -> Magnitude
|
|
__init__(Magnitude self, std::string const & publicID) -> Magnitude
|
|
"""
|
|
_datamodel.Magnitude_swiginit(self, _datamodel.new_Magnitude(*args))
|
|
__swig_destroy__ = _datamodel.delete_Magnitude
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> Magnitude
|
|
Create(std::string const & publicID) -> Magnitude
|
|
"""
|
|
return _datamodel.Magnitude_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> Magnitude"""
|
|
return _datamodel.Magnitude_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Magnitude self, Magnitude other) -> bool"""
|
|
return _datamodel.Magnitude___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Magnitude self, Magnitude other) -> bool"""
|
|
return _datamodel.Magnitude___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Magnitude self, Magnitude other) -> bool"""
|
|
return _datamodel.Magnitude_equal(self, other)
|
|
|
|
def setMagnitude(self, magnitude):
|
|
r"""setMagnitude(Magnitude self, RealQuantity magnitude)"""
|
|
return _datamodel.Magnitude_setMagnitude(self, magnitude)
|
|
|
|
def magnitude(self, *args):
|
|
r"""
|
|
magnitude(Magnitude self) -> RealQuantity
|
|
magnitude(Magnitude self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Magnitude_magnitude(self, *args)
|
|
|
|
def setType(self, type):
|
|
r"""setType(Magnitude self, std::string const & type)"""
|
|
return _datamodel.Magnitude_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(Magnitude self) -> std::string const &"""
|
|
return _datamodel.Magnitude_type(self)
|
|
|
|
def setOriginID(self, originID):
|
|
r"""setOriginID(Magnitude self, std::string const & originID)"""
|
|
return _datamodel.Magnitude_setOriginID(self, originID)
|
|
|
|
def originID(self):
|
|
r"""originID(Magnitude self) -> std::string const &"""
|
|
return _datamodel.Magnitude_originID(self)
|
|
|
|
def setMethodID(self, methodID):
|
|
r"""setMethodID(Magnitude self, std::string const & methodID)"""
|
|
return _datamodel.Magnitude_setMethodID(self, methodID)
|
|
|
|
def methodID(self):
|
|
r"""methodID(Magnitude self) -> std::string const &"""
|
|
return _datamodel.Magnitude_methodID(self)
|
|
|
|
def setStationCount(self, stationCount):
|
|
r"""setStationCount(Magnitude self, Seiscomp::Core::Optional< int >::Impl const & stationCount)"""
|
|
return _datamodel.Magnitude_setStationCount(self, stationCount)
|
|
|
|
def stationCount(self):
|
|
r"""stationCount(Magnitude self) -> int"""
|
|
return _datamodel.Magnitude_stationCount(self)
|
|
|
|
def setAzimuthalGap(self, azimuthalGap):
|
|
r"""setAzimuthalGap(Magnitude self, Seiscomp::Core::Optional< double >::Impl const & azimuthalGap)"""
|
|
return _datamodel.Magnitude_setAzimuthalGap(self, azimuthalGap)
|
|
|
|
def azimuthalGap(self):
|
|
r"""azimuthalGap(Magnitude self) -> double"""
|
|
return _datamodel.Magnitude_azimuthalGap(self)
|
|
|
|
def setEvaluationStatus(self, evaluationStatus):
|
|
r"""setEvaluationStatus(Magnitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationStatus >::Impl const & evaluationStatus)"""
|
|
return _datamodel.Magnitude_setEvaluationStatus(self, evaluationStatus)
|
|
|
|
def evaluationStatus(self):
|
|
r"""evaluationStatus(Magnitude self) -> Seiscomp::DataModel::EvaluationStatus"""
|
|
return _datamodel.Magnitude_evaluationStatus(self)
|
|
|
|
def setCreationInfo(self, creationInfo):
|
|
r"""setCreationInfo(Magnitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
|
|
return _datamodel.Magnitude_setCreationInfo(self, creationInfo)
|
|
|
|
def creationInfo(self, *args):
|
|
r"""
|
|
creationInfo(Magnitude self) -> CreationInfo
|
|
creationInfo(Magnitude self) -> CreationInfo
|
|
"""
|
|
return _datamodel.Magnitude_creationInfo(self, *args)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(Magnitude self, Comment obj) -> bool
|
|
add(Magnitude self, StationMagnitudeContribution obj) -> bool
|
|
"""
|
|
return _datamodel.Magnitude_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(Magnitude self, Comment obj) -> bool
|
|
remove(Magnitude self, StationMagnitudeContribution obj) -> bool
|
|
"""
|
|
return _datamodel.Magnitude_remove(self, *args)
|
|
|
|
def removeComment(self, *args):
|
|
r"""
|
|
removeComment(Magnitude self, size_t i) -> bool
|
|
removeComment(Magnitude self, CommentIndex i) -> bool
|
|
"""
|
|
return _datamodel.Magnitude_removeComment(self, *args)
|
|
|
|
def removeStationMagnitudeContribution(self, *args):
|
|
r"""
|
|
removeStationMagnitudeContribution(Magnitude self, size_t i) -> bool
|
|
removeStationMagnitudeContribution(Magnitude self, StationMagnitudeContributionIndex i) -> bool
|
|
"""
|
|
return _datamodel.Magnitude_removeStationMagnitudeContribution(self, *args)
|
|
|
|
def commentCount(self):
|
|
r"""commentCount(Magnitude self) -> size_t"""
|
|
return _datamodel.Magnitude_commentCount(self)
|
|
|
|
def stationMagnitudeContributionCount(self):
|
|
r"""stationMagnitudeContributionCount(Magnitude self) -> size_t"""
|
|
return _datamodel.Magnitude_stationMagnitudeContributionCount(self)
|
|
|
|
def comment(self, *args):
|
|
r"""
|
|
comment(Magnitude self, size_t i) -> Comment
|
|
comment(Magnitude self, CommentIndex i) -> Comment
|
|
"""
|
|
return _datamodel.Magnitude_comment(self, *args)
|
|
|
|
def stationMagnitudeContribution(self, *args):
|
|
r"""
|
|
stationMagnitudeContribution(Magnitude self, size_t i) -> StationMagnitudeContribution
|
|
stationMagnitudeContribution(Magnitude self, StationMagnitudeContributionIndex i) -> StationMagnitudeContribution
|
|
"""
|
|
return _datamodel.Magnitude_stationMagnitudeContribution(self, *args)
|
|
|
|
def origin(self):
|
|
r"""origin(Magnitude self) -> Origin"""
|
|
return _datamodel.Magnitude_origin(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Magnitude self, Object other) -> bool"""
|
|
return _datamodel.Magnitude_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Magnitude self, PublicObject parent) -> bool"""
|
|
return _datamodel.Magnitude_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Magnitude self, PublicObject parent) -> bool"""
|
|
return _datamodel.Magnitude_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Magnitude self) -> bool"""
|
|
return _datamodel.Magnitude_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Magnitude self) -> Object"""
|
|
return _datamodel.Magnitude_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Magnitude self, Object child) -> bool"""
|
|
return _datamodel.Magnitude_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Magnitude self, Visitor visitor)"""
|
|
return _datamodel.Magnitude_accept(self, visitor)
|
|
|
|
# Register Magnitude in _datamodel:
|
|
_datamodel.Magnitude_swigregister(Magnitude)
|
|
|
|
def Magnitude_ClassName():
|
|
r"""Magnitude_ClassName() -> char const *"""
|
|
return _datamodel.Magnitude_ClassName()
|
|
|
|
def Magnitude_TypeInfo():
|
|
r"""Magnitude_TypeInfo() -> RTTI"""
|
|
return _datamodel.Magnitude_TypeInfo()
|
|
|
|
def Magnitude_Cast(*args):
|
|
r"""
|
|
Magnitude_Cast(BaseObject o) -> Magnitude
|
|
Magnitude_Cast(Seiscomp::Core::BaseObjectPtr o) -> Magnitude
|
|
"""
|
|
return _datamodel.Magnitude_Cast(*args)
|
|
|
|
def Magnitude_ConstCast(*args):
|
|
r"""
|
|
Magnitude_ConstCast(BaseObject o) -> Magnitude
|
|
Magnitude_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Magnitude
|
|
"""
|
|
return _datamodel.Magnitude_ConstCast(*args)
|
|
|
|
def Magnitude_Meta():
|
|
r"""Magnitude_Meta() -> MetaObject"""
|
|
return _datamodel.Magnitude_Meta()
|
|
|
|
def Magnitude_Create(*args):
|
|
r"""
|
|
Magnitude_Create() -> Magnitude
|
|
Magnitude_Create(std::string const & publicID) -> Magnitude
|
|
"""
|
|
return _datamodel.Magnitude_Create(*args)
|
|
|
|
def Magnitude_Find(publicID):
|
|
r"""Magnitude_Find(std::string const & publicID) -> Magnitude"""
|
|
return _datamodel.Magnitude_Find(publicID)
|
|
|
|
class StationMagnitude(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::StationMagnitude 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 _datamodel.StationMagnitude_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.StationMagnitude_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(StationMagnitude self) -> char const *"""
|
|
return _datamodel.StationMagnitude_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(StationMagnitude self) -> RTTI"""
|
|
return _datamodel.StationMagnitude_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> StationMagnitude
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> StationMagnitude
|
|
"""
|
|
return _datamodel.StationMagnitude_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> StationMagnitude
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationMagnitude
|
|
"""
|
|
return _datamodel.StationMagnitude_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(StationMagnitude self, GenericArchive ar)"""
|
|
return _datamodel.StationMagnitude_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.StationMagnitude_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(StationMagnitude self) -> MetaObject"""
|
|
return _datamodel.StationMagnitude_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(StationMagnitude self, StationMagnitude other) -> StationMagnitude
|
|
__init__(StationMagnitude self, std::string const & publicID) -> StationMagnitude
|
|
"""
|
|
_datamodel.StationMagnitude_swiginit(self, _datamodel.new_StationMagnitude(*args))
|
|
__swig_destroy__ = _datamodel.delete_StationMagnitude
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> StationMagnitude
|
|
Create(std::string const & publicID) -> StationMagnitude
|
|
"""
|
|
return _datamodel.StationMagnitude_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> StationMagnitude"""
|
|
return _datamodel.StationMagnitude_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(StationMagnitude self, StationMagnitude other) -> bool"""
|
|
return _datamodel.StationMagnitude___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(StationMagnitude self, StationMagnitude other) -> bool"""
|
|
return _datamodel.StationMagnitude___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(StationMagnitude self, StationMagnitude other) -> bool"""
|
|
return _datamodel.StationMagnitude_equal(self, other)
|
|
|
|
def setOriginID(self, originID):
|
|
r"""setOriginID(StationMagnitude self, std::string const & originID)"""
|
|
return _datamodel.StationMagnitude_setOriginID(self, originID)
|
|
|
|
def originID(self):
|
|
r"""originID(StationMagnitude self) -> std::string const &"""
|
|
return _datamodel.StationMagnitude_originID(self)
|
|
|
|
def setMagnitude(self, magnitude):
|
|
r"""setMagnitude(StationMagnitude self, RealQuantity magnitude)"""
|
|
return _datamodel.StationMagnitude_setMagnitude(self, magnitude)
|
|
|
|
def magnitude(self, *args):
|
|
r"""
|
|
magnitude(StationMagnitude self) -> RealQuantity
|
|
magnitude(StationMagnitude self) -> RealQuantity
|
|
"""
|
|
return _datamodel.StationMagnitude_magnitude(self, *args)
|
|
|
|
def setType(self, type):
|
|
r"""setType(StationMagnitude self, std::string const & type)"""
|
|
return _datamodel.StationMagnitude_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(StationMagnitude self) -> std::string const &"""
|
|
return _datamodel.StationMagnitude_type(self)
|
|
|
|
def setAmplitudeID(self, amplitudeID):
|
|
r"""setAmplitudeID(StationMagnitude self, std::string const & amplitudeID)"""
|
|
return _datamodel.StationMagnitude_setAmplitudeID(self, amplitudeID)
|
|
|
|
def amplitudeID(self):
|
|
r"""amplitudeID(StationMagnitude self) -> std::string const &"""
|
|
return _datamodel.StationMagnitude_amplitudeID(self)
|
|
|
|
def setMethodID(self, methodID):
|
|
r"""setMethodID(StationMagnitude self, std::string const & methodID)"""
|
|
return _datamodel.StationMagnitude_setMethodID(self, methodID)
|
|
|
|
def methodID(self):
|
|
r"""methodID(StationMagnitude self) -> std::string const &"""
|
|
return _datamodel.StationMagnitude_methodID(self)
|
|
|
|
def setWaveformID(self, waveformID):
|
|
r"""setWaveformID(StationMagnitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::WaveformStreamID >::Impl const & waveformID)"""
|
|
return _datamodel.StationMagnitude_setWaveformID(self, waveformID)
|
|
|
|
def waveformID(self, *args):
|
|
r"""
|
|
waveformID(StationMagnitude self) -> WaveformStreamID
|
|
waveformID(StationMagnitude self) -> WaveformStreamID
|
|
"""
|
|
return _datamodel.StationMagnitude_waveformID(self, *args)
|
|
|
|
def setPassedQC(self, passedQC):
|
|
r"""setPassedQC(StationMagnitude self, Seiscomp::Core::Optional< bool >::Impl const & passedQC)"""
|
|
return _datamodel.StationMagnitude_setPassedQC(self, passedQC)
|
|
|
|
def passedQC(self):
|
|
r"""passedQC(StationMagnitude self) -> bool"""
|
|
return _datamodel.StationMagnitude_passedQC(self)
|
|
|
|
def setCreationInfo(self, creationInfo):
|
|
r"""setCreationInfo(StationMagnitude self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
|
|
return _datamodel.StationMagnitude_setCreationInfo(self, creationInfo)
|
|
|
|
def creationInfo(self, *args):
|
|
r"""
|
|
creationInfo(StationMagnitude self) -> CreationInfo
|
|
creationInfo(StationMagnitude self) -> CreationInfo
|
|
"""
|
|
return _datamodel.StationMagnitude_creationInfo(self, *args)
|
|
|
|
def add(self, obj):
|
|
r"""add(StationMagnitude self, Comment obj) -> bool"""
|
|
return _datamodel.StationMagnitude_add(self, obj)
|
|
|
|
def remove(self, obj):
|
|
r"""remove(StationMagnitude self, Comment obj) -> bool"""
|
|
return _datamodel.StationMagnitude_remove(self, obj)
|
|
|
|
def removeComment(self, *args):
|
|
r"""
|
|
removeComment(StationMagnitude self, size_t i) -> bool
|
|
removeComment(StationMagnitude self, CommentIndex i) -> bool
|
|
"""
|
|
return _datamodel.StationMagnitude_removeComment(self, *args)
|
|
|
|
def commentCount(self):
|
|
r"""commentCount(StationMagnitude self) -> size_t"""
|
|
return _datamodel.StationMagnitude_commentCount(self)
|
|
|
|
def comment(self, *args):
|
|
r"""
|
|
comment(StationMagnitude self, size_t i) -> Comment
|
|
comment(StationMagnitude self, CommentIndex i) -> Comment
|
|
"""
|
|
return _datamodel.StationMagnitude_comment(self, *args)
|
|
|
|
def origin(self):
|
|
r"""origin(StationMagnitude self) -> Origin"""
|
|
return _datamodel.StationMagnitude_origin(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(StationMagnitude self, Object other) -> bool"""
|
|
return _datamodel.StationMagnitude_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(StationMagnitude self, PublicObject parent) -> bool"""
|
|
return _datamodel.StationMagnitude_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(StationMagnitude self, PublicObject parent) -> bool"""
|
|
return _datamodel.StationMagnitude_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(StationMagnitude self) -> bool"""
|
|
return _datamodel.StationMagnitude_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(StationMagnitude self) -> Object"""
|
|
return _datamodel.StationMagnitude_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(StationMagnitude self, Object child) -> bool"""
|
|
return _datamodel.StationMagnitude_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(StationMagnitude self, Visitor visitor)"""
|
|
return _datamodel.StationMagnitude_accept(self, visitor)
|
|
|
|
# Register StationMagnitude in _datamodel:
|
|
_datamodel.StationMagnitude_swigregister(StationMagnitude)
|
|
|
|
def StationMagnitude_ClassName():
|
|
r"""StationMagnitude_ClassName() -> char const *"""
|
|
return _datamodel.StationMagnitude_ClassName()
|
|
|
|
def StationMagnitude_TypeInfo():
|
|
r"""StationMagnitude_TypeInfo() -> RTTI"""
|
|
return _datamodel.StationMagnitude_TypeInfo()
|
|
|
|
def StationMagnitude_Cast(*args):
|
|
r"""
|
|
StationMagnitude_Cast(BaseObject o) -> StationMagnitude
|
|
StationMagnitude_Cast(Seiscomp::Core::BaseObjectPtr o) -> StationMagnitude
|
|
"""
|
|
return _datamodel.StationMagnitude_Cast(*args)
|
|
|
|
def StationMagnitude_ConstCast(*args):
|
|
r"""
|
|
StationMagnitude_ConstCast(BaseObject o) -> StationMagnitude
|
|
StationMagnitude_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationMagnitude
|
|
"""
|
|
return _datamodel.StationMagnitude_ConstCast(*args)
|
|
|
|
def StationMagnitude_Meta():
|
|
r"""StationMagnitude_Meta() -> MetaObject"""
|
|
return _datamodel.StationMagnitude_Meta()
|
|
|
|
def StationMagnitude_Create(*args):
|
|
r"""
|
|
StationMagnitude_Create() -> StationMagnitude
|
|
StationMagnitude_Create(std::string const & publicID) -> StationMagnitude
|
|
"""
|
|
return _datamodel.StationMagnitude_Create(*args)
|
|
|
|
def StationMagnitude_Find(publicID):
|
|
r"""StationMagnitude_Find(std::string const & publicID) -> StationMagnitude"""
|
|
return _datamodel.StationMagnitude_Find(publicID)
|
|
|
|
class Pick(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Pick 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 _datamodel.Pick_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Pick_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Pick self) -> char const *"""
|
|
return _datamodel.Pick_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Pick self) -> RTTI"""
|
|
return _datamodel.Pick_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Pick
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Pick
|
|
"""
|
|
return _datamodel.Pick_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Pick
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Pick
|
|
"""
|
|
return _datamodel.Pick_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Pick self, GenericArchive ar)"""
|
|
return _datamodel.Pick_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Pick_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Pick self) -> MetaObject"""
|
|
return _datamodel.Pick_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Pick self, Pick other) -> Pick
|
|
__init__(Pick self, std::string const & publicID) -> Pick
|
|
"""
|
|
_datamodel.Pick_swiginit(self, _datamodel.new_Pick(*args))
|
|
__swig_destroy__ = _datamodel.delete_Pick
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> Pick
|
|
Create(std::string const & publicID) -> Pick
|
|
"""
|
|
return _datamodel.Pick_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> Pick"""
|
|
return _datamodel.Pick_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Pick self, Pick other) -> bool"""
|
|
return _datamodel.Pick___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Pick self, Pick other) -> bool"""
|
|
return _datamodel.Pick___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Pick self, Pick other) -> bool"""
|
|
return _datamodel.Pick_equal(self, other)
|
|
|
|
def setTime(self, time):
|
|
r"""setTime(Pick self, TimeQuantity time)"""
|
|
return _datamodel.Pick_setTime(self, time)
|
|
|
|
def time(self, *args):
|
|
r"""
|
|
time(Pick self) -> TimeQuantity
|
|
time(Pick self) -> TimeQuantity
|
|
"""
|
|
return _datamodel.Pick_time(self, *args)
|
|
|
|
def setWaveformID(self, waveformID):
|
|
r"""setWaveformID(Pick self, WaveformStreamID waveformID)"""
|
|
return _datamodel.Pick_setWaveformID(self, waveformID)
|
|
|
|
def waveformID(self, *args):
|
|
r"""
|
|
waveformID(Pick self) -> WaveformStreamID
|
|
waveformID(Pick self) -> WaveformStreamID
|
|
"""
|
|
return _datamodel.Pick_waveformID(self, *args)
|
|
|
|
def setFilterID(self, filterID):
|
|
r"""setFilterID(Pick self, std::string const & filterID)"""
|
|
return _datamodel.Pick_setFilterID(self, filterID)
|
|
|
|
def filterID(self):
|
|
r"""filterID(Pick self) -> std::string const &"""
|
|
return _datamodel.Pick_filterID(self)
|
|
|
|
def setMethodID(self, methodID):
|
|
r"""setMethodID(Pick self, std::string const & methodID)"""
|
|
return _datamodel.Pick_setMethodID(self, methodID)
|
|
|
|
def methodID(self):
|
|
r"""methodID(Pick self) -> std::string const &"""
|
|
return _datamodel.Pick_methodID(self)
|
|
|
|
def setHorizontalSlowness(self, horizontalSlowness):
|
|
r"""setHorizontalSlowness(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity >::Impl const & horizontalSlowness)"""
|
|
return _datamodel.Pick_setHorizontalSlowness(self, horizontalSlowness)
|
|
|
|
def horizontalSlowness(self, *args):
|
|
r"""
|
|
horizontalSlowness(Pick self) -> RealQuantity
|
|
horizontalSlowness(Pick self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Pick_horizontalSlowness(self, *args)
|
|
|
|
def setBackazimuth(self, backazimuth):
|
|
r"""setBackazimuth(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity >::Impl const & backazimuth)"""
|
|
return _datamodel.Pick_setBackazimuth(self, backazimuth)
|
|
|
|
def backazimuth(self, *args):
|
|
r"""
|
|
backazimuth(Pick self) -> RealQuantity
|
|
backazimuth(Pick self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Pick_backazimuth(self, *args)
|
|
|
|
def setSlownessMethodID(self, slownessMethodID):
|
|
r"""setSlownessMethodID(Pick self, std::string const & slownessMethodID)"""
|
|
return _datamodel.Pick_setSlownessMethodID(self, slownessMethodID)
|
|
|
|
def slownessMethodID(self):
|
|
r"""slownessMethodID(Pick self) -> std::string const &"""
|
|
return _datamodel.Pick_slownessMethodID(self)
|
|
|
|
def setOnset(self, onset):
|
|
r"""setOnset(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::PickOnset >::Impl const & onset)"""
|
|
return _datamodel.Pick_setOnset(self, onset)
|
|
|
|
def onset(self):
|
|
r"""onset(Pick self) -> Seiscomp::DataModel::PickOnset"""
|
|
return _datamodel.Pick_onset(self)
|
|
|
|
def setPhaseHint(self, phaseHint):
|
|
r"""setPhaseHint(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::Phase >::Impl const & phaseHint)"""
|
|
return _datamodel.Pick_setPhaseHint(self, phaseHint)
|
|
|
|
def phaseHint(self, *args):
|
|
r"""
|
|
phaseHint(Pick self) -> Phase
|
|
phaseHint(Pick self) -> Phase
|
|
"""
|
|
return _datamodel.Pick_phaseHint(self, *args)
|
|
|
|
def setPolarity(self, polarity):
|
|
r"""setPolarity(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::PickPolarity >::Impl const & polarity)"""
|
|
return _datamodel.Pick_setPolarity(self, polarity)
|
|
|
|
def polarity(self):
|
|
r"""polarity(Pick self) -> Seiscomp::DataModel::PickPolarity"""
|
|
return _datamodel.Pick_polarity(self)
|
|
|
|
def setEvaluationMode(self, evaluationMode):
|
|
r"""setEvaluationMode(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationMode >::Impl const & evaluationMode)"""
|
|
return _datamodel.Pick_setEvaluationMode(self, evaluationMode)
|
|
|
|
def evaluationMode(self):
|
|
r"""evaluationMode(Pick self) -> Seiscomp::DataModel::EvaluationMode"""
|
|
return _datamodel.Pick_evaluationMode(self)
|
|
|
|
def setEvaluationStatus(self, evaluationStatus):
|
|
r"""setEvaluationStatus(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationStatus >::Impl const & evaluationStatus)"""
|
|
return _datamodel.Pick_setEvaluationStatus(self, evaluationStatus)
|
|
|
|
def evaluationStatus(self):
|
|
r"""evaluationStatus(Pick self) -> Seiscomp::DataModel::EvaluationStatus"""
|
|
return _datamodel.Pick_evaluationStatus(self)
|
|
|
|
def setCreationInfo(self, creationInfo):
|
|
r"""setCreationInfo(Pick self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
|
|
return _datamodel.Pick_setCreationInfo(self, creationInfo)
|
|
|
|
def creationInfo(self, *args):
|
|
r"""
|
|
creationInfo(Pick self) -> CreationInfo
|
|
creationInfo(Pick self) -> CreationInfo
|
|
"""
|
|
return _datamodel.Pick_creationInfo(self, *args)
|
|
|
|
def add(self, obj):
|
|
r"""add(Pick self, Comment obj) -> bool"""
|
|
return _datamodel.Pick_add(self, obj)
|
|
|
|
def remove(self, obj):
|
|
r"""remove(Pick self, Comment obj) -> bool"""
|
|
return _datamodel.Pick_remove(self, obj)
|
|
|
|
def removeComment(self, *args):
|
|
r"""
|
|
removeComment(Pick self, size_t i) -> bool
|
|
removeComment(Pick self, CommentIndex i) -> bool
|
|
"""
|
|
return _datamodel.Pick_removeComment(self, *args)
|
|
|
|
def commentCount(self):
|
|
r"""commentCount(Pick self) -> size_t"""
|
|
return _datamodel.Pick_commentCount(self)
|
|
|
|
def comment(self, *args):
|
|
r"""
|
|
comment(Pick self, size_t i) -> Comment
|
|
comment(Pick self, CommentIndex i) -> Comment
|
|
"""
|
|
return _datamodel.Pick_comment(self, *args)
|
|
|
|
def eventParameters(self):
|
|
r"""eventParameters(Pick self) -> EventParameters"""
|
|
return _datamodel.Pick_eventParameters(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Pick self, Object other) -> bool"""
|
|
return _datamodel.Pick_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Pick self, PublicObject parent) -> bool"""
|
|
return _datamodel.Pick_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Pick self, PublicObject parent) -> bool"""
|
|
return _datamodel.Pick_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Pick self) -> bool"""
|
|
return _datamodel.Pick_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Pick self) -> Object"""
|
|
return _datamodel.Pick_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Pick self, Object child) -> bool"""
|
|
return _datamodel.Pick_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Pick self, Visitor visitor)"""
|
|
return _datamodel.Pick_accept(self, visitor)
|
|
|
|
# Register Pick in _datamodel:
|
|
_datamodel.Pick_swigregister(Pick)
|
|
|
|
def Pick_ClassName():
|
|
r"""Pick_ClassName() -> char const *"""
|
|
return _datamodel.Pick_ClassName()
|
|
|
|
def Pick_TypeInfo():
|
|
r"""Pick_TypeInfo() -> RTTI"""
|
|
return _datamodel.Pick_TypeInfo()
|
|
|
|
def Pick_Cast(*args):
|
|
r"""
|
|
Pick_Cast(BaseObject o) -> Pick
|
|
Pick_Cast(Seiscomp::Core::BaseObjectPtr o) -> Pick
|
|
"""
|
|
return _datamodel.Pick_Cast(*args)
|
|
|
|
def Pick_ConstCast(*args):
|
|
r"""
|
|
Pick_ConstCast(BaseObject o) -> Pick
|
|
Pick_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Pick
|
|
"""
|
|
return _datamodel.Pick_ConstCast(*args)
|
|
|
|
def Pick_Meta():
|
|
r"""Pick_Meta() -> MetaObject"""
|
|
return _datamodel.Pick_Meta()
|
|
|
|
def Pick_Create(*args):
|
|
r"""
|
|
Pick_Create() -> Pick
|
|
Pick_Create(std::string const & publicID) -> Pick
|
|
"""
|
|
return _datamodel.Pick_Create(*args)
|
|
|
|
def Pick_Find(publicID):
|
|
r"""Pick_Find(std::string const & publicID) -> Pick"""
|
|
return _datamodel.Pick_Find(publicID)
|
|
|
|
class OriginReferenceIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::OriginReferenceIndex 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__(OriginReferenceIndex self) -> OriginReferenceIndex
|
|
__init__(OriginReferenceIndex self, std::string const & originID) -> OriginReferenceIndex
|
|
__init__(OriginReferenceIndex self, OriginReferenceIndex arg2) -> OriginReferenceIndex
|
|
"""
|
|
_datamodel.OriginReferenceIndex_swiginit(self, _datamodel.new_OriginReferenceIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(OriginReferenceIndex self, OriginReferenceIndex arg2) -> bool"""
|
|
return _datamodel.OriginReferenceIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(OriginReferenceIndex self, OriginReferenceIndex arg2) -> bool"""
|
|
return _datamodel.OriginReferenceIndex___ne__(self, arg2)
|
|
originID = property(_datamodel.OriginReferenceIndex_originID_get, _datamodel.OriginReferenceIndex_originID_set, doc=r"""originID : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_OriginReferenceIndex
|
|
|
|
# Register OriginReferenceIndex in _datamodel:
|
|
_datamodel.OriginReferenceIndex_swigregister(OriginReferenceIndex)
|
|
|
|
class OriginReference(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::OriginReference 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 _datamodel.OriginReference_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.OriginReference_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(OriginReference self) -> char const *"""
|
|
return _datamodel.OriginReference_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(OriginReference self) -> RTTI"""
|
|
return _datamodel.OriginReference_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> OriginReference
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> OriginReference
|
|
"""
|
|
return _datamodel.OriginReference_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> OriginReference
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> OriginReference
|
|
"""
|
|
return _datamodel.OriginReference_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(OriginReference self, GenericArchive ar)"""
|
|
return _datamodel.OriginReference_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.OriginReference_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(OriginReference self) -> MetaObject"""
|
|
return _datamodel.OriginReference_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(OriginReference self) -> OriginReference
|
|
__init__(OriginReference self, OriginReference other) -> OriginReference
|
|
__init__(OriginReference self, std::string const & originID) -> OriginReference
|
|
"""
|
|
_datamodel.OriginReference_swiginit(self, _datamodel.new_OriginReference(*args))
|
|
__swig_destroy__ = _datamodel.delete_OriginReference
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(OriginReference self, OriginReference other) -> bool"""
|
|
return _datamodel.OriginReference___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(OriginReference self, OriginReference other) -> bool"""
|
|
return _datamodel.OriginReference___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(OriginReference self, OriginReference other) -> bool"""
|
|
return _datamodel.OriginReference_equal(self, other)
|
|
|
|
def setOriginID(self, originID):
|
|
r"""setOriginID(OriginReference self, std::string const & originID)"""
|
|
return _datamodel.OriginReference_setOriginID(self, originID)
|
|
|
|
def originID(self):
|
|
r"""originID(OriginReference self) -> std::string const &"""
|
|
return _datamodel.OriginReference_originID(self)
|
|
|
|
def index(self):
|
|
r"""index(OriginReference self) -> OriginReferenceIndex"""
|
|
return _datamodel.OriginReference_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(OriginReference self, OriginReference lhs) -> bool"""
|
|
return _datamodel.OriginReference_equalIndex(self, lhs)
|
|
|
|
def event(self):
|
|
r"""event(OriginReference self) -> Event"""
|
|
return _datamodel.OriginReference_event(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(OriginReference self, Object other) -> bool"""
|
|
return _datamodel.OriginReference_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(OriginReference self, PublicObject parent) -> bool"""
|
|
return _datamodel.OriginReference_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(OriginReference self, PublicObject parent) -> bool"""
|
|
return _datamodel.OriginReference_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(OriginReference self) -> bool"""
|
|
return _datamodel.OriginReference_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(OriginReference self) -> Object"""
|
|
return _datamodel.OriginReference_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(OriginReference self, Visitor visitor)"""
|
|
return _datamodel.OriginReference_accept(self, visitor)
|
|
|
|
# Register OriginReference in _datamodel:
|
|
_datamodel.OriginReference_swigregister(OriginReference)
|
|
|
|
def OriginReference_ClassName():
|
|
r"""OriginReference_ClassName() -> char const *"""
|
|
return _datamodel.OriginReference_ClassName()
|
|
|
|
def OriginReference_TypeInfo():
|
|
r"""OriginReference_TypeInfo() -> RTTI"""
|
|
return _datamodel.OriginReference_TypeInfo()
|
|
|
|
def OriginReference_Cast(*args):
|
|
r"""
|
|
OriginReference_Cast(BaseObject o) -> OriginReference
|
|
OriginReference_Cast(Seiscomp::Core::BaseObjectPtr o) -> OriginReference
|
|
"""
|
|
return _datamodel.OriginReference_Cast(*args)
|
|
|
|
def OriginReference_ConstCast(*args):
|
|
r"""
|
|
OriginReference_ConstCast(BaseObject o) -> OriginReference
|
|
OriginReference_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> OriginReference
|
|
"""
|
|
return _datamodel.OriginReference_ConstCast(*args)
|
|
|
|
def OriginReference_Meta():
|
|
r"""OriginReference_Meta() -> MetaObject"""
|
|
return _datamodel.OriginReference_Meta()
|
|
|
|
class FocalMechanismReferenceIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::FocalMechanismReferenceIndex 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__(FocalMechanismReferenceIndex self) -> FocalMechanismReferenceIndex
|
|
__init__(FocalMechanismReferenceIndex self, std::string const & focalMechanismID) -> FocalMechanismReferenceIndex
|
|
__init__(FocalMechanismReferenceIndex self, FocalMechanismReferenceIndex arg2) -> FocalMechanismReferenceIndex
|
|
"""
|
|
_datamodel.FocalMechanismReferenceIndex_swiginit(self, _datamodel.new_FocalMechanismReferenceIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(FocalMechanismReferenceIndex self, FocalMechanismReferenceIndex arg2) -> bool"""
|
|
return _datamodel.FocalMechanismReferenceIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(FocalMechanismReferenceIndex self, FocalMechanismReferenceIndex arg2) -> bool"""
|
|
return _datamodel.FocalMechanismReferenceIndex___ne__(self, arg2)
|
|
focalMechanismID = property(_datamodel.FocalMechanismReferenceIndex_focalMechanismID_get, _datamodel.FocalMechanismReferenceIndex_focalMechanismID_set, doc=r"""focalMechanismID : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_FocalMechanismReferenceIndex
|
|
|
|
# Register FocalMechanismReferenceIndex in _datamodel:
|
|
_datamodel.FocalMechanismReferenceIndex_swigregister(FocalMechanismReferenceIndex)
|
|
|
|
class FocalMechanismReference(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::FocalMechanismReference 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 _datamodel.FocalMechanismReference_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.FocalMechanismReference_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(FocalMechanismReference self) -> char const *"""
|
|
return _datamodel.FocalMechanismReference_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(FocalMechanismReference self) -> RTTI"""
|
|
return _datamodel.FocalMechanismReference_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> FocalMechanismReference
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> FocalMechanismReference
|
|
"""
|
|
return _datamodel.FocalMechanismReference_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> FocalMechanismReference
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> FocalMechanismReference
|
|
"""
|
|
return _datamodel.FocalMechanismReference_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(FocalMechanismReference self, GenericArchive ar)"""
|
|
return _datamodel.FocalMechanismReference_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.FocalMechanismReference_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(FocalMechanismReference self) -> MetaObject"""
|
|
return _datamodel.FocalMechanismReference_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(FocalMechanismReference self) -> FocalMechanismReference
|
|
__init__(FocalMechanismReference self, FocalMechanismReference other) -> FocalMechanismReference
|
|
__init__(FocalMechanismReference self, std::string const & focalMechanismID) -> FocalMechanismReference
|
|
"""
|
|
_datamodel.FocalMechanismReference_swiginit(self, _datamodel.new_FocalMechanismReference(*args))
|
|
__swig_destroy__ = _datamodel.delete_FocalMechanismReference
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(FocalMechanismReference self, FocalMechanismReference other) -> bool"""
|
|
return _datamodel.FocalMechanismReference___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(FocalMechanismReference self, FocalMechanismReference other) -> bool"""
|
|
return _datamodel.FocalMechanismReference___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(FocalMechanismReference self, FocalMechanismReference other) -> bool"""
|
|
return _datamodel.FocalMechanismReference_equal(self, other)
|
|
|
|
def setFocalMechanismID(self, focalMechanismID):
|
|
r"""setFocalMechanismID(FocalMechanismReference self, std::string const & focalMechanismID)"""
|
|
return _datamodel.FocalMechanismReference_setFocalMechanismID(self, focalMechanismID)
|
|
|
|
def focalMechanismID(self):
|
|
r"""focalMechanismID(FocalMechanismReference self) -> std::string const &"""
|
|
return _datamodel.FocalMechanismReference_focalMechanismID(self)
|
|
|
|
def index(self):
|
|
r"""index(FocalMechanismReference self) -> FocalMechanismReferenceIndex"""
|
|
return _datamodel.FocalMechanismReference_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(FocalMechanismReference self, FocalMechanismReference lhs) -> bool"""
|
|
return _datamodel.FocalMechanismReference_equalIndex(self, lhs)
|
|
|
|
def event(self):
|
|
r"""event(FocalMechanismReference self) -> Event"""
|
|
return _datamodel.FocalMechanismReference_event(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(FocalMechanismReference self, Object other) -> bool"""
|
|
return _datamodel.FocalMechanismReference_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(FocalMechanismReference self, PublicObject parent) -> bool"""
|
|
return _datamodel.FocalMechanismReference_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(FocalMechanismReference self, PublicObject parent) -> bool"""
|
|
return _datamodel.FocalMechanismReference_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(FocalMechanismReference self) -> bool"""
|
|
return _datamodel.FocalMechanismReference_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(FocalMechanismReference self) -> Object"""
|
|
return _datamodel.FocalMechanismReference_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(FocalMechanismReference self, Visitor visitor)"""
|
|
return _datamodel.FocalMechanismReference_accept(self, visitor)
|
|
|
|
# Register FocalMechanismReference in _datamodel:
|
|
_datamodel.FocalMechanismReference_swigregister(FocalMechanismReference)
|
|
|
|
def FocalMechanismReference_ClassName():
|
|
r"""FocalMechanismReference_ClassName() -> char const *"""
|
|
return _datamodel.FocalMechanismReference_ClassName()
|
|
|
|
def FocalMechanismReference_TypeInfo():
|
|
r"""FocalMechanismReference_TypeInfo() -> RTTI"""
|
|
return _datamodel.FocalMechanismReference_TypeInfo()
|
|
|
|
def FocalMechanismReference_Cast(*args):
|
|
r"""
|
|
FocalMechanismReference_Cast(BaseObject o) -> FocalMechanismReference
|
|
FocalMechanismReference_Cast(Seiscomp::Core::BaseObjectPtr o) -> FocalMechanismReference
|
|
"""
|
|
return _datamodel.FocalMechanismReference_Cast(*args)
|
|
|
|
def FocalMechanismReference_ConstCast(*args):
|
|
r"""
|
|
FocalMechanismReference_ConstCast(BaseObject o) -> FocalMechanismReference
|
|
FocalMechanismReference_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> FocalMechanismReference
|
|
"""
|
|
return _datamodel.FocalMechanismReference_ConstCast(*args)
|
|
|
|
def FocalMechanismReference_Meta():
|
|
r"""FocalMechanismReference_Meta() -> MetaObject"""
|
|
return _datamodel.FocalMechanismReference_Meta()
|
|
|
|
class Event(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Event 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 _datamodel.Event_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Event_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Event self) -> char const *"""
|
|
return _datamodel.Event_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Event self) -> RTTI"""
|
|
return _datamodel.Event_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Event
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Event
|
|
"""
|
|
return _datamodel.Event_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Event
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Event
|
|
"""
|
|
return _datamodel.Event_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Event self, GenericArchive ar)"""
|
|
return _datamodel.Event_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Event_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Event self) -> MetaObject"""
|
|
return _datamodel.Event_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Event self, Event other) -> Event
|
|
__init__(Event self, std::string const & publicID) -> Event
|
|
"""
|
|
_datamodel.Event_swiginit(self, _datamodel.new_Event(*args))
|
|
__swig_destroy__ = _datamodel.delete_Event
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> Event
|
|
Create(std::string const & publicID) -> Event
|
|
"""
|
|
return _datamodel.Event_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> Event"""
|
|
return _datamodel.Event_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Event self, Event other) -> bool"""
|
|
return _datamodel.Event___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Event self, Event other) -> bool"""
|
|
return _datamodel.Event___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Event self, Event other) -> bool"""
|
|
return _datamodel.Event_equal(self, other)
|
|
|
|
def setPreferredOriginID(self, preferredOriginID):
|
|
r"""setPreferredOriginID(Event self, std::string const & preferredOriginID)"""
|
|
return _datamodel.Event_setPreferredOriginID(self, preferredOriginID)
|
|
|
|
def preferredOriginID(self):
|
|
r"""preferredOriginID(Event self) -> std::string const &"""
|
|
return _datamodel.Event_preferredOriginID(self)
|
|
|
|
def setPreferredMagnitudeID(self, preferredMagnitudeID):
|
|
r"""setPreferredMagnitudeID(Event self, std::string const & preferredMagnitudeID)"""
|
|
return _datamodel.Event_setPreferredMagnitudeID(self, preferredMagnitudeID)
|
|
|
|
def preferredMagnitudeID(self):
|
|
r"""preferredMagnitudeID(Event self) -> std::string const &"""
|
|
return _datamodel.Event_preferredMagnitudeID(self)
|
|
|
|
def setPreferredFocalMechanismID(self, preferredFocalMechanismID):
|
|
r"""setPreferredFocalMechanismID(Event self, std::string const & preferredFocalMechanismID)"""
|
|
return _datamodel.Event_setPreferredFocalMechanismID(self, preferredFocalMechanismID)
|
|
|
|
def preferredFocalMechanismID(self):
|
|
r"""preferredFocalMechanismID(Event self) -> std::string const &"""
|
|
return _datamodel.Event_preferredFocalMechanismID(self)
|
|
|
|
def setType(self, type):
|
|
r"""setType(Event self, Seiscomp::Core::Optional< Seiscomp::DataModel::EventType >::Impl const & type)"""
|
|
return _datamodel.Event_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(Event self) -> Seiscomp::DataModel::EventType"""
|
|
return _datamodel.Event_type(self)
|
|
|
|
def setTypeCertainty(self, typeCertainty):
|
|
r"""setTypeCertainty(Event self, Seiscomp::Core::Optional< Seiscomp::DataModel::EventTypeCertainty >::Impl const & typeCertainty)"""
|
|
return _datamodel.Event_setTypeCertainty(self, typeCertainty)
|
|
|
|
def typeCertainty(self):
|
|
r"""typeCertainty(Event self) -> Seiscomp::DataModel::EventTypeCertainty"""
|
|
return _datamodel.Event_typeCertainty(self)
|
|
|
|
def setCreationInfo(self, creationInfo):
|
|
r"""setCreationInfo(Event self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
|
|
return _datamodel.Event_setCreationInfo(self, creationInfo)
|
|
|
|
def creationInfo(self, *args):
|
|
r"""
|
|
creationInfo(Event self) -> CreationInfo
|
|
creationInfo(Event self) -> CreationInfo
|
|
"""
|
|
return _datamodel.Event_creationInfo(self, *args)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(Event self, EventDescription obj) -> bool
|
|
add(Event self, Comment obj) -> bool
|
|
add(Event self, OriginReference obj) -> bool
|
|
add(Event self, FocalMechanismReference obj) -> bool
|
|
"""
|
|
return _datamodel.Event_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(Event self, EventDescription obj) -> bool
|
|
remove(Event self, Comment obj) -> bool
|
|
remove(Event self, OriginReference obj) -> bool
|
|
remove(Event self, FocalMechanismReference obj) -> bool
|
|
"""
|
|
return _datamodel.Event_remove(self, *args)
|
|
|
|
def removeEventDescription(self, *args):
|
|
r"""
|
|
removeEventDescription(Event self, size_t i) -> bool
|
|
removeEventDescription(Event self, EventDescriptionIndex i) -> bool
|
|
"""
|
|
return _datamodel.Event_removeEventDescription(self, *args)
|
|
|
|
def removeComment(self, *args):
|
|
r"""
|
|
removeComment(Event self, size_t i) -> bool
|
|
removeComment(Event self, CommentIndex i) -> bool
|
|
"""
|
|
return _datamodel.Event_removeComment(self, *args)
|
|
|
|
def removeOriginReference(self, *args):
|
|
r"""
|
|
removeOriginReference(Event self, size_t i) -> bool
|
|
removeOriginReference(Event self, OriginReferenceIndex i) -> bool
|
|
"""
|
|
return _datamodel.Event_removeOriginReference(self, *args)
|
|
|
|
def removeFocalMechanismReference(self, *args):
|
|
r"""
|
|
removeFocalMechanismReference(Event self, size_t i) -> bool
|
|
removeFocalMechanismReference(Event self, FocalMechanismReferenceIndex i) -> bool
|
|
"""
|
|
return _datamodel.Event_removeFocalMechanismReference(self, *args)
|
|
|
|
def eventDescriptionCount(self):
|
|
r"""eventDescriptionCount(Event self) -> size_t"""
|
|
return _datamodel.Event_eventDescriptionCount(self)
|
|
|
|
def commentCount(self):
|
|
r"""commentCount(Event self) -> size_t"""
|
|
return _datamodel.Event_commentCount(self)
|
|
|
|
def originReferenceCount(self):
|
|
r"""originReferenceCount(Event self) -> size_t"""
|
|
return _datamodel.Event_originReferenceCount(self)
|
|
|
|
def focalMechanismReferenceCount(self):
|
|
r"""focalMechanismReferenceCount(Event self) -> size_t"""
|
|
return _datamodel.Event_focalMechanismReferenceCount(self)
|
|
|
|
def eventDescription(self, *args):
|
|
r"""
|
|
eventDescription(Event self, size_t i) -> EventDescription
|
|
eventDescription(Event self, EventDescriptionIndex i) -> EventDescription
|
|
"""
|
|
return _datamodel.Event_eventDescription(self, *args)
|
|
|
|
def comment(self, *args):
|
|
r"""
|
|
comment(Event self, size_t i) -> Comment
|
|
comment(Event self, CommentIndex i) -> Comment
|
|
"""
|
|
return _datamodel.Event_comment(self, *args)
|
|
|
|
def originReference(self, *args):
|
|
r"""
|
|
originReference(Event self, size_t i) -> OriginReference
|
|
originReference(Event self, OriginReferenceIndex i) -> OriginReference
|
|
"""
|
|
return _datamodel.Event_originReference(self, *args)
|
|
|
|
def focalMechanismReference(self, *args):
|
|
r"""
|
|
focalMechanismReference(Event self, size_t i) -> FocalMechanismReference
|
|
focalMechanismReference(Event self, FocalMechanismReferenceIndex i) -> FocalMechanismReference
|
|
"""
|
|
return _datamodel.Event_focalMechanismReference(self, *args)
|
|
|
|
def eventParameters(self):
|
|
r"""eventParameters(Event self) -> EventParameters"""
|
|
return _datamodel.Event_eventParameters(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Event self, Object other) -> bool"""
|
|
return _datamodel.Event_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Event self, PublicObject parent) -> bool"""
|
|
return _datamodel.Event_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Event self, PublicObject parent) -> bool"""
|
|
return _datamodel.Event_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Event self) -> bool"""
|
|
return _datamodel.Event_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Event self) -> Object"""
|
|
return _datamodel.Event_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Event self, Object child) -> bool"""
|
|
return _datamodel.Event_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Event self, Visitor visitor)"""
|
|
return _datamodel.Event_accept(self, visitor)
|
|
|
|
# Register Event in _datamodel:
|
|
_datamodel.Event_swigregister(Event)
|
|
|
|
def Event_ClassName():
|
|
r"""Event_ClassName() -> char const *"""
|
|
return _datamodel.Event_ClassName()
|
|
|
|
def Event_TypeInfo():
|
|
r"""Event_TypeInfo() -> RTTI"""
|
|
return _datamodel.Event_TypeInfo()
|
|
|
|
def Event_Cast(*args):
|
|
r"""
|
|
Event_Cast(BaseObject o) -> Event
|
|
Event_Cast(Seiscomp::Core::BaseObjectPtr o) -> Event
|
|
"""
|
|
return _datamodel.Event_Cast(*args)
|
|
|
|
def Event_ConstCast(*args):
|
|
r"""
|
|
Event_ConstCast(BaseObject o) -> Event
|
|
Event_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Event
|
|
"""
|
|
return _datamodel.Event_ConstCast(*args)
|
|
|
|
def Event_Meta():
|
|
r"""Event_Meta() -> MetaObject"""
|
|
return _datamodel.Event_Meta()
|
|
|
|
def Event_Create(*args):
|
|
r"""
|
|
Event_Create() -> Event
|
|
Event_Create(std::string const & publicID) -> Event
|
|
"""
|
|
return _datamodel.Event_Create(*args)
|
|
|
|
def Event_Find(publicID):
|
|
r"""Event_Find(std::string const & publicID) -> Event"""
|
|
return _datamodel.Event_Find(publicID)
|
|
|
|
class ArrivalIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ArrivalIndex 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__(ArrivalIndex self) -> ArrivalIndex
|
|
__init__(ArrivalIndex self, std::string const & pickID) -> ArrivalIndex
|
|
__init__(ArrivalIndex self, ArrivalIndex arg2) -> ArrivalIndex
|
|
"""
|
|
_datamodel.ArrivalIndex_swiginit(self, _datamodel.new_ArrivalIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(ArrivalIndex self, ArrivalIndex arg2) -> bool"""
|
|
return _datamodel.ArrivalIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(ArrivalIndex self, ArrivalIndex arg2) -> bool"""
|
|
return _datamodel.ArrivalIndex___ne__(self, arg2)
|
|
pickID = property(_datamodel.ArrivalIndex_pickID_get, _datamodel.ArrivalIndex_pickID_set, doc=r"""pickID : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_ArrivalIndex
|
|
|
|
# Register ArrivalIndex in _datamodel:
|
|
_datamodel.ArrivalIndex_swigregister(ArrivalIndex)
|
|
|
|
class Arrival(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Arrival 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 _datamodel.Arrival_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Arrival_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Arrival self) -> char const *"""
|
|
return _datamodel.Arrival_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Arrival self) -> RTTI"""
|
|
return _datamodel.Arrival_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Arrival
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Arrival
|
|
"""
|
|
return _datamodel.Arrival_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Arrival
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Arrival
|
|
"""
|
|
return _datamodel.Arrival_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Arrival self, GenericArchive ar)"""
|
|
return _datamodel.Arrival_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Arrival_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Arrival self) -> MetaObject"""
|
|
return _datamodel.Arrival_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Arrival self) -> Arrival
|
|
__init__(Arrival self, Arrival other) -> Arrival
|
|
"""
|
|
_datamodel.Arrival_swiginit(self, _datamodel.new_Arrival(*args))
|
|
__swig_destroy__ = _datamodel.delete_Arrival
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Arrival self, Arrival other) -> bool"""
|
|
return _datamodel.Arrival___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Arrival self, Arrival other) -> bool"""
|
|
return _datamodel.Arrival___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Arrival self, Arrival other) -> bool"""
|
|
return _datamodel.Arrival_equal(self, other)
|
|
|
|
def setPickID(self, pickID):
|
|
r"""setPickID(Arrival self, std::string const & pickID)"""
|
|
return _datamodel.Arrival_setPickID(self, pickID)
|
|
|
|
def pickID(self):
|
|
r"""pickID(Arrival self) -> std::string const &"""
|
|
return _datamodel.Arrival_pickID(self)
|
|
|
|
def setPhase(self, phase):
|
|
r"""setPhase(Arrival self, Phase phase)"""
|
|
return _datamodel.Arrival_setPhase(self, phase)
|
|
|
|
def phase(self, *args):
|
|
r"""
|
|
phase(Arrival self) -> Phase
|
|
phase(Arrival self) -> Phase
|
|
"""
|
|
return _datamodel.Arrival_phase(self, *args)
|
|
|
|
def setTimeCorrection(self, timeCorrection):
|
|
r"""setTimeCorrection(Arrival self, Seiscomp::Core::Optional< double >::Impl const & timeCorrection)"""
|
|
return _datamodel.Arrival_setTimeCorrection(self, timeCorrection)
|
|
|
|
def timeCorrection(self):
|
|
r"""timeCorrection(Arrival self) -> double"""
|
|
return _datamodel.Arrival_timeCorrection(self)
|
|
|
|
def setAzimuth(self, azimuth):
|
|
r"""setAzimuth(Arrival self, Seiscomp::Core::Optional< double >::Impl const & azimuth)"""
|
|
return _datamodel.Arrival_setAzimuth(self, azimuth)
|
|
|
|
def azimuth(self):
|
|
r"""azimuth(Arrival self) -> double"""
|
|
return _datamodel.Arrival_azimuth(self)
|
|
|
|
def setDistance(self, distance):
|
|
r"""setDistance(Arrival self, Seiscomp::Core::Optional< double >::Impl const & distance)"""
|
|
return _datamodel.Arrival_setDistance(self, distance)
|
|
|
|
def distance(self):
|
|
r"""distance(Arrival self) -> double"""
|
|
return _datamodel.Arrival_distance(self)
|
|
|
|
def setTakeOffAngle(self, takeOffAngle):
|
|
r"""setTakeOffAngle(Arrival self, Seiscomp::Core::Optional< double >::Impl const & takeOffAngle)"""
|
|
return _datamodel.Arrival_setTakeOffAngle(self, takeOffAngle)
|
|
|
|
def takeOffAngle(self):
|
|
r"""takeOffAngle(Arrival self) -> double"""
|
|
return _datamodel.Arrival_takeOffAngle(self)
|
|
|
|
def setTimeResidual(self, timeResidual):
|
|
r"""setTimeResidual(Arrival self, Seiscomp::Core::Optional< double >::Impl const & timeResidual)"""
|
|
return _datamodel.Arrival_setTimeResidual(self, timeResidual)
|
|
|
|
def timeResidual(self):
|
|
r"""timeResidual(Arrival self) -> double"""
|
|
return _datamodel.Arrival_timeResidual(self)
|
|
|
|
def setHorizontalSlownessResidual(self, horizontalSlownessResidual):
|
|
r"""setHorizontalSlownessResidual(Arrival self, Seiscomp::Core::Optional< double >::Impl const & horizontalSlownessResidual)"""
|
|
return _datamodel.Arrival_setHorizontalSlownessResidual(self, horizontalSlownessResidual)
|
|
|
|
def horizontalSlownessResidual(self):
|
|
r"""horizontalSlownessResidual(Arrival self) -> double"""
|
|
return _datamodel.Arrival_horizontalSlownessResidual(self)
|
|
|
|
def setBackazimuthResidual(self, backazimuthResidual):
|
|
r"""setBackazimuthResidual(Arrival self, Seiscomp::Core::Optional< double >::Impl const & backazimuthResidual)"""
|
|
return _datamodel.Arrival_setBackazimuthResidual(self, backazimuthResidual)
|
|
|
|
def backazimuthResidual(self):
|
|
r"""backazimuthResidual(Arrival self) -> double"""
|
|
return _datamodel.Arrival_backazimuthResidual(self)
|
|
|
|
def setTimeUsed(self, timeUsed):
|
|
r"""setTimeUsed(Arrival self, Seiscomp::Core::Optional< bool >::Impl const & timeUsed)"""
|
|
return _datamodel.Arrival_setTimeUsed(self, timeUsed)
|
|
|
|
def timeUsed(self):
|
|
r"""timeUsed(Arrival self) -> bool"""
|
|
return _datamodel.Arrival_timeUsed(self)
|
|
|
|
def setHorizontalSlownessUsed(self, horizontalSlownessUsed):
|
|
r"""setHorizontalSlownessUsed(Arrival self, Seiscomp::Core::Optional< bool >::Impl const & horizontalSlownessUsed)"""
|
|
return _datamodel.Arrival_setHorizontalSlownessUsed(self, horizontalSlownessUsed)
|
|
|
|
def horizontalSlownessUsed(self):
|
|
r"""horizontalSlownessUsed(Arrival self) -> bool"""
|
|
return _datamodel.Arrival_horizontalSlownessUsed(self)
|
|
|
|
def setBackazimuthUsed(self, backazimuthUsed):
|
|
r"""setBackazimuthUsed(Arrival self, Seiscomp::Core::Optional< bool >::Impl const & backazimuthUsed)"""
|
|
return _datamodel.Arrival_setBackazimuthUsed(self, backazimuthUsed)
|
|
|
|
def backazimuthUsed(self):
|
|
r"""backazimuthUsed(Arrival self) -> bool"""
|
|
return _datamodel.Arrival_backazimuthUsed(self)
|
|
|
|
def setWeight(self, weight):
|
|
r"""setWeight(Arrival self, Seiscomp::Core::Optional< double >::Impl const & weight)"""
|
|
return _datamodel.Arrival_setWeight(self, weight)
|
|
|
|
def weight(self):
|
|
r"""weight(Arrival self) -> double"""
|
|
return _datamodel.Arrival_weight(self)
|
|
|
|
def setEarthModelID(self, earthModelID):
|
|
r"""setEarthModelID(Arrival self, std::string const & earthModelID)"""
|
|
return _datamodel.Arrival_setEarthModelID(self, earthModelID)
|
|
|
|
def earthModelID(self):
|
|
r"""earthModelID(Arrival self) -> std::string const &"""
|
|
return _datamodel.Arrival_earthModelID(self)
|
|
|
|
def setPreliminary(self, preliminary):
|
|
r"""setPreliminary(Arrival self, Seiscomp::Core::Optional< bool >::Impl const & preliminary)"""
|
|
return _datamodel.Arrival_setPreliminary(self, preliminary)
|
|
|
|
def preliminary(self):
|
|
r"""preliminary(Arrival self) -> bool"""
|
|
return _datamodel.Arrival_preliminary(self)
|
|
|
|
def setCreationInfo(self, creationInfo):
|
|
r"""setCreationInfo(Arrival self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
|
|
return _datamodel.Arrival_setCreationInfo(self, creationInfo)
|
|
|
|
def creationInfo(self, *args):
|
|
r"""
|
|
creationInfo(Arrival self) -> CreationInfo
|
|
creationInfo(Arrival self) -> CreationInfo
|
|
"""
|
|
return _datamodel.Arrival_creationInfo(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(Arrival self) -> ArrivalIndex"""
|
|
return _datamodel.Arrival_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(Arrival self, Arrival lhs) -> bool"""
|
|
return _datamodel.Arrival_equalIndex(self, lhs)
|
|
|
|
def origin(self):
|
|
r"""origin(Arrival self) -> Origin"""
|
|
return _datamodel.Arrival_origin(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Arrival self, Object other) -> bool"""
|
|
return _datamodel.Arrival_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Arrival self, PublicObject parent) -> bool"""
|
|
return _datamodel.Arrival_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Arrival self, PublicObject parent) -> bool"""
|
|
return _datamodel.Arrival_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Arrival self) -> bool"""
|
|
return _datamodel.Arrival_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Arrival self) -> Object"""
|
|
return _datamodel.Arrival_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Arrival self, Visitor visitor)"""
|
|
return _datamodel.Arrival_accept(self, visitor)
|
|
|
|
# Register Arrival in _datamodel:
|
|
_datamodel.Arrival_swigregister(Arrival)
|
|
|
|
def Arrival_ClassName():
|
|
r"""Arrival_ClassName() -> char const *"""
|
|
return _datamodel.Arrival_ClassName()
|
|
|
|
def Arrival_TypeInfo():
|
|
r"""Arrival_TypeInfo() -> RTTI"""
|
|
return _datamodel.Arrival_TypeInfo()
|
|
|
|
def Arrival_Cast(*args):
|
|
r"""
|
|
Arrival_Cast(BaseObject o) -> Arrival
|
|
Arrival_Cast(Seiscomp::Core::BaseObjectPtr o) -> Arrival
|
|
"""
|
|
return _datamodel.Arrival_Cast(*args)
|
|
|
|
def Arrival_ConstCast(*args):
|
|
r"""
|
|
Arrival_ConstCast(BaseObject o) -> Arrival
|
|
Arrival_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Arrival
|
|
"""
|
|
return _datamodel.Arrival_ConstCast(*args)
|
|
|
|
def Arrival_Meta():
|
|
r"""Arrival_Meta() -> MetaObject"""
|
|
return _datamodel.Arrival_Meta()
|
|
|
|
class Origin(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Origin 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 _datamodel.Origin_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Origin_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Origin self) -> char const *"""
|
|
return _datamodel.Origin_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Origin self) -> RTTI"""
|
|
return _datamodel.Origin_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Origin
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Origin
|
|
"""
|
|
return _datamodel.Origin_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Origin
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Origin
|
|
"""
|
|
return _datamodel.Origin_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Origin self, GenericArchive ar)"""
|
|
return _datamodel.Origin_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Origin_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Origin self) -> MetaObject"""
|
|
return _datamodel.Origin_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Origin self, Origin other) -> Origin
|
|
__init__(Origin self, std::string const & publicID) -> Origin
|
|
"""
|
|
_datamodel.Origin_swiginit(self, _datamodel.new_Origin(*args))
|
|
__swig_destroy__ = _datamodel.delete_Origin
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> Origin
|
|
Create(std::string const & publicID) -> Origin
|
|
"""
|
|
return _datamodel.Origin_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> Origin"""
|
|
return _datamodel.Origin_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Origin self, Origin other) -> bool"""
|
|
return _datamodel.Origin___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Origin self, Origin other) -> bool"""
|
|
return _datamodel.Origin___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Origin self, Origin other) -> bool"""
|
|
return _datamodel.Origin_equal(self, other)
|
|
|
|
def setTime(self, time):
|
|
r"""setTime(Origin self, TimeQuantity time)"""
|
|
return _datamodel.Origin_setTime(self, time)
|
|
|
|
def time(self, *args):
|
|
r"""
|
|
time(Origin self) -> TimeQuantity
|
|
time(Origin self) -> TimeQuantity
|
|
"""
|
|
return _datamodel.Origin_time(self, *args)
|
|
|
|
def setLatitude(self, latitude):
|
|
r"""setLatitude(Origin self, RealQuantity latitude)"""
|
|
return _datamodel.Origin_setLatitude(self, latitude)
|
|
|
|
def latitude(self, *args):
|
|
r"""
|
|
latitude(Origin self) -> RealQuantity
|
|
latitude(Origin self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Origin_latitude(self, *args)
|
|
|
|
def setLongitude(self, longitude):
|
|
r"""setLongitude(Origin self, RealQuantity longitude)"""
|
|
return _datamodel.Origin_setLongitude(self, longitude)
|
|
|
|
def longitude(self, *args):
|
|
r"""
|
|
longitude(Origin self) -> RealQuantity
|
|
longitude(Origin self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Origin_longitude(self, *args)
|
|
|
|
def setDepth(self, depth):
|
|
r"""setDepth(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealQuantity >::Impl const & depth)"""
|
|
return _datamodel.Origin_setDepth(self, depth)
|
|
|
|
def depth(self, *args):
|
|
r"""
|
|
depth(Origin self) -> RealQuantity
|
|
depth(Origin self) -> RealQuantity
|
|
"""
|
|
return _datamodel.Origin_depth(self, *args)
|
|
|
|
def setDepthType(self, depthType):
|
|
r"""setDepthType(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::OriginDepthType >::Impl const & depthType)"""
|
|
return _datamodel.Origin_setDepthType(self, depthType)
|
|
|
|
def depthType(self):
|
|
r"""depthType(Origin self) -> Seiscomp::DataModel::OriginDepthType"""
|
|
return _datamodel.Origin_depthType(self)
|
|
|
|
def setTimeFixed(self, timeFixed):
|
|
r"""setTimeFixed(Origin self, Seiscomp::Core::Optional< bool >::Impl const & timeFixed)"""
|
|
return _datamodel.Origin_setTimeFixed(self, timeFixed)
|
|
|
|
def timeFixed(self):
|
|
r"""timeFixed(Origin self) -> bool"""
|
|
return _datamodel.Origin_timeFixed(self)
|
|
|
|
def setEpicenterFixed(self, epicenterFixed):
|
|
r"""setEpicenterFixed(Origin self, Seiscomp::Core::Optional< bool >::Impl const & epicenterFixed)"""
|
|
return _datamodel.Origin_setEpicenterFixed(self, epicenterFixed)
|
|
|
|
def epicenterFixed(self):
|
|
r"""epicenterFixed(Origin self) -> bool"""
|
|
return _datamodel.Origin_epicenterFixed(self)
|
|
|
|
def setReferenceSystemID(self, referenceSystemID):
|
|
r"""setReferenceSystemID(Origin self, std::string const & referenceSystemID)"""
|
|
return _datamodel.Origin_setReferenceSystemID(self, referenceSystemID)
|
|
|
|
def referenceSystemID(self):
|
|
r"""referenceSystemID(Origin self) -> std::string const &"""
|
|
return _datamodel.Origin_referenceSystemID(self)
|
|
|
|
def setMethodID(self, methodID):
|
|
r"""setMethodID(Origin self, std::string const & methodID)"""
|
|
return _datamodel.Origin_setMethodID(self, methodID)
|
|
|
|
def methodID(self):
|
|
r"""methodID(Origin self) -> std::string const &"""
|
|
return _datamodel.Origin_methodID(self)
|
|
|
|
def setEarthModelID(self, earthModelID):
|
|
r"""setEarthModelID(Origin self, std::string const & earthModelID)"""
|
|
return _datamodel.Origin_setEarthModelID(self, earthModelID)
|
|
|
|
def earthModelID(self):
|
|
r"""earthModelID(Origin self) -> std::string const &"""
|
|
return _datamodel.Origin_earthModelID(self)
|
|
|
|
def setQuality(self, quality):
|
|
r"""setQuality(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::OriginQuality >::Impl const & quality)"""
|
|
return _datamodel.Origin_setQuality(self, quality)
|
|
|
|
def quality(self, *args):
|
|
r"""
|
|
quality(Origin self) -> OriginQuality
|
|
quality(Origin self) -> OriginQuality
|
|
"""
|
|
return _datamodel.Origin_quality(self, *args)
|
|
|
|
def setUncertainty(self, uncertainty):
|
|
r"""setUncertainty(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::OriginUncertainty >::Impl const & uncertainty)"""
|
|
return _datamodel.Origin_setUncertainty(self, uncertainty)
|
|
|
|
def uncertainty(self, *args):
|
|
r"""
|
|
uncertainty(Origin self) -> OriginUncertainty
|
|
uncertainty(Origin self) -> OriginUncertainty
|
|
"""
|
|
return _datamodel.Origin_uncertainty(self, *args)
|
|
|
|
def setType(self, type):
|
|
r"""setType(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::OriginType >::Impl const & type)"""
|
|
return _datamodel.Origin_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(Origin self) -> Seiscomp::DataModel::OriginType"""
|
|
return _datamodel.Origin_type(self)
|
|
|
|
def setEvaluationMode(self, evaluationMode):
|
|
r"""setEvaluationMode(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationMode >::Impl const & evaluationMode)"""
|
|
return _datamodel.Origin_setEvaluationMode(self, evaluationMode)
|
|
|
|
def evaluationMode(self):
|
|
r"""evaluationMode(Origin self) -> Seiscomp::DataModel::EvaluationMode"""
|
|
return _datamodel.Origin_evaluationMode(self)
|
|
|
|
def setEvaluationStatus(self, evaluationStatus):
|
|
r"""setEvaluationStatus(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::EvaluationStatus >::Impl const & evaluationStatus)"""
|
|
return _datamodel.Origin_setEvaluationStatus(self, evaluationStatus)
|
|
|
|
def evaluationStatus(self):
|
|
r"""evaluationStatus(Origin self) -> Seiscomp::DataModel::EvaluationStatus"""
|
|
return _datamodel.Origin_evaluationStatus(self)
|
|
|
|
def setCreationInfo(self, creationInfo):
|
|
r"""setCreationInfo(Origin self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
|
|
return _datamodel.Origin_setCreationInfo(self, creationInfo)
|
|
|
|
def creationInfo(self, *args):
|
|
r"""
|
|
creationInfo(Origin self) -> CreationInfo
|
|
creationInfo(Origin self) -> CreationInfo
|
|
"""
|
|
return _datamodel.Origin_creationInfo(self, *args)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(Origin self, Comment obj) -> bool
|
|
add(Origin self, CompositeTime obj) -> bool
|
|
add(Origin self, Arrival obj) -> bool
|
|
add(Origin self, StationMagnitude obj) -> bool
|
|
add(Origin self, Magnitude obj) -> bool
|
|
"""
|
|
return _datamodel.Origin_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(Origin self, Comment obj) -> bool
|
|
remove(Origin self, CompositeTime obj) -> bool
|
|
remove(Origin self, Arrival obj) -> bool
|
|
remove(Origin self, StationMagnitude obj) -> bool
|
|
remove(Origin self, Magnitude obj) -> bool
|
|
"""
|
|
return _datamodel.Origin_remove(self, *args)
|
|
|
|
def removeComment(self, *args):
|
|
r"""
|
|
removeComment(Origin self, size_t i) -> bool
|
|
removeComment(Origin self, CommentIndex i) -> bool
|
|
"""
|
|
return _datamodel.Origin_removeComment(self, *args)
|
|
|
|
def removeCompositeTime(self, i):
|
|
r"""removeCompositeTime(Origin self, size_t i) -> bool"""
|
|
return _datamodel.Origin_removeCompositeTime(self, i)
|
|
|
|
def removeArrival(self, *args):
|
|
r"""
|
|
removeArrival(Origin self, size_t i) -> bool
|
|
removeArrival(Origin self, ArrivalIndex i) -> bool
|
|
"""
|
|
return _datamodel.Origin_removeArrival(self, *args)
|
|
|
|
def removeStationMagnitude(self, i):
|
|
r"""removeStationMagnitude(Origin self, size_t i) -> bool"""
|
|
return _datamodel.Origin_removeStationMagnitude(self, i)
|
|
|
|
def removeMagnitude(self, i):
|
|
r"""removeMagnitude(Origin self, size_t i) -> bool"""
|
|
return _datamodel.Origin_removeMagnitude(self, i)
|
|
|
|
def commentCount(self):
|
|
r"""commentCount(Origin self) -> size_t"""
|
|
return _datamodel.Origin_commentCount(self)
|
|
|
|
def compositeTimeCount(self):
|
|
r"""compositeTimeCount(Origin self) -> size_t"""
|
|
return _datamodel.Origin_compositeTimeCount(self)
|
|
|
|
def arrivalCount(self):
|
|
r"""arrivalCount(Origin self) -> size_t"""
|
|
return _datamodel.Origin_arrivalCount(self)
|
|
|
|
def stationMagnitudeCount(self):
|
|
r"""stationMagnitudeCount(Origin self) -> size_t"""
|
|
return _datamodel.Origin_stationMagnitudeCount(self)
|
|
|
|
def magnitudeCount(self):
|
|
r"""magnitudeCount(Origin self) -> size_t"""
|
|
return _datamodel.Origin_magnitudeCount(self)
|
|
|
|
def comment(self, *args):
|
|
r"""
|
|
comment(Origin self, size_t i) -> Comment
|
|
comment(Origin self, CommentIndex i) -> Comment
|
|
"""
|
|
return _datamodel.Origin_comment(self, *args)
|
|
|
|
def compositeTime(self, i):
|
|
r"""compositeTime(Origin self, size_t i) -> CompositeTime"""
|
|
return _datamodel.Origin_compositeTime(self, i)
|
|
|
|
def arrival(self, *args):
|
|
r"""
|
|
arrival(Origin self, size_t i) -> Arrival
|
|
arrival(Origin self, ArrivalIndex i) -> Arrival
|
|
"""
|
|
return _datamodel.Origin_arrival(self, *args)
|
|
|
|
def stationMagnitude(self, i):
|
|
r"""stationMagnitude(Origin self, size_t i) -> StationMagnitude"""
|
|
return _datamodel.Origin_stationMagnitude(self, i)
|
|
|
|
def magnitude(self, i):
|
|
r"""magnitude(Origin self, size_t i) -> Magnitude"""
|
|
return _datamodel.Origin_magnitude(self, i)
|
|
|
|
def findCompositeTime(self, compositeTime):
|
|
r"""findCompositeTime(Origin self, CompositeTime compositeTime) -> CompositeTime"""
|
|
return _datamodel.Origin_findCompositeTime(self, compositeTime)
|
|
|
|
def findStationMagnitude(self, publicID):
|
|
r"""findStationMagnitude(Origin self, std::string const & publicID) -> StationMagnitude"""
|
|
return _datamodel.Origin_findStationMagnitude(self, publicID)
|
|
|
|
def findMagnitude(self, publicID):
|
|
r"""findMagnitude(Origin self, std::string const & publicID) -> Magnitude"""
|
|
return _datamodel.Origin_findMagnitude(self, publicID)
|
|
|
|
def eventParameters(self):
|
|
r"""eventParameters(Origin self) -> EventParameters"""
|
|
return _datamodel.Origin_eventParameters(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Origin self, Object other) -> bool"""
|
|
return _datamodel.Origin_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Origin self, PublicObject parent) -> bool"""
|
|
return _datamodel.Origin_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Origin self, PublicObject parent) -> bool"""
|
|
return _datamodel.Origin_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Origin self) -> bool"""
|
|
return _datamodel.Origin_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Origin self) -> Object"""
|
|
return _datamodel.Origin_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Origin self, Object child) -> bool"""
|
|
return _datamodel.Origin_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Origin self, Visitor visitor)"""
|
|
return _datamodel.Origin_accept(self, visitor)
|
|
|
|
# Register Origin in _datamodel:
|
|
_datamodel.Origin_swigregister(Origin)
|
|
|
|
def Origin_ClassName():
|
|
r"""Origin_ClassName() -> char const *"""
|
|
return _datamodel.Origin_ClassName()
|
|
|
|
def Origin_TypeInfo():
|
|
r"""Origin_TypeInfo() -> RTTI"""
|
|
return _datamodel.Origin_TypeInfo()
|
|
|
|
def Origin_Cast(*args):
|
|
r"""
|
|
Origin_Cast(BaseObject o) -> Origin
|
|
Origin_Cast(Seiscomp::Core::BaseObjectPtr o) -> Origin
|
|
"""
|
|
return _datamodel.Origin_Cast(*args)
|
|
|
|
def Origin_ConstCast(*args):
|
|
r"""
|
|
Origin_ConstCast(BaseObject o) -> Origin
|
|
Origin_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Origin
|
|
"""
|
|
return _datamodel.Origin_ConstCast(*args)
|
|
|
|
def Origin_Meta():
|
|
r"""Origin_Meta() -> MetaObject"""
|
|
return _datamodel.Origin_Meta()
|
|
|
|
def Origin_Create(*args):
|
|
r"""
|
|
Origin_Create() -> Origin
|
|
Origin_Create(std::string const & publicID) -> Origin
|
|
"""
|
|
return _datamodel.Origin_Create(*args)
|
|
|
|
def Origin_Find(publicID):
|
|
r"""Origin_Find(std::string const & publicID) -> Origin"""
|
|
return _datamodel.Origin_Find(publicID)
|
|
|
|
class EventParameters(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::EventParameters 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 _datamodel.EventParameters_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.EventParameters_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(EventParameters self) -> char const *"""
|
|
return _datamodel.EventParameters_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(EventParameters self) -> RTTI"""
|
|
return _datamodel.EventParameters_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> EventParameters
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> EventParameters
|
|
"""
|
|
return _datamodel.EventParameters_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> EventParameters
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> EventParameters
|
|
"""
|
|
return _datamodel.EventParameters_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(EventParameters self, GenericArchive ar)"""
|
|
return _datamodel.EventParameters_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.EventParameters_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(EventParameters self) -> MetaObject"""
|
|
return _datamodel.EventParameters_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(EventParameters self) -> EventParameters
|
|
__init__(EventParameters self, EventParameters other) -> EventParameters
|
|
"""
|
|
_datamodel.EventParameters_swiginit(self, _datamodel.new_EventParameters(*args))
|
|
__swig_destroy__ = _datamodel.delete_EventParameters
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(EventParameters self, EventParameters other) -> bool"""
|
|
return _datamodel.EventParameters___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(EventParameters self, EventParameters other) -> bool"""
|
|
return _datamodel.EventParameters___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(EventParameters self, EventParameters other) -> bool"""
|
|
return _datamodel.EventParameters_equal(self, other)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(EventParameters self, Pick obj) -> bool
|
|
add(EventParameters self, Amplitude obj) -> bool
|
|
add(EventParameters self, Reading obj) -> bool
|
|
add(EventParameters self, Origin obj) -> bool
|
|
add(EventParameters self, FocalMechanism obj) -> bool
|
|
add(EventParameters self, Event obj) -> bool
|
|
"""
|
|
return _datamodel.EventParameters_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(EventParameters self, Pick obj) -> bool
|
|
remove(EventParameters self, Amplitude obj) -> bool
|
|
remove(EventParameters self, Reading obj) -> bool
|
|
remove(EventParameters self, Origin obj) -> bool
|
|
remove(EventParameters self, FocalMechanism obj) -> bool
|
|
remove(EventParameters self, Event obj) -> bool
|
|
"""
|
|
return _datamodel.EventParameters_remove(self, *args)
|
|
|
|
def removePick(self, i):
|
|
r"""removePick(EventParameters self, size_t i) -> bool"""
|
|
return _datamodel.EventParameters_removePick(self, i)
|
|
|
|
def removeAmplitude(self, i):
|
|
r"""removeAmplitude(EventParameters self, size_t i) -> bool"""
|
|
return _datamodel.EventParameters_removeAmplitude(self, i)
|
|
|
|
def removeReading(self, i):
|
|
r"""removeReading(EventParameters self, size_t i) -> bool"""
|
|
return _datamodel.EventParameters_removeReading(self, i)
|
|
|
|
def removeOrigin(self, i):
|
|
r"""removeOrigin(EventParameters self, size_t i) -> bool"""
|
|
return _datamodel.EventParameters_removeOrigin(self, i)
|
|
|
|
def removeFocalMechanism(self, i):
|
|
r"""removeFocalMechanism(EventParameters self, size_t i) -> bool"""
|
|
return _datamodel.EventParameters_removeFocalMechanism(self, i)
|
|
|
|
def removeEvent(self, i):
|
|
r"""removeEvent(EventParameters self, size_t i) -> bool"""
|
|
return _datamodel.EventParameters_removeEvent(self, i)
|
|
|
|
def pickCount(self):
|
|
r"""pickCount(EventParameters self) -> size_t"""
|
|
return _datamodel.EventParameters_pickCount(self)
|
|
|
|
def amplitudeCount(self):
|
|
r"""amplitudeCount(EventParameters self) -> size_t"""
|
|
return _datamodel.EventParameters_amplitudeCount(self)
|
|
|
|
def readingCount(self):
|
|
r"""readingCount(EventParameters self) -> size_t"""
|
|
return _datamodel.EventParameters_readingCount(self)
|
|
|
|
def originCount(self):
|
|
r"""originCount(EventParameters self) -> size_t"""
|
|
return _datamodel.EventParameters_originCount(self)
|
|
|
|
def focalMechanismCount(self):
|
|
r"""focalMechanismCount(EventParameters self) -> size_t"""
|
|
return _datamodel.EventParameters_focalMechanismCount(self)
|
|
|
|
def eventCount(self):
|
|
r"""eventCount(EventParameters self) -> size_t"""
|
|
return _datamodel.EventParameters_eventCount(self)
|
|
|
|
def pick(self, i):
|
|
r"""pick(EventParameters self, size_t i) -> Pick"""
|
|
return _datamodel.EventParameters_pick(self, i)
|
|
|
|
def amplitude(self, i):
|
|
r"""amplitude(EventParameters self, size_t i) -> Amplitude"""
|
|
return _datamodel.EventParameters_amplitude(self, i)
|
|
|
|
def reading(self, i):
|
|
r"""reading(EventParameters self, size_t i) -> Reading"""
|
|
return _datamodel.EventParameters_reading(self, i)
|
|
|
|
def origin(self, i):
|
|
r"""origin(EventParameters self, size_t i) -> Origin"""
|
|
return _datamodel.EventParameters_origin(self, i)
|
|
|
|
def focalMechanism(self, i):
|
|
r"""focalMechanism(EventParameters self, size_t i) -> FocalMechanism"""
|
|
return _datamodel.EventParameters_focalMechanism(self, i)
|
|
|
|
def event(self, i):
|
|
r"""event(EventParameters self, size_t i) -> Event"""
|
|
return _datamodel.EventParameters_event(self, i)
|
|
|
|
def findPick(self, publicID):
|
|
r"""findPick(EventParameters self, std::string const & publicID) -> Pick"""
|
|
return _datamodel.EventParameters_findPick(self, publicID)
|
|
|
|
def findAmplitude(self, publicID):
|
|
r"""findAmplitude(EventParameters self, std::string const & publicID) -> Amplitude"""
|
|
return _datamodel.EventParameters_findAmplitude(self, publicID)
|
|
|
|
def findReading(self, publicID):
|
|
r"""findReading(EventParameters self, std::string const & publicID) -> Reading"""
|
|
return _datamodel.EventParameters_findReading(self, publicID)
|
|
|
|
def findOrigin(self, publicID):
|
|
r"""findOrigin(EventParameters self, std::string const & publicID) -> Origin"""
|
|
return _datamodel.EventParameters_findOrigin(self, publicID)
|
|
|
|
def findFocalMechanism(self, publicID):
|
|
r"""findFocalMechanism(EventParameters self, std::string const & publicID) -> FocalMechanism"""
|
|
return _datamodel.EventParameters_findFocalMechanism(self, publicID)
|
|
|
|
def findEvent(self, publicID):
|
|
r"""findEvent(EventParameters self, std::string const & publicID) -> Event"""
|
|
return _datamodel.EventParameters_findEvent(self, publicID)
|
|
|
|
def assign(self, other):
|
|
r"""assign(EventParameters self, Object other) -> bool"""
|
|
return _datamodel.EventParameters_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(EventParameters self, PublicObject parent) -> bool"""
|
|
return _datamodel.EventParameters_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(EventParameters self, PublicObject parent) -> bool"""
|
|
return _datamodel.EventParameters_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(EventParameters self) -> bool"""
|
|
return _datamodel.EventParameters_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(EventParameters self) -> Object"""
|
|
return _datamodel.EventParameters_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(EventParameters self, Object child) -> bool"""
|
|
return _datamodel.EventParameters_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(EventParameters self, Visitor visitor)"""
|
|
return _datamodel.EventParameters_accept(self, visitor)
|
|
|
|
# Register EventParameters in _datamodel:
|
|
_datamodel.EventParameters_swigregister(EventParameters)
|
|
|
|
def EventParameters_ClassName():
|
|
r"""EventParameters_ClassName() -> char const *"""
|
|
return _datamodel.EventParameters_ClassName()
|
|
|
|
def EventParameters_TypeInfo():
|
|
r"""EventParameters_TypeInfo() -> RTTI"""
|
|
return _datamodel.EventParameters_TypeInfo()
|
|
|
|
def EventParameters_Cast(*args):
|
|
r"""
|
|
EventParameters_Cast(BaseObject o) -> EventParameters
|
|
EventParameters_Cast(Seiscomp::Core::BaseObjectPtr o) -> EventParameters
|
|
"""
|
|
return _datamodel.EventParameters_Cast(*args)
|
|
|
|
def EventParameters_ConstCast(*args):
|
|
r"""
|
|
EventParameters_ConstCast(BaseObject o) -> EventParameters
|
|
EventParameters_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> EventParameters
|
|
"""
|
|
return _datamodel.EventParameters_ConstCast(*args)
|
|
|
|
def EventParameters_Meta():
|
|
r"""EventParameters_Meta() -> MetaObject"""
|
|
return _datamodel.EventParameters_Meta()
|
|
|
|
class Parameter(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Parameter 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 _datamodel.Parameter_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Parameter_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Parameter self) -> char const *"""
|
|
return _datamodel.Parameter_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Parameter self) -> RTTI"""
|
|
return _datamodel.Parameter_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Parameter
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Parameter
|
|
"""
|
|
return _datamodel.Parameter_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Parameter
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Parameter
|
|
"""
|
|
return _datamodel.Parameter_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Parameter self, GenericArchive ar)"""
|
|
return _datamodel.Parameter_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Parameter_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Parameter self) -> MetaObject"""
|
|
return _datamodel.Parameter_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Parameter self, Parameter other) -> Parameter
|
|
__init__(Parameter self, std::string const & publicID) -> Parameter
|
|
"""
|
|
_datamodel.Parameter_swiginit(self, _datamodel.new_Parameter(*args))
|
|
__swig_destroy__ = _datamodel.delete_Parameter
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> Parameter
|
|
Create(std::string const & publicID) -> Parameter
|
|
"""
|
|
return _datamodel.Parameter_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> Parameter"""
|
|
return _datamodel.Parameter_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Parameter self, Parameter other) -> bool"""
|
|
return _datamodel.Parameter___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Parameter self, Parameter other) -> bool"""
|
|
return _datamodel.Parameter___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Parameter self, Parameter other) -> bool"""
|
|
return _datamodel.Parameter_equal(self, other)
|
|
|
|
def setName(self, name):
|
|
r"""setName(Parameter self, std::string const & name)"""
|
|
return _datamodel.Parameter_setName(self, name)
|
|
|
|
def name(self):
|
|
r"""name(Parameter self) -> std::string const &"""
|
|
return _datamodel.Parameter_name(self)
|
|
|
|
def setValue(self, value):
|
|
r"""setValue(Parameter self, std::string const & value)"""
|
|
return _datamodel.Parameter_setValue(self, value)
|
|
|
|
def value(self):
|
|
r"""value(Parameter self) -> std::string const &"""
|
|
return _datamodel.Parameter_value(self)
|
|
|
|
def add(self, obj):
|
|
r"""add(Parameter self, Comment obj) -> bool"""
|
|
return _datamodel.Parameter_add(self, obj)
|
|
|
|
def remove(self, obj):
|
|
r"""remove(Parameter self, Comment obj) -> bool"""
|
|
return _datamodel.Parameter_remove(self, obj)
|
|
|
|
def removeComment(self, *args):
|
|
r"""
|
|
removeComment(Parameter self, size_t i) -> bool
|
|
removeComment(Parameter self, CommentIndex i) -> bool
|
|
"""
|
|
return _datamodel.Parameter_removeComment(self, *args)
|
|
|
|
def commentCount(self):
|
|
r"""commentCount(Parameter self) -> size_t"""
|
|
return _datamodel.Parameter_commentCount(self)
|
|
|
|
def comment(self, *args):
|
|
r"""
|
|
comment(Parameter self, size_t i) -> Comment
|
|
comment(Parameter self, CommentIndex i) -> Comment
|
|
"""
|
|
return _datamodel.Parameter_comment(self, *args)
|
|
|
|
def parameterSet(self):
|
|
r"""parameterSet(Parameter self) -> ParameterSet"""
|
|
return _datamodel.Parameter_parameterSet(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Parameter self, Object other) -> bool"""
|
|
return _datamodel.Parameter_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Parameter self, PublicObject parent) -> bool"""
|
|
return _datamodel.Parameter_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Parameter self, PublicObject parent) -> bool"""
|
|
return _datamodel.Parameter_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Parameter self) -> bool"""
|
|
return _datamodel.Parameter_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Parameter self) -> Object"""
|
|
return _datamodel.Parameter_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Parameter self, Object child) -> bool"""
|
|
return _datamodel.Parameter_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Parameter self, Visitor visitor)"""
|
|
return _datamodel.Parameter_accept(self, visitor)
|
|
|
|
# Register Parameter in _datamodel:
|
|
_datamodel.Parameter_swigregister(Parameter)
|
|
|
|
def Parameter_ClassName():
|
|
r"""Parameter_ClassName() -> char const *"""
|
|
return _datamodel.Parameter_ClassName()
|
|
|
|
def Parameter_TypeInfo():
|
|
r"""Parameter_TypeInfo() -> RTTI"""
|
|
return _datamodel.Parameter_TypeInfo()
|
|
|
|
def Parameter_Cast(*args):
|
|
r"""
|
|
Parameter_Cast(BaseObject o) -> Parameter
|
|
Parameter_Cast(Seiscomp::Core::BaseObjectPtr o) -> Parameter
|
|
"""
|
|
return _datamodel.Parameter_Cast(*args)
|
|
|
|
def Parameter_ConstCast(*args):
|
|
r"""
|
|
Parameter_ConstCast(BaseObject o) -> Parameter
|
|
Parameter_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Parameter
|
|
"""
|
|
return _datamodel.Parameter_ConstCast(*args)
|
|
|
|
def Parameter_Meta():
|
|
r"""Parameter_Meta() -> MetaObject"""
|
|
return _datamodel.Parameter_Meta()
|
|
|
|
def Parameter_Create(*args):
|
|
r"""
|
|
Parameter_Create() -> Parameter
|
|
Parameter_Create(std::string const & publicID) -> Parameter
|
|
"""
|
|
return _datamodel.Parameter_Create(*args)
|
|
|
|
def Parameter_Find(publicID):
|
|
r"""Parameter_Find(std::string const & publicID) -> Parameter"""
|
|
return _datamodel.Parameter_Find(publicID)
|
|
|
|
class ParameterSet(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ParameterSet 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 _datamodel.ParameterSet_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ParameterSet_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ParameterSet self) -> char const *"""
|
|
return _datamodel.ParameterSet_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ParameterSet self) -> RTTI"""
|
|
return _datamodel.ParameterSet_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ParameterSet
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ParameterSet
|
|
"""
|
|
return _datamodel.ParameterSet_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ParameterSet
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ParameterSet
|
|
"""
|
|
return _datamodel.ParameterSet_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ParameterSet self, GenericArchive ar)"""
|
|
return _datamodel.ParameterSet_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ParameterSet_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ParameterSet self) -> MetaObject"""
|
|
return _datamodel.ParameterSet_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ParameterSet self, ParameterSet other) -> ParameterSet
|
|
__init__(ParameterSet self, std::string const & publicID) -> ParameterSet
|
|
"""
|
|
_datamodel.ParameterSet_swiginit(self, _datamodel.new_ParameterSet(*args))
|
|
__swig_destroy__ = _datamodel.delete_ParameterSet
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> ParameterSet
|
|
Create(std::string const & publicID) -> ParameterSet
|
|
"""
|
|
return _datamodel.ParameterSet_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> ParameterSet"""
|
|
return _datamodel.ParameterSet_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ParameterSet self, ParameterSet other) -> bool"""
|
|
return _datamodel.ParameterSet___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ParameterSet self, ParameterSet other) -> bool"""
|
|
return _datamodel.ParameterSet___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ParameterSet self, ParameterSet other) -> bool"""
|
|
return _datamodel.ParameterSet_equal(self, other)
|
|
|
|
def setBaseID(self, baseID):
|
|
r"""setBaseID(ParameterSet self, std::string const & baseID)"""
|
|
return _datamodel.ParameterSet_setBaseID(self, baseID)
|
|
|
|
def baseID(self):
|
|
r"""baseID(ParameterSet self) -> std::string const &"""
|
|
return _datamodel.ParameterSet_baseID(self)
|
|
|
|
def setModuleID(self, moduleID):
|
|
r"""setModuleID(ParameterSet self, std::string const & moduleID)"""
|
|
return _datamodel.ParameterSet_setModuleID(self, moduleID)
|
|
|
|
def moduleID(self):
|
|
r"""moduleID(ParameterSet self) -> std::string const &"""
|
|
return _datamodel.ParameterSet_moduleID(self)
|
|
|
|
def setCreated(self, created):
|
|
r"""setCreated(ParameterSet self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & created)"""
|
|
return _datamodel.ParameterSet_setCreated(self, created)
|
|
|
|
def created(self):
|
|
r"""created(ParameterSet self) -> Time"""
|
|
return _datamodel.ParameterSet_created(self)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(ParameterSet self, Parameter obj) -> bool
|
|
add(ParameterSet self, Comment obj) -> bool
|
|
"""
|
|
return _datamodel.ParameterSet_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(ParameterSet self, Parameter obj) -> bool
|
|
remove(ParameterSet self, Comment obj) -> bool
|
|
"""
|
|
return _datamodel.ParameterSet_remove(self, *args)
|
|
|
|
def removeParameter(self, i):
|
|
r"""removeParameter(ParameterSet self, size_t i) -> bool"""
|
|
return _datamodel.ParameterSet_removeParameter(self, i)
|
|
|
|
def removeComment(self, *args):
|
|
r"""
|
|
removeComment(ParameterSet self, size_t i) -> bool
|
|
removeComment(ParameterSet self, CommentIndex i) -> bool
|
|
"""
|
|
return _datamodel.ParameterSet_removeComment(self, *args)
|
|
|
|
def parameterCount(self):
|
|
r"""parameterCount(ParameterSet self) -> size_t"""
|
|
return _datamodel.ParameterSet_parameterCount(self)
|
|
|
|
def commentCount(self):
|
|
r"""commentCount(ParameterSet self) -> size_t"""
|
|
return _datamodel.ParameterSet_commentCount(self)
|
|
|
|
def parameter(self, i):
|
|
r"""parameter(ParameterSet self, size_t i) -> Parameter"""
|
|
return _datamodel.ParameterSet_parameter(self, i)
|
|
|
|
def comment(self, *args):
|
|
r"""
|
|
comment(ParameterSet self, size_t i) -> Comment
|
|
comment(ParameterSet self, CommentIndex i) -> Comment
|
|
"""
|
|
return _datamodel.ParameterSet_comment(self, *args)
|
|
|
|
def findParameter(self, publicID):
|
|
r"""findParameter(ParameterSet self, std::string const & publicID) -> Parameter"""
|
|
return _datamodel.ParameterSet_findParameter(self, publicID)
|
|
|
|
def config(self):
|
|
r"""config(ParameterSet self) -> Config"""
|
|
return _datamodel.ParameterSet_config(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(ParameterSet self, Object other) -> bool"""
|
|
return _datamodel.ParameterSet_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(ParameterSet self, PublicObject parent) -> bool"""
|
|
return _datamodel.ParameterSet_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(ParameterSet self, PublicObject parent) -> bool"""
|
|
return _datamodel.ParameterSet_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(ParameterSet self) -> bool"""
|
|
return _datamodel.ParameterSet_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(ParameterSet self) -> Object"""
|
|
return _datamodel.ParameterSet_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(ParameterSet self, Object child) -> bool"""
|
|
return _datamodel.ParameterSet_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(ParameterSet self, Visitor visitor)"""
|
|
return _datamodel.ParameterSet_accept(self, visitor)
|
|
|
|
# Register ParameterSet in _datamodel:
|
|
_datamodel.ParameterSet_swigregister(ParameterSet)
|
|
|
|
def ParameterSet_ClassName():
|
|
r"""ParameterSet_ClassName() -> char const *"""
|
|
return _datamodel.ParameterSet_ClassName()
|
|
|
|
def ParameterSet_TypeInfo():
|
|
r"""ParameterSet_TypeInfo() -> RTTI"""
|
|
return _datamodel.ParameterSet_TypeInfo()
|
|
|
|
def ParameterSet_Cast(*args):
|
|
r"""
|
|
ParameterSet_Cast(BaseObject o) -> ParameterSet
|
|
ParameterSet_Cast(Seiscomp::Core::BaseObjectPtr o) -> ParameterSet
|
|
"""
|
|
return _datamodel.ParameterSet_Cast(*args)
|
|
|
|
def ParameterSet_ConstCast(*args):
|
|
r"""
|
|
ParameterSet_ConstCast(BaseObject o) -> ParameterSet
|
|
ParameterSet_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ParameterSet
|
|
"""
|
|
return _datamodel.ParameterSet_ConstCast(*args)
|
|
|
|
def ParameterSet_Meta():
|
|
r"""ParameterSet_Meta() -> MetaObject"""
|
|
return _datamodel.ParameterSet_Meta()
|
|
|
|
def ParameterSet_Create(*args):
|
|
r"""
|
|
ParameterSet_Create() -> ParameterSet
|
|
ParameterSet_Create(std::string const & publicID) -> ParameterSet
|
|
"""
|
|
return _datamodel.ParameterSet_Create(*args)
|
|
|
|
def ParameterSet_Find(publicID):
|
|
r"""ParameterSet_Find(std::string const & publicID) -> ParameterSet"""
|
|
return _datamodel.ParameterSet_Find(publicID)
|
|
|
|
class SetupIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::SetupIndex 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__(SetupIndex self) -> SetupIndex
|
|
__init__(SetupIndex self, std::string const & name) -> SetupIndex
|
|
__init__(SetupIndex self, SetupIndex arg2) -> SetupIndex
|
|
"""
|
|
_datamodel.SetupIndex_swiginit(self, _datamodel.new_SetupIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(SetupIndex self, SetupIndex arg2) -> bool"""
|
|
return _datamodel.SetupIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(SetupIndex self, SetupIndex arg2) -> bool"""
|
|
return _datamodel.SetupIndex___ne__(self, arg2)
|
|
name = property(_datamodel.SetupIndex_name_get, _datamodel.SetupIndex_name_set, doc=r"""name : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_SetupIndex
|
|
|
|
# Register SetupIndex in _datamodel:
|
|
_datamodel.SetupIndex_swigregister(SetupIndex)
|
|
|
|
class Setup(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Setup 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 _datamodel.Setup_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Setup_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Setup self) -> char const *"""
|
|
return _datamodel.Setup_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Setup self) -> RTTI"""
|
|
return _datamodel.Setup_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Setup
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Setup
|
|
"""
|
|
return _datamodel.Setup_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Setup
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Setup
|
|
"""
|
|
return _datamodel.Setup_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Setup self, GenericArchive ar)"""
|
|
return _datamodel.Setup_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Setup_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Setup self) -> MetaObject"""
|
|
return _datamodel.Setup_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Setup self) -> Setup
|
|
__init__(Setup self, Setup other) -> Setup
|
|
"""
|
|
_datamodel.Setup_swiginit(self, _datamodel.new_Setup(*args))
|
|
__swig_destroy__ = _datamodel.delete_Setup
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Setup self, Setup other) -> bool"""
|
|
return _datamodel.Setup___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Setup self, Setup other) -> bool"""
|
|
return _datamodel.Setup___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Setup self, Setup other) -> bool"""
|
|
return _datamodel.Setup_equal(self, other)
|
|
|
|
def setName(self, name):
|
|
r"""setName(Setup self, std::string const & name)"""
|
|
return _datamodel.Setup_setName(self, name)
|
|
|
|
def name(self):
|
|
r"""name(Setup self) -> std::string const &"""
|
|
return _datamodel.Setup_name(self)
|
|
|
|
def setParameterSetID(self, parameterSetID):
|
|
r"""setParameterSetID(Setup self, std::string const & parameterSetID)"""
|
|
return _datamodel.Setup_setParameterSetID(self, parameterSetID)
|
|
|
|
def parameterSetID(self):
|
|
r"""parameterSetID(Setup self) -> std::string const &"""
|
|
return _datamodel.Setup_parameterSetID(self)
|
|
|
|
def setEnabled(self, enabled):
|
|
r"""setEnabled(Setup self, bool enabled)"""
|
|
return _datamodel.Setup_setEnabled(self, enabled)
|
|
|
|
def enabled(self):
|
|
r"""enabled(Setup self) -> bool"""
|
|
return _datamodel.Setup_enabled(self)
|
|
|
|
def index(self):
|
|
r"""index(Setup self) -> SetupIndex"""
|
|
return _datamodel.Setup_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(Setup self, Setup lhs) -> bool"""
|
|
return _datamodel.Setup_equalIndex(self, lhs)
|
|
|
|
def configStation(self):
|
|
r"""configStation(Setup self) -> ConfigStation"""
|
|
return _datamodel.Setup_configStation(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Setup self, Object other) -> bool"""
|
|
return _datamodel.Setup_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Setup self, PublicObject parent) -> bool"""
|
|
return _datamodel.Setup_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Setup self, PublicObject parent) -> bool"""
|
|
return _datamodel.Setup_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Setup self) -> bool"""
|
|
return _datamodel.Setup_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Setup self) -> Object"""
|
|
return _datamodel.Setup_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Setup self, Visitor visitor)"""
|
|
return _datamodel.Setup_accept(self, visitor)
|
|
|
|
# Register Setup in _datamodel:
|
|
_datamodel.Setup_swigregister(Setup)
|
|
|
|
def Setup_ClassName():
|
|
r"""Setup_ClassName() -> char const *"""
|
|
return _datamodel.Setup_ClassName()
|
|
|
|
def Setup_TypeInfo():
|
|
r"""Setup_TypeInfo() -> RTTI"""
|
|
return _datamodel.Setup_TypeInfo()
|
|
|
|
def Setup_Cast(*args):
|
|
r"""
|
|
Setup_Cast(BaseObject o) -> Setup
|
|
Setup_Cast(Seiscomp::Core::BaseObjectPtr o) -> Setup
|
|
"""
|
|
return _datamodel.Setup_Cast(*args)
|
|
|
|
def Setup_ConstCast(*args):
|
|
r"""
|
|
Setup_ConstCast(BaseObject o) -> Setup
|
|
Setup_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Setup
|
|
"""
|
|
return _datamodel.Setup_ConstCast(*args)
|
|
|
|
def Setup_Meta():
|
|
r"""Setup_Meta() -> MetaObject"""
|
|
return _datamodel.Setup_Meta()
|
|
|
|
class ConfigStationIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ConfigStationIndex 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__(ConfigStationIndex self) -> ConfigStationIndex
|
|
__init__(ConfigStationIndex self, std::string const & networkCode, std::string const & stationCode) -> ConfigStationIndex
|
|
__init__(ConfigStationIndex self, ConfigStationIndex arg2) -> ConfigStationIndex
|
|
"""
|
|
_datamodel.ConfigStationIndex_swiginit(self, _datamodel.new_ConfigStationIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(ConfigStationIndex self, ConfigStationIndex arg2) -> bool"""
|
|
return _datamodel.ConfigStationIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(ConfigStationIndex self, ConfigStationIndex arg2) -> bool"""
|
|
return _datamodel.ConfigStationIndex___ne__(self, arg2)
|
|
networkCode = property(_datamodel.ConfigStationIndex_networkCode_get, _datamodel.ConfigStationIndex_networkCode_set, doc=r"""networkCode : std::string""")
|
|
stationCode = property(_datamodel.ConfigStationIndex_stationCode_get, _datamodel.ConfigStationIndex_stationCode_set, doc=r"""stationCode : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_ConfigStationIndex
|
|
|
|
# Register ConfigStationIndex in _datamodel:
|
|
_datamodel.ConfigStationIndex_swigregister(ConfigStationIndex)
|
|
|
|
class ConfigStation(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ConfigStation 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 _datamodel.ConfigStation_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ConfigStation_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ConfigStation self) -> char const *"""
|
|
return _datamodel.ConfigStation_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ConfigStation self) -> RTTI"""
|
|
return _datamodel.ConfigStation_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ConfigStation
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfigStation
|
|
"""
|
|
return _datamodel.ConfigStation_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ConfigStation
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfigStation
|
|
"""
|
|
return _datamodel.ConfigStation_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ConfigStation self, GenericArchive ar)"""
|
|
return _datamodel.ConfigStation_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ConfigStation_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ConfigStation self) -> MetaObject"""
|
|
return _datamodel.ConfigStation_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ConfigStation self, ConfigStation other) -> ConfigStation
|
|
__init__(ConfigStation self, std::string const & publicID) -> ConfigStation
|
|
"""
|
|
_datamodel.ConfigStation_swiginit(self, _datamodel.new_ConfigStation(*args))
|
|
__swig_destroy__ = _datamodel.delete_ConfigStation
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> ConfigStation
|
|
Create(std::string const & publicID) -> ConfigStation
|
|
"""
|
|
return _datamodel.ConfigStation_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> ConfigStation"""
|
|
return _datamodel.ConfigStation_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ConfigStation self, ConfigStation other) -> bool"""
|
|
return _datamodel.ConfigStation___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ConfigStation self, ConfigStation other) -> bool"""
|
|
return _datamodel.ConfigStation___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ConfigStation self, ConfigStation other) -> bool"""
|
|
return _datamodel.ConfigStation_equal(self, other)
|
|
|
|
def setNetworkCode(self, networkCode):
|
|
r"""setNetworkCode(ConfigStation self, std::string const & networkCode)"""
|
|
return _datamodel.ConfigStation_setNetworkCode(self, networkCode)
|
|
|
|
def networkCode(self):
|
|
r"""networkCode(ConfigStation self) -> std::string const &"""
|
|
return _datamodel.ConfigStation_networkCode(self)
|
|
|
|
def setStationCode(self, stationCode):
|
|
r"""setStationCode(ConfigStation self, std::string const & stationCode)"""
|
|
return _datamodel.ConfigStation_setStationCode(self, stationCode)
|
|
|
|
def stationCode(self):
|
|
r"""stationCode(ConfigStation self) -> std::string const &"""
|
|
return _datamodel.ConfigStation_stationCode(self)
|
|
|
|
def setEnabled(self, enabled):
|
|
r"""setEnabled(ConfigStation self, bool enabled)"""
|
|
return _datamodel.ConfigStation_setEnabled(self, enabled)
|
|
|
|
def enabled(self):
|
|
r"""enabled(ConfigStation self) -> bool"""
|
|
return _datamodel.ConfigStation_enabled(self)
|
|
|
|
def setCreationInfo(self, creationInfo):
|
|
r"""setCreationInfo(ConfigStation self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
|
|
return _datamodel.ConfigStation_setCreationInfo(self, creationInfo)
|
|
|
|
def creationInfo(self, *args):
|
|
r"""
|
|
creationInfo(ConfigStation self) -> CreationInfo
|
|
creationInfo(ConfigStation self) -> CreationInfo
|
|
"""
|
|
return _datamodel.ConfigStation_creationInfo(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(ConfigStation self) -> ConfigStationIndex"""
|
|
return _datamodel.ConfigStation_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(ConfigStation self, ConfigStation lhs) -> bool"""
|
|
return _datamodel.ConfigStation_equalIndex(self, lhs)
|
|
|
|
def add(self, obj):
|
|
r"""add(ConfigStation self, Setup obj) -> bool"""
|
|
return _datamodel.ConfigStation_add(self, obj)
|
|
|
|
def remove(self, obj):
|
|
r"""remove(ConfigStation self, Setup obj) -> bool"""
|
|
return _datamodel.ConfigStation_remove(self, obj)
|
|
|
|
def removeSetup(self, *args):
|
|
r"""
|
|
removeSetup(ConfigStation self, size_t i) -> bool
|
|
removeSetup(ConfigStation self, SetupIndex i) -> bool
|
|
"""
|
|
return _datamodel.ConfigStation_removeSetup(self, *args)
|
|
|
|
def setupCount(self):
|
|
r"""setupCount(ConfigStation self) -> size_t"""
|
|
return _datamodel.ConfigStation_setupCount(self)
|
|
|
|
def setup(self, *args):
|
|
r"""
|
|
setup(ConfigStation self, size_t i) -> Setup
|
|
setup(ConfigStation self, SetupIndex i) -> Setup
|
|
"""
|
|
return _datamodel.ConfigStation_setup(self, *args)
|
|
|
|
def configModule(self):
|
|
r"""configModule(ConfigStation self) -> ConfigModule"""
|
|
return _datamodel.ConfigStation_configModule(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(ConfigStation self, Object other) -> bool"""
|
|
return _datamodel.ConfigStation_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(ConfigStation self, PublicObject parent) -> bool"""
|
|
return _datamodel.ConfigStation_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(ConfigStation self, PublicObject parent) -> bool"""
|
|
return _datamodel.ConfigStation_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(ConfigStation self) -> bool"""
|
|
return _datamodel.ConfigStation_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(ConfigStation self) -> Object"""
|
|
return _datamodel.ConfigStation_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(ConfigStation self, Object child) -> bool"""
|
|
return _datamodel.ConfigStation_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(ConfigStation self, Visitor visitor)"""
|
|
return _datamodel.ConfigStation_accept(self, visitor)
|
|
|
|
# Register ConfigStation in _datamodel:
|
|
_datamodel.ConfigStation_swigregister(ConfigStation)
|
|
|
|
def ConfigStation_ClassName():
|
|
r"""ConfigStation_ClassName() -> char const *"""
|
|
return _datamodel.ConfigStation_ClassName()
|
|
|
|
def ConfigStation_TypeInfo():
|
|
r"""ConfigStation_TypeInfo() -> RTTI"""
|
|
return _datamodel.ConfigStation_TypeInfo()
|
|
|
|
def ConfigStation_Cast(*args):
|
|
r"""
|
|
ConfigStation_Cast(BaseObject o) -> ConfigStation
|
|
ConfigStation_Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfigStation
|
|
"""
|
|
return _datamodel.ConfigStation_Cast(*args)
|
|
|
|
def ConfigStation_ConstCast(*args):
|
|
r"""
|
|
ConfigStation_ConstCast(BaseObject o) -> ConfigStation
|
|
ConfigStation_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfigStation
|
|
"""
|
|
return _datamodel.ConfigStation_ConstCast(*args)
|
|
|
|
def ConfigStation_Meta():
|
|
r"""ConfigStation_Meta() -> MetaObject"""
|
|
return _datamodel.ConfigStation_Meta()
|
|
|
|
def ConfigStation_Create(*args):
|
|
r"""
|
|
ConfigStation_Create() -> ConfigStation
|
|
ConfigStation_Create(std::string const & publicID) -> ConfigStation
|
|
"""
|
|
return _datamodel.ConfigStation_Create(*args)
|
|
|
|
def ConfigStation_Find(publicID):
|
|
r"""ConfigStation_Find(std::string const & publicID) -> ConfigStation"""
|
|
return _datamodel.ConfigStation_Find(publicID)
|
|
|
|
class ConfigModule(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ConfigModule 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 _datamodel.ConfigModule_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ConfigModule_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ConfigModule self) -> char const *"""
|
|
return _datamodel.ConfigModule_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ConfigModule self) -> RTTI"""
|
|
return _datamodel.ConfigModule_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ConfigModule
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfigModule
|
|
"""
|
|
return _datamodel.ConfigModule_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ConfigModule
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfigModule
|
|
"""
|
|
return _datamodel.ConfigModule_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ConfigModule self, GenericArchive ar)"""
|
|
return _datamodel.ConfigModule_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ConfigModule_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ConfigModule self) -> MetaObject"""
|
|
return _datamodel.ConfigModule_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ConfigModule self, ConfigModule other) -> ConfigModule
|
|
__init__(ConfigModule self, std::string const & publicID) -> ConfigModule
|
|
"""
|
|
_datamodel.ConfigModule_swiginit(self, _datamodel.new_ConfigModule(*args))
|
|
__swig_destroy__ = _datamodel.delete_ConfigModule
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> ConfigModule
|
|
Create(std::string const & publicID) -> ConfigModule
|
|
"""
|
|
return _datamodel.ConfigModule_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> ConfigModule"""
|
|
return _datamodel.ConfigModule_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ConfigModule self, ConfigModule other) -> bool"""
|
|
return _datamodel.ConfigModule___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ConfigModule self, ConfigModule other) -> bool"""
|
|
return _datamodel.ConfigModule___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ConfigModule self, ConfigModule other) -> bool"""
|
|
return _datamodel.ConfigModule_equal(self, other)
|
|
|
|
def setName(self, name):
|
|
r"""setName(ConfigModule self, std::string const & name)"""
|
|
return _datamodel.ConfigModule_setName(self, name)
|
|
|
|
def name(self):
|
|
r"""name(ConfigModule self) -> std::string const &"""
|
|
return _datamodel.ConfigModule_name(self)
|
|
|
|
def setParameterSetID(self, parameterSetID):
|
|
r"""setParameterSetID(ConfigModule self, std::string const & parameterSetID)"""
|
|
return _datamodel.ConfigModule_setParameterSetID(self, parameterSetID)
|
|
|
|
def parameterSetID(self):
|
|
r"""parameterSetID(ConfigModule self) -> std::string const &"""
|
|
return _datamodel.ConfigModule_parameterSetID(self)
|
|
|
|
def setEnabled(self, enabled):
|
|
r"""setEnabled(ConfigModule self, bool enabled)"""
|
|
return _datamodel.ConfigModule_setEnabled(self, enabled)
|
|
|
|
def enabled(self):
|
|
r"""enabled(ConfigModule self) -> bool"""
|
|
return _datamodel.ConfigModule_enabled(self)
|
|
|
|
def add(self, obj):
|
|
r"""add(ConfigModule self, ConfigStation obj) -> bool"""
|
|
return _datamodel.ConfigModule_add(self, obj)
|
|
|
|
def remove(self, obj):
|
|
r"""remove(ConfigModule self, ConfigStation obj) -> bool"""
|
|
return _datamodel.ConfigModule_remove(self, obj)
|
|
|
|
def removeConfigStation(self, *args):
|
|
r"""
|
|
removeConfigStation(ConfigModule self, size_t i) -> bool
|
|
removeConfigStation(ConfigModule self, ConfigStationIndex i) -> bool
|
|
"""
|
|
return _datamodel.ConfigModule_removeConfigStation(self, *args)
|
|
|
|
def configStationCount(self):
|
|
r"""configStationCount(ConfigModule self) -> size_t"""
|
|
return _datamodel.ConfigModule_configStationCount(self)
|
|
|
|
def configStation(self, *args):
|
|
r"""
|
|
configStation(ConfigModule self, size_t i) -> ConfigStation
|
|
configStation(ConfigModule self, ConfigStationIndex i) -> ConfigStation
|
|
"""
|
|
return _datamodel.ConfigModule_configStation(self, *args)
|
|
|
|
def findConfigStation(self, publicID):
|
|
r"""findConfigStation(ConfigModule self, std::string const & publicID) -> ConfigStation"""
|
|
return _datamodel.ConfigModule_findConfigStation(self, publicID)
|
|
|
|
def config(self):
|
|
r"""config(ConfigModule self) -> Config"""
|
|
return _datamodel.ConfigModule_config(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(ConfigModule self, Object other) -> bool"""
|
|
return _datamodel.ConfigModule_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(ConfigModule self, PublicObject parent) -> bool"""
|
|
return _datamodel.ConfigModule_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(ConfigModule self, PublicObject parent) -> bool"""
|
|
return _datamodel.ConfigModule_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(ConfigModule self) -> bool"""
|
|
return _datamodel.ConfigModule_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(ConfigModule self) -> Object"""
|
|
return _datamodel.ConfigModule_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(ConfigModule self, Object child) -> bool"""
|
|
return _datamodel.ConfigModule_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(ConfigModule self, Visitor visitor)"""
|
|
return _datamodel.ConfigModule_accept(self, visitor)
|
|
|
|
# Register ConfigModule in _datamodel:
|
|
_datamodel.ConfigModule_swigregister(ConfigModule)
|
|
|
|
def ConfigModule_ClassName():
|
|
r"""ConfigModule_ClassName() -> char const *"""
|
|
return _datamodel.ConfigModule_ClassName()
|
|
|
|
def ConfigModule_TypeInfo():
|
|
r"""ConfigModule_TypeInfo() -> RTTI"""
|
|
return _datamodel.ConfigModule_TypeInfo()
|
|
|
|
def ConfigModule_Cast(*args):
|
|
r"""
|
|
ConfigModule_Cast(BaseObject o) -> ConfigModule
|
|
ConfigModule_Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfigModule
|
|
"""
|
|
return _datamodel.ConfigModule_Cast(*args)
|
|
|
|
def ConfigModule_ConstCast(*args):
|
|
r"""
|
|
ConfigModule_ConstCast(BaseObject o) -> ConfigModule
|
|
ConfigModule_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfigModule
|
|
"""
|
|
return _datamodel.ConfigModule_ConstCast(*args)
|
|
|
|
def ConfigModule_Meta():
|
|
r"""ConfigModule_Meta() -> MetaObject"""
|
|
return _datamodel.ConfigModule_Meta()
|
|
|
|
def ConfigModule_Create(*args):
|
|
r"""
|
|
ConfigModule_Create() -> ConfigModule
|
|
ConfigModule_Create(std::string const & publicID) -> ConfigModule
|
|
"""
|
|
return _datamodel.ConfigModule_Create(*args)
|
|
|
|
def ConfigModule_Find(publicID):
|
|
r"""ConfigModule_Find(std::string const & publicID) -> ConfigModule"""
|
|
return _datamodel.ConfigModule_Find(publicID)
|
|
|
|
class Config(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Config 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 _datamodel.Config_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Config_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Config self) -> char const *"""
|
|
return _datamodel.Config_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Config self) -> RTTI"""
|
|
return _datamodel.Config_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Config
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Config
|
|
"""
|
|
return _datamodel.Config_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Config
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Config
|
|
"""
|
|
return _datamodel.Config_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Config self, GenericArchive ar)"""
|
|
return _datamodel.Config_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Config_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Config self) -> MetaObject"""
|
|
return _datamodel.Config_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Config self) -> Config
|
|
__init__(Config self, Config other) -> Config
|
|
"""
|
|
_datamodel.Config_swiginit(self, _datamodel.new_Config(*args))
|
|
__swig_destroy__ = _datamodel.delete_Config
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Config self, Config other) -> bool"""
|
|
return _datamodel.Config___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Config self, Config other) -> bool"""
|
|
return _datamodel.Config___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Config self, Config other) -> bool"""
|
|
return _datamodel.Config_equal(self, other)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(Config self, ParameterSet obj) -> bool
|
|
add(Config self, ConfigModule obj) -> bool
|
|
"""
|
|
return _datamodel.Config_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(Config self, ParameterSet obj) -> bool
|
|
remove(Config self, ConfigModule obj) -> bool
|
|
"""
|
|
return _datamodel.Config_remove(self, *args)
|
|
|
|
def removeParameterSet(self, i):
|
|
r"""removeParameterSet(Config self, size_t i) -> bool"""
|
|
return _datamodel.Config_removeParameterSet(self, i)
|
|
|
|
def removeConfigModule(self, i):
|
|
r"""removeConfigModule(Config self, size_t i) -> bool"""
|
|
return _datamodel.Config_removeConfigModule(self, i)
|
|
|
|
def parameterSetCount(self):
|
|
r"""parameterSetCount(Config self) -> size_t"""
|
|
return _datamodel.Config_parameterSetCount(self)
|
|
|
|
def configModuleCount(self):
|
|
r"""configModuleCount(Config self) -> size_t"""
|
|
return _datamodel.Config_configModuleCount(self)
|
|
|
|
def parameterSet(self, i):
|
|
r"""parameterSet(Config self, size_t i) -> ParameterSet"""
|
|
return _datamodel.Config_parameterSet(self, i)
|
|
|
|
def configModule(self, i):
|
|
r"""configModule(Config self, size_t i) -> ConfigModule"""
|
|
return _datamodel.Config_configModule(self, i)
|
|
|
|
def findParameterSet(self, publicID):
|
|
r"""findParameterSet(Config self, std::string const & publicID) -> ParameterSet"""
|
|
return _datamodel.Config_findParameterSet(self, publicID)
|
|
|
|
def findConfigModule(self, publicID):
|
|
r"""findConfigModule(Config self, std::string const & publicID) -> ConfigModule"""
|
|
return _datamodel.Config_findConfigModule(self, publicID)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Config self, Object other) -> bool"""
|
|
return _datamodel.Config_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Config self, PublicObject parent) -> bool"""
|
|
return _datamodel.Config_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Config self, PublicObject parent) -> bool"""
|
|
return _datamodel.Config_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Config self) -> bool"""
|
|
return _datamodel.Config_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Config self) -> Object"""
|
|
return _datamodel.Config_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Config self, Object child) -> bool"""
|
|
return _datamodel.Config_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Config self, Visitor visitor)"""
|
|
return _datamodel.Config_accept(self, visitor)
|
|
|
|
# Register Config in _datamodel:
|
|
_datamodel.Config_swigregister(Config)
|
|
|
|
def Config_ClassName():
|
|
r"""Config_ClassName() -> char const *"""
|
|
return _datamodel.Config_ClassName()
|
|
|
|
def Config_TypeInfo():
|
|
r"""Config_TypeInfo() -> RTTI"""
|
|
return _datamodel.Config_TypeInfo()
|
|
|
|
def Config_Cast(*args):
|
|
r"""
|
|
Config_Cast(BaseObject o) -> Config
|
|
Config_Cast(Seiscomp::Core::BaseObjectPtr o) -> Config
|
|
"""
|
|
return _datamodel.Config_Cast(*args)
|
|
|
|
def Config_ConstCast(*args):
|
|
r"""
|
|
Config_ConstCast(BaseObject o) -> Config
|
|
Config_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Config
|
|
"""
|
|
return _datamodel.Config_ConstCast(*args)
|
|
|
|
def Config_Meta():
|
|
r"""Config_Meta() -> MetaObject"""
|
|
return _datamodel.Config_Meta()
|
|
|
|
class QCLogIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::QCLogIndex 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__(QCLogIndex self) -> QCLogIndex
|
|
__init__(QCLogIndex self, Time start, WaveformStreamID waveformID) -> QCLogIndex
|
|
__init__(QCLogIndex self, QCLogIndex arg2) -> QCLogIndex
|
|
"""
|
|
_datamodel.QCLogIndex_swiginit(self, _datamodel.new_QCLogIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(QCLogIndex self, QCLogIndex arg2) -> bool"""
|
|
return _datamodel.QCLogIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(QCLogIndex self, QCLogIndex arg2) -> bool"""
|
|
return _datamodel.QCLogIndex___ne__(self, arg2)
|
|
start = property(_datamodel.QCLogIndex_start_get, _datamodel.QCLogIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
|
|
waveformID = property(_datamodel.QCLogIndex_waveformID_get, _datamodel.QCLogIndex_waveformID_set, doc=r"""waveformID : Seiscomp::DataModel::WaveformStreamID""")
|
|
__swig_destroy__ = _datamodel.delete_QCLogIndex
|
|
|
|
# Register QCLogIndex in _datamodel:
|
|
_datamodel.QCLogIndex_swigregister(QCLogIndex)
|
|
|
|
class QCLog(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::QCLog 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 _datamodel.QCLog_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.QCLog_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(QCLog self) -> char const *"""
|
|
return _datamodel.QCLog_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(QCLog self) -> RTTI"""
|
|
return _datamodel.QCLog_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> QCLog
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> QCLog
|
|
"""
|
|
return _datamodel.QCLog_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> QCLog
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> QCLog
|
|
"""
|
|
return _datamodel.QCLog_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(QCLog self, GenericArchive ar)"""
|
|
return _datamodel.QCLog_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.QCLog_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(QCLog self) -> MetaObject"""
|
|
return _datamodel.QCLog_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(QCLog self, QCLog other) -> QCLog
|
|
__init__(QCLog self, std::string const & publicID) -> QCLog
|
|
"""
|
|
_datamodel.QCLog_swiginit(self, _datamodel.new_QCLog(*args))
|
|
__swig_destroy__ = _datamodel.delete_QCLog
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> QCLog
|
|
Create(std::string const & publicID) -> QCLog
|
|
"""
|
|
return _datamodel.QCLog_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> QCLog"""
|
|
return _datamodel.QCLog_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(QCLog self, QCLog other) -> bool"""
|
|
return _datamodel.QCLog___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(QCLog self, QCLog other) -> bool"""
|
|
return _datamodel.QCLog___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(QCLog self, QCLog other) -> bool"""
|
|
return _datamodel.QCLog_equal(self, other)
|
|
|
|
def setWaveformID(self, waveformID):
|
|
r"""setWaveformID(QCLog self, WaveformStreamID waveformID)"""
|
|
return _datamodel.QCLog_setWaveformID(self, waveformID)
|
|
|
|
def waveformID(self, *args):
|
|
r"""
|
|
waveformID(QCLog self) -> WaveformStreamID
|
|
waveformID(QCLog self) -> WaveformStreamID
|
|
"""
|
|
return _datamodel.QCLog_waveformID(self, *args)
|
|
|
|
def setCreatorID(self, creatorID):
|
|
r"""setCreatorID(QCLog self, std::string const & creatorID)"""
|
|
return _datamodel.QCLog_setCreatorID(self, creatorID)
|
|
|
|
def creatorID(self):
|
|
r"""creatorID(QCLog self) -> std::string const &"""
|
|
return _datamodel.QCLog_creatorID(self)
|
|
|
|
def setCreated(self, created):
|
|
r"""setCreated(QCLog self, Time created)"""
|
|
return _datamodel.QCLog_setCreated(self, created)
|
|
|
|
def created(self):
|
|
r"""created(QCLog self) -> Time"""
|
|
return _datamodel.QCLog_created(self)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(QCLog self, Time start)"""
|
|
return _datamodel.QCLog_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(QCLog self) -> Time"""
|
|
return _datamodel.QCLog_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(QCLog self, Time end)"""
|
|
return _datamodel.QCLog_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(QCLog self) -> Time"""
|
|
return _datamodel.QCLog_end(self)
|
|
|
|
def setMessage(self, message):
|
|
r"""setMessage(QCLog self, std::string const & message)"""
|
|
return _datamodel.QCLog_setMessage(self, message)
|
|
|
|
def message(self):
|
|
r"""message(QCLog self) -> std::string const &"""
|
|
return _datamodel.QCLog_message(self)
|
|
|
|
def index(self):
|
|
r"""index(QCLog self) -> QCLogIndex"""
|
|
return _datamodel.QCLog_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(QCLog self, QCLog lhs) -> bool"""
|
|
return _datamodel.QCLog_equalIndex(self, lhs)
|
|
|
|
def qualityControl(self):
|
|
r"""qualityControl(QCLog self) -> QualityControl"""
|
|
return _datamodel.QCLog_qualityControl(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(QCLog self, Object other) -> bool"""
|
|
return _datamodel.QCLog_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(QCLog self, PublicObject parent) -> bool"""
|
|
return _datamodel.QCLog_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(QCLog self, PublicObject parent) -> bool"""
|
|
return _datamodel.QCLog_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(QCLog self) -> bool"""
|
|
return _datamodel.QCLog_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(QCLog self) -> Object"""
|
|
return _datamodel.QCLog_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(QCLog self, Object child) -> bool"""
|
|
return _datamodel.QCLog_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(QCLog self, Visitor visitor)"""
|
|
return _datamodel.QCLog_accept(self, visitor)
|
|
|
|
# Register QCLog in _datamodel:
|
|
_datamodel.QCLog_swigregister(QCLog)
|
|
|
|
def QCLog_ClassName():
|
|
r"""QCLog_ClassName() -> char const *"""
|
|
return _datamodel.QCLog_ClassName()
|
|
|
|
def QCLog_TypeInfo():
|
|
r"""QCLog_TypeInfo() -> RTTI"""
|
|
return _datamodel.QCLog_TypeInfo()
|
|
|
|
def QCLog_Cast(*args):
|
|
r"""
|
|
QCLog_Cast(BaseObject o) -> QCLog
|
|
QCLog_Cast(Seiscomp::Core::BaseObjectPtr o) -> QCLog
|
|
"""
|
|
return _datamodel.QCLog_Cast(*args)
|
|
|
|
def QCLog_ConstCast(*args):
|
|
r"""
|
|
QCLog_ConstCast(BaseObject o) -> QCLog
|
|
QCLog_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> QCLog
|
|
"""
|
|
return _datamodel.QCLog_ConstCast(*args)
|
|
|
|
def QCLog_Meta():
|
|
r"""QCLog_Meta() -> MetaObject"""
|
|
return _datamodel.QCLog_Meta()
|
|
|
|
def QCLog_Create(*args):
|
|
r"""
|
|
QCLog_Create() -> QCLog
|
|
QCLog_Create(std::string const & publicID) -> QCLog
|
|
"""
|
|
return _datamodel.QCLog_Create(*args)
|
|
|
|
def QCLog_Find(publicID):
|
|
r"""QCLog_Find(std::string const & publicID) -> QCLog"""
|
|
return _datamodel.QCLog_Find(publicID)
|
|
|
|
class WaveformQualityIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::WaveformQualityIndex 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__(WaveformQualityIndex self) -> WaveformQualityIndex
|
|
__init__(WaveformQualityIndex self, Time start, WaveformStreamID waveformID, std::string const & type, std::string const & parameter) -> WaveformQualityIndex
|
|
__init__(WaveformQualityIndex self, WaveformQualityIndex arg2) -> WaveformQualityIndex
|
|
"""
|
|
_datamodel.WaveformQualityIndex_swiginit(self, _datamodel.new_WaveformQualityIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(WaveformQualityIndex self, WaveformQualityIndex arg2) -> bool"""
|
|
return _datamodel.WaveformQualityIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(WaveformQualityIndex self, WaveformQualityIndex arg2) -> bool"""
|
|
return _datamodel.WaveformQualityIndex___ne__(self, arg2)
|
|
start = property(_datamodel.WaveformQualityIndex_start_get, _datamodel.WaveformQualityIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
|
|
waveformID = property(_datamodel.WaveformQualityIndex_waveformID_get, _datamodel.WaveformQualityIndex_waveformID_set, doc=r"""waveformID : Seiscomp::DataModel::WaveformStreamID""")
|
|
type = property(_datamodel.WaveformQualityIndex_type_get, _datamodel.WaveformQualityIndex_type_set, doc=r"""type : std::string""")
|
|
parameter = property(_datamodel.WaveformQualityIndex_parameter_get, _datamodel.WaveformQualityIndex_parameter_set, doc=r"""parameter : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_WaveformQualityIndex
|
|
|
|
# Register WaveformQualityIndex in _datamodel:
|
|
_datamodel.WaveformQualityIndex_swigregister(WaveformQualityIndex)
|
|
|
|
class WaveformQuality(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::WaveformQuality 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 _datamodel.WaveformQuality_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.WaveformQuality_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(WaveformQuality self) -> char const *"""
|
|
return _datamodel.WaveformQuality_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(WaveformQuality self) -> RTTI"""
|
|
return _datamodel.WaveformQuality_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> WaveformQuality
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> WaveformQuality
|
|
"""
|
|
return _datamodel.WaveformQuality_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> WaveformQuality
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> WaveformQuality
|
|
"""
|
|
return _datamodel.WaveformQuality_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(WaveformQuality self, GenericArchive ar)"""
|
|
return _datamodel.WaveformQuality_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.WaveformQuality_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(WaveformQuality self) -> MetaObject"""
|
|
return _datamodel.WaveformQuality_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(WaveformQuality self) -> WaveformQuality
|
|
__init__(WaveformQuality self, WaveformQuality other) -> WaveformQuality
|
|
"""
|
|
_datamodel.WaveformQuality_swiginit(self, _datamodel.new_WaveformQuality(*args))
|
|
__swig_destroy__ = _datamodel.delete_WaveformQuality
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(WaveformQuality self, WaveformQuality other) -> bool"""
|
|
return _datamodel.WaveformQuality___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(WaveformQuality self, WaveformQuality other) -> bool"""
|
|
return _datamodel.WaveformQuality___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(WaveformQuality self, WaveformQuality other) -> bool"""
|
|
return _datamodel.WaveformQuality_equal(self, other)
|
|
|
|
def setWaveformID(self, waveformID):
|
|
r"""setWaveformID(WaveformQuality self, WaveformStreamID waveformID)"""
|
|
return _datamodel.WaveformQuality_setWaveformID(self, waveformID)
|
|
|
|
def waveformID(self, *args):
|
|
r"""
|
|
waveformID(WaveformQuality self) -> WaveformStreamID
|
|
waveformID(WaveformQuality self) -> WaveformStreamID
|
|
"""
|
|
return _datamodel.WaveformQuality_waveformID(self, *args)
|
|
|
|
def setCreatorID(self, creatorID):
|
|
r"""setCreatorID(WaveformQuality self, std::string const & creatorID)"""
|
|
return _datamodel.WaveformQuality_setCreatorID(self, creatorID)
|
|
|
|
def creatorID(self):
|
|
r"""creatorID(WaveformQuality self) -> std::string const &"""
|
|
return _datamodel.WaveformQuality_creatorID(self)
|
|
|
|
def setCreated(self, created):
|
|
r"""setCreated(WaveformQuality self, Time created)"""
|
|
return _datamodel.WaveformQuality_setCreated(self, created)
|
|
|
|
def created(self):
|
|
r"""created(WaveformQuality self) -> Time"""
|
|
return _datamodel.WaveformQuality_created(self)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(WaveformQuality self, Time start)"""
|
|
return _datamodel.WaveformQuality_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(WaveformQuality self) -> Time"""
|
|
return _datamodel.WaveformQuality_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(WaveformQuality self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
|
|
return _datamodel.WaveformQuality_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(WaveformQuality self) -> Time"""
|
|
return _datamodel.WaveformQuality_end(self)
|
|
|
|
def setType(self, type):
|
|
r"""setType(WaveformQuality self, std::string const & type)"""
|
|
return _datamodel.WaveformQuality_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(WaveformQuality self) -> std::string const &"""
|
|
return _datamodel.WaveformQuality_type(self)
|
|
|
|
def setParameter(self, parameter):
|
|
r"""setParameter(WaveformQuality self, std::string const & parameter)"""
|
|
return _datamodel.WaveformQuality_setParameter(self, parameter)
|
|
|
|
def parameter(self):
|
|
r"""parameter(WaveformQuality self) -> std::string const &"""
|
|
return _datamodel.WaveformQuality_parameter(self)
|
|
|
|
def setValue(self, value):
|
|
r"""setValue(WaveformQuality self, double value)"""
|
|
return _datamodel.WaveformQuality_setValue(self, value)
|
|
|
|
def value(self):
|
|
r"""value(WaveformQuality self) -> double"""
|
|
return _datamodel.WaveformQuality_value(self)
|
|
|
|
def setLowerUncertainty(self, lowerUncertainty):
|
|
r"""setLowerUncertainty(WaveformQuality self, Seiscomp::Core::Optional< double >::Impl const & lowerUncertainty)"""
|
|
return _datamodel.WaveformQuality_setLowerUncertainty(self, lowerUncertainty)
|
|
|
|
def lowerUncertainty(self):
|
|
r"""lowerUncertainty(WaveformQuality self) -> double"""
|
|
return _datamodel.WaveformQuality_lowerUncertainty(self)
|
|
|
|
def setUpperUncertainty(self, upperUncertainty):
|
|
r"""setUpperUncertainty(WaveformQuality self, Seiscomp::Core::Optional< double >::Impl const & upperUncertainty)"""
|
|
return _datamodel.WaveformQuality_setUpperUncertainty(self, upperUncertainty)
|
|
|
|
def upperUncertainty(self):
|
|
r"""upperUncertainty(WaveformQuality self) -> double"""
|
|
return _datamodel.WaveformQuality_upperUncertainty(self)
|
|
|
|
def setWindowLength(self, windowLength):
|
|
r"""setWindowLength(WaveformQuality self, Seiscomp::Core::Optional< double >::Impl const & windowLength)"""
|
|
return _datamodel.WaveformQuality_setWindowLength(self, windowLength)
|
|
|
|
def windowLength(self):
|
|
r"""windowLength(WaveformQuality self) -> double"""
|
|
return _datamodel.WaveformQuality_windowLength(self)
|
|
|
|
def index(self):
|
|
r"""index(WaveformQuality self) -> WaveformQualityIndex"""
|
|
return _datamodel.WaveformQuality_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(WaveformQuality self, WaveformQuality lhs) -> bool"""
|
|
return _datamodel.WaveformQuality_equalIndex(self, lhs)
|
|
|
|
def qualityControl(self):
|
|
r"""qualityControl(WaveformQuality self) -> QualityControl"""
|
|
return _datamodel.WaveformQuality_qualityControl(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(WaveformQuality self, Object other) -> bool"""
|
|
return _datamodel.WaveformQuality_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(WaveformQuality self, PublicObject parent) -> bool"""
|
|
return _datamodel.WaveformQuality_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(WaveformQuality self, PublicObject parent) -> bool"""
|
|
return _datamodel.WaveformQuality_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(WaveformQuality self) -> bool"""
|
|
return _datamodel.WaveformQuality_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(WaveformQuality self) -> Object"""
|
|
return _datamodel.WaveformQuality_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(WaveformQuality self, Visitor visitor)"""
|
|
return _datamodel.WaveformQuality_accept(self, visitor)
|
|
|
|
# Register WaveformQuality in _datamodel:
|
|
_datamodel.WaveformQuality_swigregister(WaveformQuality)
|
|
|
|
def WaveformQuality_ClassName():
|
|
r"""WaveformQuality_ClassName() -> char const *"""
|
|
return _datamodel.WaveformQuality_ClassName()
|
|
|
|
def WaveformQuality_TypeInfo():
|
|
r"""WaveformQuality_TypeInfo() -> RTTI"""
|
|
return _datamodel.WaveformQuality_TypeInfo()
|
|
|
|
def WaveformQuality_Cast(*args):
|
|
r"""
|
|
WaveformQuality_Cast(BaseObject o) -> WaveformQuality
|
|
WaveformQuality_Cast(Seiscomp::Core::BaseObjectPtr o) -> WaveformQuality
|
|
"""
|
|
return _datamodel.WaveformQuality_Cast(*args)
|
|
|
|
def WaveformQuality_ConstCast(*args):
|
|
r"""
|
|
WaveformQuality_ConstCast(BaseObject o) -> WaveformQuality
|
|
WaveformQuality_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> WaveformQuality
|
|
"""
|
|
return _datamodel.WaveformQuality_ConstCast(*args)
|
|
|
|
def WaveformQuality_Meta():
|
|
r"""WaveformQuality_Meta() -> MetaObject"""
|
|
return _datamodel.WaveformQuality_Meta()
|
|
|
|
class OutageIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::OutageIndex 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__(OutageIndex self) -> OutageIndex
|
|
__init__(OutageIndex self, WaveformStreamID waveformID, Time start) -> OutageIndex
|
|
__init__(OutageIndex self, OutageIndex arg2) -> OutageIndex
|
|
"""
|
|
_datamodel.OutageIndex_swiginit(self, _datamodel.new_OutageIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(OutageIndex self, OutageIndex arg2) -> bool"""
|
|
return _datamodel.OutageIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(OutageIndex self, OutageIndex arg2) -> bool"""
|
|
return _datamodel.OutageIndex___ne__(self, arg2)
|
|
waveformID = property(_datamodel.OutageIndex_waveformID_get, _datamodel.OutageIndex_waveformID_set, doc=r"""waveformID : Seiscomp::DataModel::WaveformStreamID""")
|
|
start = property(_datamodel.OutageIndex_start_get, _datamodel.OutageIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
|
|
__swig_destroy__ = _datamodel.delete_OutageIndex
|
|
|
|
# Register OutageIndex in _datamodel:
|
|
_datamodel.OutageIndex_swigregister(OutageIndex)
|
|
|
|
class Outage(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Outage 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 _datamodel.Outage_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Outage_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Outage self) -> char const *"""
|
|
return _datamodel.Outage_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Outage self) -> RTTI"""
|
|
return _datamodel.Outage_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Outage
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Outage
|
|
"""
|
|
return _datamodel.Outage_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Outage
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Outage
|
|
"""
|
|
return _datamodel.Outage_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Outage self, GenericArchive ar)"""
|
|
return _datamodel.Outage_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Outage_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Outage self) -> MetaObject"""
|
|
return _datamodel.Outage_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Outage self) -> Outage
|
|
__init__(Outage self, Outage other) -> Outage
|
|
"""
|
|
_datamodel.Outage_swiginit(self, _datamodel.new_Outage(*args))
|
|
__swig_destroy__ = _datamodel.delete_Outage
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Outage self, Outage other) -> bool"""
|
|
return _datamodel.Outage___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Outage self, Outage other) -> bool"""
|
|
return _datamodel.Outage___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Outage self, Outage other) -> bool"""
|
|
return _datamodel.Outage_equal(self, other)
|
|
|
|
def setWaveformID(self, waveformID):
|
|
r"""setWaveformID(Outage self, WaveformStreamID waveformID)"""
|
|
return _datamodel.Outage_setWaveformID(self, waveformID)
|
|
|
|
def waveformID(self, *args):
|
|
r"""
|
|
waveformID(Outage self) -> WaveformStreamID
|
|
waveformID(Outage self) -> WaveformStreamID
|
|
"""
|
|
return _datamodel.Outage_waveformID(self, *args)
|
|
|
|
def setCreatorID(self, creatorID):
|
|
r"""setCreatorID(Outage self, std::string const & creatorID)"""
|
|
return _datamodel.Outage_setCreatorID(self, creatorID)
|
|
|
|
def creatorID(self):
|
|
r"""creatorID(Outage self) -> std::string const &"""
|
|
return _datamodel.Outage_creatorID(self)
|
|
|
|
def setCreated(self, created):
|
|
r"""setCreated(Outage self, Time created)"""
|
|
return _datamodel.Outage_setCreated(self, created)
|
|
|
|
def created(self):
|
|
r"""created(Outage self) -> Time"""
|
|
return _datamodel.Outage_created(self)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(Outage self, Time start)"""
|
|
return _datamodel.Outage_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(Outage self) -> Time"""
|
|
return _datamodel.Outage_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(Outage self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
|
|
return _datamodel.Outage_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(Outage self) -> Time"""
|
|
return _datamodel.Outage_end(self)
|
|
|
|
def index(self):
|
|
r"""index(Outage self) -> OutageIndex"""
|
|
return _datamodel.Outage_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(Outage self, Outage lhs) -> bool"""
|
|
return _datamodel.Outage_equalIndex(self, lhs)
|
|
|
|
def qualityControl(self):
|
|
r"""qualityControl(Outage self) -> QualityControl"""
|
|
return _datamodel.Outage_qualityControl(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Outage self, Object other) -> bool"""
|
|
return _datamodel.Outage_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Outage self, PublicObject parent) -> bool"""
|
|
return _datamodel.Outage_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Outage self, PublicObject parent) -> bool"""
|
|
return _datamodel.Outage_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Outage self) -> bool"""
|
|
return _datamodel.Outage_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Outage self) -> Object"""
|
|
return _datamodel.Outage_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Outage self, Visitor visitor)"""
|
|
return _datamodel.Outage_accept(self, visitor)
|
|
|
|
# Register Outage in _datamodel:
|
|
_datamodel.Outage_swigregister(Outage)
|
|
|
|
def Outage_ClassName():
|
|
r"""Outage_ClassName() -> char const *"""
|
|
return _datamodel.Outage_ClassName()
|
|
|
|
def Outage_TypeInfo():
|
|
r"""Outage_TypeInfo() -> RTTI"""
|
|
return _datamodel.Outage_TypeInfo()
|
|
|
|
def Outage_Cast(*args):
|
|
r"""
|
|
Outage_Cast(BaseObject o) -> Outage
|
|
Outage_Cast(Seiscomp::Core::BaseObjectPtr o) -> Outage
|
|
"""
|
|
return _datamodel.Outage_Cast(*args)
|
|
|
|
def Outage_ConstCast(*args):
|
|
r"""
|
|
Outage_ConstCast(BaseObject o) -> Outage
|
|
Outage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Outage
|
|
"""
|
|
return _datamodel.Outage_ConstCast(*args)
|
|
|
|
def Outage_Meta():
|
|
r"""Outage_Meta() -> MetaObject"""
|
|
return _datamodel.Outage_Meta()
|
|
|
|
class QualityControl(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::QualityControl 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 _datamodel.QualityControl_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.QualityControl_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(QualityControl self) -> char const *"""
|
|
return _datamodel.QualityControl_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(QualityControl self) -> RTTI"""
|
|
return _datamodel.QualityControl_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> QualityControl
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> QualityControl
|
|
"""
|
|
return _datamodel.QualityControl_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> QualityControl
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> QualityControl
|
|
"""
|
|
return _datamodel.QualityControl_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(QualityControl self, GenericArchive ar)"""
|
|
return _datamodel.QualityControl_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.QualityControl_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(QualityControl self) -> MetaObject"""
|
|
return _datamodel.QualityControl_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(QualityControl self) -> QualityControl
|
|
__init__(QualityControl self, QualityControl other) -> QualityControl
|
|
"""
|
|
_datamodel.QualityControl_swiginit(self, _datamodel.new_QualityControl(*args))
|
|
__swig_destroy__ = _datamodel.delete_QualityControl
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(QualityControl self, QualityControl other) -> bool"""
|
|
return _datamodel.QualityControl___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(QualityControl self, QualityControl other) -> bool"""
|
|
return _datamodel.QualityControl___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(QualityControl self, QualityControl other) -> bool"""
|
|
return _datamodel.QualityControl_equal(self, other)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(QualityControl self, QCLog obj) -> bool
|
|
add(QualityControl self, WaveformQuality obj) -> bool
|
|
add(QualityControl self, Outage obj) -> bool
|
|
"""
|
|
return _datamodel.QualityControl_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(QualityControl self, QCLog obj) -> bool
|
|
remove(QualityControl self, WaveformQuality obj) -> bool
|
|
remove(QualityControl self, Outage obj) -> bool
|
|
"""
|
|
return _datamodel.QualityControl_remove(self, *args)
|
|
|
|
def removeQCLog(self, *args):
|
|
r"""
|
|
removeQCLog(QualityControl self, size_t i) -> bool
|
|
removeQCLog(QualityControl self, QCLogIndex i) -> bool
|
|
"""
|
|
return _datamodel.QualityControl_removeQCLog(self, *args)
|
|
|
|
def removeWaveformQuality(self, *args):
|
|
r"""
|
|
removeWaveformQuality(QualityControl self, size_t i) -> bool
|
|
removeWaveformQuality(QualityControl self, WaveformQualityIndex i) -> bool
|
|
"""
|
|
return _datamodel.QualityControl_removeWaveformQuality(self, *args)
|
|
|
|
def removeOutage(self, *args):
|
|
r"""
|
|
removeOutage(QualityControl self, size_t i) -> bool
|
|
removeOutage(QualityControl self, OutageIndex i) -> bool
|
|
"""
|
|
return _datamodel.QualityControl_removeOutage(self, *args)
|
|
|
|
def qCLogCount(self):
|
|
r"""qCLogCount(QualityControl self) -> size_t"""
|
|
return _datamodel.QualityControl_qCLogCount(self)
|
|
|
|
def waveformQualityCount(self):
|
|
r"""waveformQualityCount(QualityControl self) -> size_t"""
|
|
return _datamodel.QualityControl_waveformQualityCount(self)
|
|
|
|
def outageCount(self):
|
|
r"""outageCount(QualityControl self) -> size_t"""
|
|
return _datamodel.QualityControl_outageCount(self)
|
|
|
|
def qCLog(self, *args):
|
|
r"""
|
|
qCLog(QualityControl self, size_t i) -> QCLog
|
|
qCLog(QualityControl self, QCLogIndex i) -> QCLog
|
|
"""
|
|
return _datamodel.QualityControl_qCLog(self, *args)
|
|
|
|
def waveformQuality(self, *args):
|
|
r"""
|
|
waveformQuality(QualityControl self, size_t i) -> WaveformQuality
|
|
waveformQuality(QualityControl self, WaveformQualityIndex i) -> WaveformQuality
|
|
"""
|
|
return _datamodel.QualityControl_waveformQuality(self, *args)
|
|
|
|
def outage(self, *args):
|
|
r"""
|
|
outage(QualityControl self, size_t i) -> Outage
|
|
outage(QualityControl self, OutageIndex i) -> Outage
|
|
"""
|
|
return _datamodel.QualityControl_outage(self, *args)
|
|
|
|
def findQCLog(self, publicID):
|
|
r"""findQCLog(QualityControl self, std::string const & publicID) -> QCLog"""
|
|
return _datamodel.QualityControl_findQCLog(self, publicID)
|
|
|
|
def assign(self, other):
|
|
r"""assign(QualityControl self, Object other) -> bool"""
|
|
return _datamodel.QualityControl_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(QualityControl self, PublicObject parent) -> bool"""
|
|
return _datamodel.QualityControl_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(QualityControl self, PublicObject parent) -> bool"""
|
|
return _datamodel.QualityControl_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(QualityControl self) -> bool"""
|
|
return _datamodel.QualityControl_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(QualityControl self) -> Object"""
|
|
return _datamodel.QualityControl_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(QualityControl self, Object child) -> bool"""
|
|
return _datamodel.QualityControl_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(QualityControl self, Visitor visitor)"""
|
|
return _datamodel.QualityControl_accept(self, visitor)
|
|
|
|
# Register QualityControl in _datamodel:
|
|
_datamodel.QualityControl_swigregister(QualityControl)
|
|
|
|
def QualityControl_ClassName():
|
|
r"""QualityControl_ClassName() -> char const *"""
|
|
return _datamodel.QualityControl_ClassName()
|
|
|
|
def QualityControl_TypeInfo():
|
|
r"""QualityControl_TypeInfo() -> RTTI"""
|
|
return _datamodel.QualityControl_TypeInfo()
|
|
|
|
def QualityControl_Cast(*args):
|
|
r"""
|
|
QualityControl_Cast(BaseObject o) -> QualityControl
|
|
QualityControl_Cast(Seiscomp::Core::BaseObjectPtr o) -> QualityControl
|
|
"""
|
|
return _datamodel.QualityControl_Cast(*args)
|
|
|
|
def QualityControl_ConstCast(*args):
|
|
r"""
|
|
QualityControl_ConstCast(BaseObject o) -> QualityControl
|
|
QualityControl_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> QualityControl
|
|
"""
|
|
return _datamodel.QualityControl_ConstCast(*args)
|
|
|
|
def QualityControl_Meta():
|
|
r"""QualityControl_Meta() -> MetaObject"""
|
|
return _datamodel.QualityControl_Meta()
|
|
|
|
class StationReferenceIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::StationReferenceIndex 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__(StationReferenceIndex self) -> StationReferenceIndex
|
|
__init__(StationReferenceIndex self, std::string const & stationID) -> StationReferenceIndex
|
|
__init__(StationReferenceIndex self, StationReferenceIndex arg2) -> StationReferenceIndex
|
|
"""
|
|
_datamodel.StationReferenceIndex_swiginit(self, _datamodel.new_StationReferenceIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(StationReferenceIndex self, StationReferenceIndex arg2) -> bool"""
|
|
return _datamodel.StationReferenceIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(StationReferenceIndex self, StationReferenceIndex arg2) -> bool"""
|
|
return _datamodel.StationReferenceIndex___ne__(self, arg2)
|
|
stationID = property(_datamodel.StationReferenceIndex_stationID_get, _datamodel.StationReferenceIndex_stationID_set, doc=r"""stationID : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_StationReferenceIndex
|
|
|
|
# Register StationReferenceIndex in _datamodel:
|
|
_datamodel.StationReferenceIndex_swigregister(StationReferenceIndex)
|
|
|
|
class StationReference(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::StationReference 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 _datamodel.StationReference_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.StationReference_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(StationReference self) -> char const *"""
|
|
return _datamodel.StationReference_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(StationReference self) -> RTTI"""
|
|
return _datamodel.StationReference_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> StationReference
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> StationReference
|
|
"""
|
|
return _datamodel.StationReference_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> StationReference
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationReference
|
|
"""
|
|
return _datamodel.StationReference_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(StationReference self, GenericArchive ar)"""
|
|
return _datamodel.StationReference_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.StationReference_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(StationReference self) -> MetaObject"""
|
|
return _datamodel.StationReference_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(StationReference self) -> StationReference
|
|
__init__(StationReference self, StationReference other) -> StationReference
|
|
__init__(StationReference self, std::string const & stationID) -> StationReference
|
|
"""
|
|
_datamodel.StationReference_swiginit(self, _datamodel.new_StationReference(*args))
|
|
__swig_destroy__ = _datamodel.delete_StationReference
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(StationReference self, StationReference other) -> bool"""
|
|
return _datamodel.StationReference___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(StationReference self, StationReference other) -> bool"""
|
|
return _datamodel.StationReference___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(StationReference self, StationReference other) -> bool"""
|
|
return _datamodel.StationReference_equal(self, other)
|
|
|
|
def setStationID(self, stationID):
|
|
r"""setStationID(StationReference self, std::string const & stationID)"""
|
|
return _datamodel.StationReference_setStationID(self, stationID)
|
|
|
|
def stationID(self):
|
|
r"""stationID(StationReference self) -> std::string const &"""
|
|
return _datamodel.StationReference_stationID(self)
|
|
|
|
def index(self):
|
|
r"""index(StationReference self) -> StationReferenceIndex"""
|
|
return _datamodel.StationReference_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(StationReference self, StationReference lhs) -> bool"""
|
|
return _datamodel.StationReference_equalIndex(self, lhs)
|
|
|
|
def stationGroup(self):
|
|
r"""stationGroup(StationReference self) -> StationGroup"""
|
|
return _datamodel.StationReference_stationGroup(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(StationReference self, Object other) -> bool"""
|
|
return _datamodel.StationReference_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(StationReference self, PublicObject parent) -> bool"""
|
|
return _datamodel.StationReference_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(StationReference self, PublicObject parent) -> bool"""
|
|
return _datamodel.StationReference_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(StationReference self) -> bool"""
|
|
return _datamodel.StationReference_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(StationReference self) -> Object"""
|
|
return _datamodel.StationReference_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(StationReference self, Visitor visitor)"""
|
|
return _datamodel.StationReference_accept(self, visitor)
|
|
|
|
# Register StationReference in _datamodel:
|
|
_datamodel.StationReference_swigregister(StationReference)
|
|
|
|
def StationReference_ClassName():
|
|
r"""StationReference_ClassName() -> char const *"""
|
|
return _datamodel.StationReference_ClassName()
|
|
|
|
def StationReference_TypeInfo():
|
|
r"""StationReference_TypeInfo() -> RTTI"""
|
|
return _datamodel.StationReference_TypeInfo()
|
|
|
|
def StationReference_Cast(*args):
|
|
r"""
|
|
StationReference_Cast(BaseObject o) -> StationReference
|
|
StationReference_Cast(Seiscomp::Core::BaseObjectPtr o) -> StationReference
|
|
"""
|
|
return _datamodel.StationReference_Cast(*args)
|
|
|
|
def StationReference_ConstCast(*args):
|
|
r"""
|
|
StationReference_ConstCast(BaseObject o) -> StationReference
|
|
StationReference_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationReference
|
|
"""
|
|
return _datamodel.StationReference_ConstCast(*args)
|
|
|
|
def StationReference_Meta():
|
|
r"""StationReference_Meta() -> MetaObject"""
|
|
return _datamodel.StationReference_Meta()
|
|
|
|
class StationGroupIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::StationGroupIndex 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__(StationGroupIndex self) -> StationGroupIndex
|
|
__init__(StationGroupIndex self, std::string const & code) -> StationGroupIndex
|
|
__init__(StationGroupIndex self, StationGroupIndex arg2) -> StationGroupIndex
|
|
"""
|
|
_datamodel.StationGroupIndex_swiginit(self, _datamodel.new_StationGroupIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(StationGroupIndex self, StationGroupIndex arg2) -> bool"""
|
|
return _datamodel.StationGroupIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(StationGroupIndex self, StationGroupIndex arg2) -> bool"""
|
|
return _datamodel.StationGroupIndex___ne__(self, arg2)
|
|
code = property(_datamodel.StationGroupIndex_code_get, _datamodel.StationGroupIndex_code_set, doc=r"""code : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_StationGroupIndex
|
|
|
|
# Register StationGroupIndex in _datamodel:
|
|
_datamodel.StationGroupIndex_swigregister(StationGroupIndex)
|
|
|
|
class StationGroup(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::StationGroup 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 _datamodel.StationGroup_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.StationGroup_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(StationGroup self) -> char const *"""
|
|
return _datamodel.StationGroup_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(StationGroup self) -> RTTI"""
|
|
return _datamodel.StationGroup_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> StationGroup
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> StationGroup
|
|
"""
|
|
return _datamodel.StationGroup_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> StationGroup
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationGroup
|
|
"""
|
|
return _datamodel.StationGroup_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(StationGroup self, GenericArchive ar)"""
|
|
return _datamodel.StationGroup_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.StationGroup_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(StationGroup self) -> MetaObject"""
|
|
return _datamodel.StationGroup_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(StationGroup self, StationGroup other) -> StationGroup
|
|
__init__(StationGroup self, std::string const & publicID) -> StationGroup
|
|
"""
|
|
_datamodel.StationGroup_swiginit(self, _datamodel.new_StationGroup(*args))
|
|
__swig_destroy__ = _datamodel.delete_StationGroup
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> StationGroup
|
|
Create(std::string const & publicID) -> StationGroup
|
|
"""
|
|
return _datamodel.StationGroup_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> StationGroup"""
|
|
return _datamodel.StationGroup_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(StationGroup self, StationGroup other) -> bool"""
|
|
return _datamodel.StationGroup___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(StationGroup self, StationGroup other) -> bool"""
|
|
return _datamodel.StationGroup___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(StationGroup self, StationGroup other) -> bool"""
|
|
return _datamodel.StationGroup_equal(self, other)
|
|
|
|
def setType(self, type):
|
|
r"""setType(StationGroup self, Seiscomp::Core::Optional< Seiscomp::DataModel::StationGroupType >::Impl const & type)"""
|
|
return _datamodel.StationGroup_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(StationGroup self) -> Seiscomp::DataModel::StationGroupType"""
|
|
return _datamodel.StationGroup_type(self)
|
|
|
|
def setCode(self, code):
|
|
r"""setCode(StationGroup self, std::string const & code)"""
|
|
return _datamodel.StationGroup_setCode(self, code)
|
|
|
|
def code(self):
|
|
r"""code(StationGroup self) -> std::string const &"""
|
|
return _datamodel.StationGroup_code(self)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(StationGroup self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & start)"""
|
|
return _datamodel.StationGroup_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(StationGroup self) -> Time"""
|
|
return _datamodel.StationGroup_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(StationGroup self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
|
|
return _datamodel.StationGroup_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(StationGroup self) -> Time"""
|
|
return _datamodel.StationGroup_end(self)
|
|
|
|
def setDescription(self, description):
|
|
r"""setDescription(StationGroup self, std::string const & description)"""
|
|
return _datamodel.StationGroup_setDescription(self, description)
|
|
|
|
def description(self):
|
|
r"""description(StationGroup self) -> std::string const &"""
|
|
return _datamodel.StationGroup_description(self)
|
|
|
|
def setLatitude(self, latitude):
|
|
r"""setLatitude(StationGroup self, Seiscomp::Core::Optional< double >::Impl const & latitude)"""
|
|
return _datamodel.StationGroup_setLatitude(self, latitude)
|
|
|
|
def latitude(self):
|
|
r"""latitude(StationGroup self) -> double"""
|
|
return _datamodel.StationGroup_latitude(self)
|
|
|
|
def setLongitude(self, longitude):
|
|
r"""setLongitude(StationGroup self, Seiscomp::Core::Optional< double >::Impl const & longitude)"""
|
|
return _datamodel.StationGroup_setLongitude(self, longitude)
|
|
|
|
def longitude(self):
|
|
r"""longitude(StationGroup self) -> double"""
|
|
return _datamodel.StationGroup_longitude(self)
|
|
|
|
def setElevation(self, elevation):
|
|
r"""setElevation(StationGroup self, Seiscomp::Core::Optional< double >::Impl const & elevation)"""
|
|
return _datamodel.StationGroup_setElevation(self, elevation)
|
|
|
|
def elevation(self):
|
|
r"""elevation(StationGroup self) -> double"""
|
|
return _datamodel.StationGroup_elevation(self)
|
|
|
|
def index(self):
|
|
r"""index(StationGroup self) -> StationGroupIndex"""
|
|
return _datamodel.StationGroup_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(StationGroup self, StationGroup lhs) -> bool"""
|
|
return _datamodel.StationGroup_equalIndex(self, lhs)
|
|
|
|
def add(self, obj):
|
|
r"""add(StationGroup self, StationReference obj) -> bool"""
|
|
return _datamodel.StationGroup_add(self, obj)
|
|
|
|
def remove(self, obj):
|
|
r"""remove(StationGroup self, StationReference obj) -> bool"""
|
|
return _datamodel.StationGroup_remove(self, obj)
|
|
|
|
def removeStationReference(self, *args):
|
|
r"""
|
|
removeStationReference(StationGroup self, size_t i) -> bool
|
|
removeStationReference(StationGroup self, StationReferenceIndex i) -> bool
|
|
"""
|
|
return _datamodel.StationGroup_removeStationReference(self, *args)
|
|
|
|
def stationReferenceCount(self):
|
|
r"""stationReferenceCount(StationGroup self) -> size_t"""
|
|
return _datamodel.StationGroup_stationReferenceCount(self)
|
|
|
|
def stationReference(self, *args):
|
|
r"""
|
|
stationReference(StationGroup self, size_t i) -> StationReference
|
|
stationReference(StationGroup self, StationReferenceIndex i) -> StationReference
|
|
"""
|
|
return _datamodel.StationGroup_stationReference(self, *args)
|
|
|
|
def inventory(self):
|
|
r"""inventory(StationGroup self) -> Inventory"""
|
|
return _datamodel.StationGroup_inventory(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(StationGroup self, Object other) -> bool"""
|
|
return _datamodel.StationGroup_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(StationGroup self, PublicObject parent) -> bool"""
|
|
return _datamodel.StationGroup_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(StationGroup self, PublicObject parent) -> bool"""
|
|
return _datamodel.StationGroup_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(StationGroup self) -> bool"""
|
|
return _datamodel.StationGroup_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(StationGroup self) -> Object"""
|
|
return _datamodel.StationGroup_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(StationGroup self, Object child) -> bool"""
|
|
return _datamodel.StationGroup_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(StationGroup self, Visitor visitor)"""
|
|
return _datamodel.StationGroup_accept(self, visitor)
|
|
|
|
# Register StationGroup in _datamodel:
|
|
_datamodel.StationGroup_swigregister(StationGroup)
|
|
|
|
def StationGroup_ClassName():
|
|
r"""StationGroup_ClassName() -> char const *"""
|
|
return _datamodel.StationGroup_ClassName()
|
|
|
|
def StationGroup_TypeInfo():
|
|
r"""StationGroup_TypeInfo() -> RTTI"""
|
|
return _datamodel.StationGroup_TypeInfo()
|
|
|
|
def StationGroup_Cast(*args):
|
|
r"""
|
|
StationGroup_Cast(BaseObject o) -> StationGroup
|
|
StationGroup_Cast(Seiscomp::Core::BaseObjectPtr o) -> StationGroup
|
|
"""
|
|
return _datamodel.StationGroup_Cast(*args)
|
|
|
|
def StationGroup_ConstCast(*args):
|
|
r"""
|
|
StationGroup_ConstCast(BaseObject o) -> StationGroup
|
|
StationGroup_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> StationGroup
|
|
"""
|
|
return _datamodel.StationGroup_ConstCast(*args)
|
|
|
|
def StationGroup_Meta():
|
|
r"""StationGroup_Meta() -> MetaObject"""
|
|
return _datamodel.StationGroup_Meta()
|
|
|
|
def StationGroup_Create(*args):
|
|
r"""
|
|
StationGroup_Create() -> StationGroup
|
|
StationGroup_Create(std::string const & publicID) -> StationGroup
|
|
"""
|
|
return _datamodel.StationGroup_Create(*args)
|
|
|
|
def StationGroup_Find(publicID):
|
|
r"""StationGroup_Find(std::string const & publicID) -> StationGroup"""
|
|
return _datamodel.StationGroup_Find(publicID)
|
|
|
|
class AuxSourceIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::AuxSourceIndex 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__(AuxSourceIndex self) -> AuxSourceIndex
|
|
__init__(AuxSourceIndex self, std::string const & name) -> AuxSourceIndex
|
|
__init__(AuxSourceIndex self, AuxSourceIndex arg2) -> AuxSourceIndex
|
|
"""
|
|
_datamodel.AuxSourceIndex_swiginit(self, _datamodel.new_AuxSourceIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(AuxSourceIndex self, AuxSourceIndex arg2) -> bool"""
|
|
return _datamodel.AuxSourceIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(AuxSourceIndex self, AuxSourceIndex arg2) -> bool"""
|
|
return _datamodel.AuxSourceIndex___ne__(self, arg2)
|
|
name = property(_datamodel.AuxSourceIndex_name_get, _datamodel.AuxSourceIndex_name_set, doc=r"""name : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_AuxSourceIndex
|
|
|
|
# Register AuxSourceIndex in _datamodel:
|
|
_datamodel.AuxSourceIndex_swigregister(AuxSourceIndex)
|
|
|
|
class AuxSource(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::AuxSource 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 _datamodel.AuxSource_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.AuxSource_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(AuxSource self) -> char const *"""
|
|
return _datamodel.AuxSource_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(AuxSource self) -> RTTI"""
|
|
return _datamodel.AuxSource_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> AuxSource
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> AuxSource
|
|
"""
|
|
return _datamodel.AuxSource_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> AuxSource
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AuxSource
|
|
"""
|
|
return _datamodel.AuxSource_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(AuxSource self, GenericArchive ar)"""
|
|
return _datamodel.AuxSource_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.AuxSource_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(AuxSource self) -> MetaObject"""
|
|
return _datamodel.AuxSource_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(AuxSource self) -> AuxSource
|
|
__init__(AuxSource self, AuxSource other) -> AuxSource
|
|
__init__(AuxSource self, std::string const & name) -> AuxSource
|
|
__init__(AuxSource self, std::string const & name, std::string const & description, std::string const & unit, std::string const & conversion, Seiscomp::Core::Optional< int >::Impl const & sampleRateNumerator=Unset, Seiscomp::Core::Optional< int >::Impl const & sampleRateDenominator=Unset, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark=Unset) -> AuxSource
|
|
"""
|
|
_datamodel.AuxSource_swiginit(self, _datamodel.new_AuxSource(*args))
|
|
__swig_destroy__ = _datamodel.delete_AuxSource
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(AuxSource self, AuxSource other) -> bool"""
|
|
return _datamodel.AuxSource___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(AuxSource self, AuxSource other) -> bool"""
|
|
return _datamodel.AuxSource___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(AuxSource self, AuxSource other) -> bool"""
|
|
return _datamodel.AuxSource_equal(self, other)
|
|
|
|
def setName(self, name):
|
|
r"""setName(AuxSource self, std::string const & name)"""
|
|
return _datamodel.AuxSource_setName(self, name)
|
|
|
|
def name(self):
|
|
r"""name(AuxSource self) -> std::string const &"""
|
|
return _datamodel.AuxSource_name(self)
|
|
|
|
def setDescription(self, description):
|
|
r"""setDescription(AuxSource self, std::string const & description)"""
|
|
return _datamodel.AuxSource_setDescription(self, description)
|
|
|
|
def description(self):
|
|
r"""description(AuxSource self) -> std::string const &"""
|
|
return _datamodel.AuxSource_description(self)
|
|
|
|
def setUnit(self, unit):
|
|
r"""setUnit(AuxSource self, std::string const & unit)"""
|
|
return _datamodel.AuxSource_setUnit(self, unit)
|
|
|
|
def unit(self):
|
|
r"""unit(AuxSource self) -> std::string const &"""
|
|
return _datamodel.AuxSource_unit(self)
|
|
|
|
def setConversion(self, conversion):
|
|
r"""setConversion(AuxSource self, std::string const & conversion)"""
|
|
return _datamodel.AuxSource_setConversion(self, conversion)
|
|
|
|
def conversion(self):
|
|
r"""conversion(AuxSource self) -> std::string const &"""
|
|
return _datamodel.AuxSource_conversion(self)
|
|
|
|
def setSampleRateNumerator(self, sampleRateNumerator):
|
|
r"""setSampleRateNumerator(AuxSource self, Seiscomp::Core::Optional< int >::Impl const & sampleRateNumerator)"""
|
|
return _datamodel.AuxSource_setSampleRateNumerator(self, sampleRateNumerator)
|
|
|
|
def sampleRateNumerator(self):
|
|
r"""sampleRateNumerator(AuxSource self) -> int"""
|
|
return _datamodel.AuxSource_sampleRateNumerator(self)
|
|
|
|
def setSampleRateDenominator(self, sampleRateDenominator):
|
|
r"""setSampleRateDenominator(AuxSource self, Seiscomp::Core::Optional< int >::Impl const & sampleRateDenominator)"""
|
|
return _datamodel.AuxSource_setSampleRateDenominator(self, sampleRateDenominator)
|
|
|
|
def sampleRateDenominator(self):
|
|
r"""sampleRateDenominator(AuxSource self) -> int"""
|
|
return _datamodel.AuxSource_sampleRateDenominator(self)
|
|
|
|
def setRemark(self, remark):
|
|
r"""setRemark(AuxSource self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
|
|
return _datamodel.AuxSource_setRemark(self, remark)
|
|
|
|
def remark(self, *args):
|
|
r"""
|
|
remark(AuxSource self) -> Blob
|
|
remark(AuxSource self) -> Blob
|
|
"""
|
|
return _datamodel.AuxSource_remark(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(AuxSource self) -> AuxSourceIndex"""
|
|
return _datamodel.AuxSource_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(AuxSource self, AuxSource lhs) -> bool"""
|
|
return _datamodel.AuxSource_equalIndex(self, lhs)
|
|
|
|
def auxDevice(self):
|
|
r"""auxDevice(AuxSource self) -> AuxDevice"""
|
|
return _datamodel.AuxSource_auxDevice(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(AuxSource self, Object other) -> bool"""
|
|
return _datamodel.AuxSource_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(AuxSource self, PublicObject parent) -> bool"""
|
|
return _datamodel.AuxSource_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(AuxSource self, PublicObject parent) -> bool"""
|
|
return _datamodel.AuxSource_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(AuxSource self) -> bool"""
|
|
return _datamodel.AuxSource_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(AuxSource self) -> Object"""
|
|
return _datamodel.AuxSource_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(AuxSource self, Visitor visitor)"""
|
|
return _datamodel.AuxSource_accept(self, visitor)
|
|
|
|
# Register AuxSource in _datamodel:
|
|
_datamodel.AuxSource_swigregister(AuxSource)
|
|
|
|
def AuxSource_ClassName():
|
|
r"""AuxSource_ClassName() -> char const *"""
|
|
return _datamodel.AuxSource_ClassName()
|
|
|
|
def AuxSource_TypeInfo():
|
|
r"""AuxSource_TypeInfo() -> RTTI"""
|
|
return _datamodel.AuxSource_TypeInfo()
|
|
|
|
def AuxSource_Cast(*args):
|
|
r"""
|
|
AuxSource_Cast(BaseObject o) -> AuxSource
|
|
AuxSource_Cast(Seiscomp::Core::BaseObjectPtr o) -> AuxSource
|
|
"""
|
|
return _datamodel.AuxSource_Cast(*args)
|
|
|
|
def AuxSource_ConstCast(*args):
|
|
r"""
|
|
AuxSource_ConstCast(BaseObject o) -> AuxSource
|
|
AuxSource_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AuxSource
|
|
"""
|
|
return _datamodel.AuxSource_ConstCast(*args)
|
|
|
|
def AuxSource_Meta():
|
|
r"""AuxSource_Meta() -> MetaObject"""
|
|
return _datamodel.AuxSource_Meta()
|
|
|
|
class AuxDeviceIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::AuxDeviceIndex 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__(AuxDeviceIndex self) -> AuxDeviceIndex
|
|
__init__(AuxDeviceIndex self, std::string const & name) -> AuxDeviceIndex
|
|
__init__(AuxDeviceIndex self, AuxDeviceIndex arg2) -> AuxDeviceIndex
|
|
"""
|
|
_datamodel.AuxDeviceIndex_swiginit(self, _datamodel.new_AuxDeviceIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(AuxDeviceIndex self, AuxDeviceIndex arg2) -> bool"""
|
|
return _datamodel.AuxDeviceIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(AuxDeviceIndex self, AuxDeviceIndex arg2) -> bool"""
|
|
return _datamodel.AuxDeviceIndex___ne__(self, arg2)
|
|
name = property(_datamodel.AuxDeviceIndex_name_get, _datamodel.AuxDeviceIndex_name_set, doc=r"""name : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_AuxDeviceIndex
|
|
|
|
# Register AuxDeviceIndex in _datamodel:
|
|
_datamodel.AuxDeviceIndex_swigregister(AuxDeviceIndex)
|
|
|
|
class AuxDevice(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::AuxDevice 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 _datamodel.AuxDevice_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.AuxDevice_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(AuxDevice self) -> char const *"""
|
|
return _datamodel.AuxDevice_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(AuxDevice self) -> RTTI"""
|
|
return _datamodel.AuxDevice_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> AuxDevice
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> AuxDevice
|
|
"""
|
|
return _datamodel.AuxDevice_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> AuxDevice
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AuxDevice
|
|
"""
|
|
return _datamodel.AuxDevice_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(AuxDevice self, GenericArchive ar)"""
|
|
return _datamodel.AuxDevice_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.AuxDevice_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(AuxDevice self) -> MetaObject"""
|
|
return _datamodel.AuxDevice_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(AuxDevice self, AuxDevice other) -> AuxDevice
|
|
__init__(AuxDevice self, std::string const & publicID) -> AuxDevice
|
|
"""
|
|
_datamodel.AuxDevice_swiginit(self, _datamodel.new_AuxDevice(*args))
|
|
__swig_destroy__ = _datamodel.delete_AuxDevice
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> AuxDevice
|
|
Create(std::string const & publicID) -> AuxDevice
|
|
"""
|
|
return _datamodel.AuxDevice_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> AuxDevice"""
|
|
return _datamodel.AuxDevice_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(AuxDevice self, AuxDevice other) -> bool"""
|
|
return _datamodel.AuxDevice___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(AuxDevice self, AuxDevice other) -> bool"""
|
|
return _datamodel.AuxDevice___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(AuxDevice self, AuxDevice other) -> bool"""
|
|
return _datamodel.AuxDevice_equal(self, other)
|
|
|
|
def setName(self, name):
|
|
r"""setName(AuxDevice self, std::string const & name)"""
|
|
return _datamodel.AuxDevice_setName(self, name)
|
|
|
|
def name(self):
|
|
r"""name(AuxDevice self) -> std::string const &"""
|
|
return _datamodel.AuxDevice_name(self)
|
|
|
|
def setDescription(self, description):
|
|
r"""setDescription(AuxDevice self, std::string const & description)"""
|
|
return _datamodel.AuxDevice_setDescription(self, description)
|
|
|
|
def description(self):
|
|
r"""description(AuxDevice self) -> std::string const &"""
|
|
return _datamodel.AuxDevice_description(self)
|
|
|
|
def setModel(self, model):
|
|
r"""setModel(AuxDevice self, std::string const & model)"""
|
|
return _datamodel.AuxDevice_setModel(self, model)
|
|
|
|
def model(self):
|
|
r"""model(AuxDevice self) -> std::string const &"""
|
|
return _datamodel.AuxDevice_model(self)
|
|
|
|
def setManufacturer(self, manufacturer):
|
|
r"""setManufacturer(AuxDevice self, std::string const & manufacturer)"""
|
|
return _datamodel.AuxDevice_setManufacturer(self, manufacturer)
|
|
|
|
def manufacturer(self):
|
|
r"""manufacturer(AuxDevice self) -> std::string const &"""
|
|
return _datamodel.AuxDevice_manufacturer(self)
|
|
|
|
def setRemark(self, remark):
|
|
r"""setRemark(AuxDevice self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
|
|
return _datamodel.AuxDevice_setRemark(self, remark)
|
|
|
|
def remark(self, *args):
|
|
r"""
|
|
remark(AuxDevice self) -> Blob
|
|
remark(AuxDevice self) -> Blob
|
|
"""
|
|
return _datamodel.AuxDevice_remark(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(AuxDevice self) -> AuxDeviceIndex"""
|
|
return _datamodel.AuxDevice_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(AuxDevice self, AuxDevice lhs) -> bool"""
|
|
return _datamodel.AuxDevice_equalIndex(self, lhs)
|
|
|
|
def add(self, obj):
|
|
r"""add(AuxDevice self, AuxSource obj) -> bool"""
|
|
return _datamodel.AuxDevice_add(self, obj)
|
|
|
|
def remove(self, obj):
|
|
r"""remove(AuxDevice self, AuxSource obj) -> bool"""
|
|
return _datamodel.AuxDevice_remove(self, obj)
|
|
|
|
def removeAuxSource(self, *args):
|
|
r"""
|
|
removeAuxSource(AuxDevice self, size_t i) -> bool
|
|
removeAuxSource(AuxDevice self, AuxSourceIndex i) -> bool
|
|
"""
|
|
return _datamodel.AuxDevice_removeAuxSource(self, *args)
|
|
|
|
def auxSourceCount(self):
|
|
r"""auxSourceCount(AuxDevice self) -> size_t"""
|
|
return _datamodel.AuxDevice_auxSourceCount(self)
|
|
|
|
def auxSource(self, *args):
|
|
r"""
|
|
auxSource(AuxDevice self, size_t i) -> AuxSource
|
|
auxSource(AuxDevice self, AuxSourceIndex i) -> AuxSource
|
|
"""
|
|
return _datamodel.AuxDevice_auxSource(self, *args)
|
|
|
|
def inventory(self):
|
|
r"""inventory(AuxDevice self) -> Inventory"""
|
|
return _datamodel.AuxDevice_inventory(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(AuxDevice self, Object other) -> bool"""
|
|
return _datamodel.AuxDevice_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(AuxDevice self, PublicObject parent) -> bool"""
|
|
return _datamodel.AuxDevice_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(AuxDevice self, PublicObject parent) -> bool"""
|
|
return _datamodel.AuxDevice_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(AuxDevice self) -> bool"""
|
|
return _datamodel.AuxDevice_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(AuxDevice self) -> Object"""
|
|
return _datamodel.AuxDevice_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(AuxDevice self, Object child) -> bool"""
|
|
return _datamodel.AuxDevice_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(AuxDevice self, Visitor visitor)"""
|
|
return _datamodel.AuxDevice_accept(self, visitor)
|
|
|
|
# Register AuxDevice in _datamodel:
|
|
_datamodel.AuxDevice_swigregister(AuxDevice)
|
|
|
|
def AuxDevice_ClassName():
|
|
r"""AuxDevice_ClassName() -> char const *"""
|
|
return _datamodel.AuxDevice_ClassName()
|
|
|
|
def AuxDevice_TypeInfo():
|
|
r"""AuxDevice_TypeInfo() -> RTTI"""
|
|
return _datamodel.AuxDevice_TypeInfo()
|
|
|
|
def AuxDevice_Cast(*args):
|
|
r"""
|
|
AuxDevice_Cast(BaseObject o) -> AuxDevice
|
|
AuxDevice_Cast(Seiscomp::Core::BaseObjectPtr o) -> AuxDevice
|
|
"""
|
|
return _datamodel.AuxDevice_Cast(*args)
|
|
|
|
def AuxDevice_ConstCast(*args):
|
|
r"""
|
|
AuxDevice_ConstCast(BaseObject o) -> AuxDevice
|
|
AuxDevice_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AuxDevice
|
|
"""
|
|
return _datamodel.AuxDevice_ConstCast(*args)
|
|
|
|
def AuxDevice_Meta():
|
|
r"""AuxDevice_Meta() -> MetaObject"""
|
|
return _datamodel.AuxDevice_Meta()
|
|
|
|
def AuxDevice_Create(*args):
|
|
r"""
|
|
AuxDevice_Create() -> AuxDevice
|
|
AuxDevice_Create(std::string const & publicID) -> AuxDevice
|
|
"""
|
|
return _datamodel.AuxDevice_Create(*args)
|
|
|
|
def AuxDevice_Find(publicID):
|
|
r"""AuxDevice_Find(std::string const & publicID) -> AuxDevice"""
|
|
return _datamodel.AuxDevice_Find(publicID)
|
|
|
|
class SensorCalibrationIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::SensorCalibrationIndex 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__(SensorCalibrationIndex self) -> SensorCalibrationIndex
|
|
__init__(SensorCalibrationIndex self, std::string const & serialNumber, int channel, Time start) -> SensorCalibrationIndex
|
|
__init__(SensorCalibrationIndex self, SensorCalibrationIndex arg2) -> SensorCalibrationIndex
|
|
"""
|
|
_datamodel.SensorCalibrationIndex_swiginit(self, _datamodel.new_SensorCalibrationIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(SensorCalibrationIndex self, SensorCalibrationIndex arg2) -> bool"""
|
|
return _datamodel.SensorCalibrationIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(SensorCalibrationIndex self, SensorCalibrationIndex arg2) -> bool"""
|
|
return _datamodel.SensorCalibrationIndex___ne__(self, arg2)
|
|
serialNumber = property(_datamodel.SensorCalibrationIndex_serialNumber_get, _datamodel.SensorCalibrationIndex_serialNumber_set, doc=r"""serialNumber : std::string""")
|
|
channel = property(_datamodel.SensorCalibrationIndex_channel_get, _datamodel.SensorCalibrationIndex_channel_set, doc=r"""channel : int""")
|
|
start = property(_datamodel.SensorCalibrationIndex_start_get, _datamodel.SensorCalibrationIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
|
|
__swig_destroy__ = _datamodel.delete_SensorCalibrationIndex
|
|
|
|
# Register SensorCalibrationIndex in _datamodel:
|
|
_datamodel.SensorCalibrationIndex_swigregister(SensorCalibrationIndex)
|
|
|
|
class SensorCalibration(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::SensorCalibration 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 _datamodel.SensorCalibration_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.SensorCalibration_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(SensorCalibration self) -> char const *"""
|
|
return _datamodel.SensorCalibration_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(SensorCalibration self) -> RTTI"""
|
|
return _datamodel.SensorCalibration_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> SensorCalibration
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> SensorCalibration
|
|
"""
|
|
return _datamodel.SensorCalibration_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> SensorCalibration
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SensorCalibration
|
|
"""
|
|
return _datamodel.SensorCalibration_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(SensorCalibration self, GenericArchive ar)"""
|
|
return _datamodel.SensorCalibration_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.SensorCalibration_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(SensorCalibration self) -> MetaObject"""
|
|
return _datamodel.SensorCalibration_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(SensorCalibration self) -> SensorCalibration
|
|
__init__(SensorCalibration self, SensorCalibration other) -> SensorCalibration
|
|
"""
|
|
_datamodel.SensorCalibration_swiginit(self, _datamodel.new_SensorCalibration(*args))
|
|
__swig_destroy__ = _datamodel.delete_SensorCalibration
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(SensorCalibration self, SensorCalibration other) -> bool"""
|
|
return _datamodel.SensorCalibration___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(SensorCalibration self, SensorCalibration other) -> bool"""
|
|
return _datamodel.SensorCalibration___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(SensorCalibration self, SensorCalibration other) -> bool"""
|
|
return _datamodel.SensorCalibration_equal(self, other)
|
|
|
|
def setSerialNumber(self, serialNumber):
|
|
r"""setSerialNumber(SensorCalibration self, std::string const & serialNumber)"""
|
|
return _datamodel.SensorCalibration_setSerialNumber(self, serialNumber)
|
|
|
|
def serialNumber(self):
|
|
r"""serialNumber(SensorCalibration self) -> std::string const &"""
|
|
return _datamodel.SensorCalibration_serialNumber(self)
|
|
|
|
def setChannel(self, channel):
|
|
r"""setChannel(SensorCalibration self, int channel)"""
|
|
return _datamodel.SensorCalibration_setChannel(self, channel)
|
|
|
|
def channel(self):
|
|
r"""channel(SensorCalibration self) -> int"""
|
|
return _datamodel.SensorCalibration_channel(self)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(SensorCalibration self, Time start)"""
|
|
return _datamodel.SensorCalibration_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(SensorCalibration self) -> Time"""
|
|
return _datamodel.SensorCalibration_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(SensorCalibration self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
|
|
return _datamodel.SensorCalibration_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(SensorCalibration self) -> Time"""
|
|
return _datamodel.SensorCalibration_end(self)
|
|
|
|
def setGain(self, gain):
|
|
r"""setGain(SensorCalibration self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
|
|
return _datamodel.SensorCalibration_setGain(self, gain)
|
|
|
|
def gain(self):
|
|
r"""gain(SensorCalibration self) -> double"""
|
|
return _datamodel.SensorCalibration_gain(self)
|
|
|
|
def setGainFrequency(self, gainFrequency):
|
|
r"""setGainFrequency(SensorCalibration self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
|
|
return _datamodel.SensorCalibration_setGainFrequency(self, gainFrequency)
|
|
|
|
def gainFrequency(self):
|
|
r"""gainFrequency(SensorCalibration self) -> double"""
|
|
return _datamodel.SensorCalibration_gainFrequency(self)
|
|
|
|
def setRemark(self, remark):
|
|
r"""setRemark(SensorCalibration self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
|
|
return _datamodel.SensorCalibration_setRemark(self, remark)
|
|
|
|
def remark(self, *args):
|
|
r"""
|
|
remark(SensorCalibration self) -> Blob
|
|
remark(SensorCalibration self) -> Blob
|
|
"""
|
|
return _datamodel.SensorCalibration_remark(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(SensorCalibration self) -> SensorCalibrationIndex"""
|
|
return _datamodel.SensorCalibration_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(SensorCalibration self, SensorCalibration lhs) -> bool"""
|
|
return _datamodel.SensorCalibration_equalIndex(self, lhs)
|
|
|
|
def sensor(self):
|
|
r"""sensor(SensorCalibration self) -> Sensor"""
|
|
return _datamodel.SensorCalibration_sensor(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(SensorCalibration self, Object other) -> bool"""
|
|
return _datamodel.SensorCalibration_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(SensorCalibration self, PublicObject parent) -> bool"""
|
|
return _datamodel.SensorCalibration_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(SensorCalibration self, PublicObject parent) -> bool"""
|
|
return _datamodel.SensorCalibration_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(SensorCalibration self) -> bool"""
|
|
return _datamodel.SensorCalibration_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(SensorCalibration self) -> Object"""
|
|
return _datamodel.SensorCalibration_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(SensorCalibration self, Visitor visitor)"""
|
|
return _datamodel.SensorCalibration_accept(self, visitor)
|
|
|
|
# Register SensorCalibration in _datamodel:
|
|
_datamodel.SensorCalibration_swigregister(SensorCalibration)
|
|
|
|
def SensorCalibration_ClassName():
|
|
r"""SensorCalibration_ClassName() -> char const *"""
|
|
return _datamodel.SensorCalibration_ClassName()
|
|
|
|
def SensorCalibration_TypeInfo():
|
|
r"""SensorCalibration_TypeInfo() -> RTTI"""
|
|
return _datamodel.SensorCalibration_TypeInfo()
|
|
|
|
def SensorCalibration_Cast(*args):
|
|
r"""
|
|
SensorCalibration_Cast(BaseObject o) -> SensorCalibration
|
|
SensorCalibration_Cast(Seiscomp::Core::BaseObjectPtr o) -> SensorCalibration
|
|
"""
|
|
return _datamodel.SensorCalibration_Cast(*args)
|
|
|
|
def SensorCalibration_ConstCast(*args):
|
|
r"""
|
|
SensorCalibration_ConstCast(BaseObject o) -> SensorCalibration
|
|
SensorCalibration_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SensorCalibration
|
|
"""
|
|
return _datamodel.SensorCalibration_ConstCast(*args)
|
|
|
|
def SensorCalibration_Meta():
|
|
r"""SensorCalibration_Meta() -> MetaObject"""
|
|
return _datamodel.SensorCalibration_Meta()
|
|
|
|
class SensorIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::SensorIndex 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__(SensorIndex self) -> SensorIndex
|
|
__init__(SensorIndex self, std::string const & name) -> SensorIndex
|
|
__init__(SensorIndex self, SensorIndex arg2) -> SensorIndex
|
|
"""
|
|
_datamodel.SensorIndex_swiginit(self, _datamodel.new_SensorIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(SensorIndex self, SensorIndex arg2) -> bool"""
|
|
return _datamodel.SensorIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(SensorIndex self, SensorIndex arg2) -> bool"""
|
|
return _datamodel.SensorIndex___ne__(self, arg2)
|
|
name = property(_datamodel.SensorIndex_name_get, _datamodel.SensorIndex_name_set, doc=r"""name : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_SensorIndex
|
|
|
|
# Register SensorIndex in _datamodel:
|
|
_datamodel.SensorIndex_swigregister(SensorIndex)
|
|
|
|
class Sensor(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Sensor 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 _datamodel.Sensor_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Sensor_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Sensor self) -> char const *"""
|
|
return _datamodel.Sensor_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Sensor self) -> RTTI"""
|
|
return _datamodel.Sensor_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Sensor
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Sensor
|
|
"""
|
|
return _datamodel.Sensor_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Sensor
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Sensor
|
|
"""
|
|
return _datamodel.Sensor_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Sensor self, GenericArchive ar)"""
|
|
return _datamodel.Sensor_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Sensor_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Sensor self) -> MetaObject"""
|
|
return _datamodel.Sensor_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Sensor self, Sensor other) -> Sensor
|
|
__init__(Sensor self, std::string const & publicID) -> Sensor
|
|
"""
|
|
_datamodel.Sensor_swiginit(self, _datamodel.new_Sensor(*args))
|
|
__swig_destroy__ = _datamodel.delete_Sensor
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> Sensor
|
|
Create(std::string const & publicID) -> Sensor
|
|
"""
|
|
return _datamodel.Sensor_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> Sensor"""
|
|
return _datamodel.Sensor_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Sensor self, Sensor other) -> bool"""
|
|
return _datamodel.Sensor___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Sensor self, Sensor other) -> bool"""
|
|
return _datamodel.Sensor___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Sensor self, Sensor other) -> bool"""
|
|
return _datamodel.Sensor_equal(self, other)
|
|
|
|
def setName(self, name):
|
|
r"""setName(Sensor self, std::string const & name)"""
|
|
return _datamodel.Sensor_setName(self, name)
|
|
|
|
def name(self):
|
|
r"""name(Sensor self) -> std::string const &"""
|
|
return _datamodel.Sensor_name(self)
|
|
|
|
def setDescription(self, description):
|
|
r"""setDescription(Sensor self, std::string const & description)"""
|
|
return _datamodel.Sensor_setDescription(self, description)
|
|
|
|
def description(self):
|
|
r"""description(Sensor self) -> std::string const &"""
|
|
return _datamodel.Sensor_description(self)
|
|
|
|
def setModel(self, model):
|
|
r"""setModel(Sensor self, std::string const & model)"""
|
|
return _datamodel.Sensor_setModel(self, model)
|
|
|
|
def model(self):
|
|
r"""model(Sensor self) -> std::string const &"""
|
|
return _datamodel.Sensor_model(self)
|
|
|
|
def setManufacturer(self, manufacturer):
|
|
r"""setManufacturer(Sensor self, std::string const & manufacturer)"""
|
|
return _datamodel.Sensor_setManufacturer(self, manufacturer)
|
|
|
|
def manufacturer(self):
|
|
r"""manufacturer(Sensor self) -> std::string const &"""
|
|
return _datamodel.Sensor_manufacturer(self)
|
|
|
|
def setType(self, type):
|
|
r"""setType(Sensor self, std::string const & type)"""
|
|
return _datamodel.Sensor_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(Sensor self) -> std::string const &"""
|
|
return _datamodel.Sensor_type(self)
|
|
|
|
def setUnit(self, unit):
|
|
r"""setUnit(Sensor self, std::string const & unit)"""
|
|
return _datamodel.Sensor_setUnit(self, unit)
|
|
|
|
def unit(self):
|
|
r"""unit(Sensor self) -> std::string const &"""
|
|
return _datamodel.Sensor_unit(self)
|
|
|
|
def setLowFrequency(self, lowFrequency):
|
|
r"""setLowFrequency(Sensor self, Seiscomp::Core::Optional< double >::Impl const & lowFrequency)"""
|
|
return _datamodel.Sensor_setLowFrequency(self, lowFrequency)
|
|
|
|
def lowFrequency(self):
|
|
r"""lowFrequency(Sensor self) -> double"""
|
|
return _datamodel.Sensor_lowFrequency(self)
|
|
|
|
def setHighFrequency(self, highFrequency):
|
|
r"""setHighFrequency(Sensor self, Seiscomp::Core::Optional< double >::Impl const & highFrequency)"""
|
|
return _datamodel.Sensor_setHighFrequency(self, highFrequency)
|
|
|
|
def highFrequency(self):
|
|
r"""highFrequency(Sensor self) -> double"""
|
|
return _datamodel.Sensor_highFrequency(self)
|
|
|
|
def setResponse(self, response):
|
|
r"""setResponse(Sensor self, std::string const & response)"""
|
|
return _datamodel.Sensor_setResponse(self, response)
|
|
|
|
def response(self):
|
|
r"""response(Sensor self) -> std::string const &"""
|
|
return _datamodel.Sensor_response(self)
|
|
|
|
def setRemark(self, remark):
|
|
r"""setRemark(Sensor self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
|
|
return _datamodel.Sensor_setRemark(self, remark)
|
|
|
|
def remark(self, *args):
|
|
r"""
|
|
remark(Sensor self) -> Blob
|
|
remark(Sensor self) -> Blob
|
|
"""
|
|
return _datamodel.Sensor_remark(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(Sensor self) -> SensorIndex"""
|
|
return _datamodel.Sensor_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(Sensor self, Sensor lhs) -> bool"""
|
|
return _datamodel.Sensor_equalIndex(self, lhs)
|
|
|
|
def add(self, obj):
|
|
r"""add(Sensor self, SensorCalibration obj) -> bool"""
|
|
return _datamodel.Sensor_add(self, obj)
|
|
|
|
def remove(self, obj):
|
|
r"""remove(Sensor self, SensorCalibration obj) -> bool"""
|
|
return _datamodel.Sensor_remove(self, obj)
|
|
|
|
def removeSensorCalibration(self, *args):
|
|
r"""
|
|
removeSensorCalibration(Sensor self, size_t i) -> bool
|
|
removeSensorCalibration(Sensor self, SensorCalibrationIndex i) -> bool
|
|
"""
|
|
return _datamodel.Sensor_removeSensorCalibration(self, *args)
|
|
|
|
def sensorCalibrationCount(self):
|
|
r"""sensorCalibrationCount(Sensor self) -> size_t"""
|
|
return _datamodel.Sensor_sensorCalibrationCount(self)
|
|
|
|
def sensorCalibration(self, *args):
|
|
r"""
|
|
sensorCalibration(Sensor self, size_t i) -> SensorCalibration
|
|
sensorCalibration(Sensor self, SensorCalibrationIndex i) -> SensorCalibration
|
|
"""
|
|
return _datamodel.Sensor_sensorCalibration(self, *args)
|
|
|
|
def inventory(self):
|
|
r"""inventory(Sensor self) -> Inventory"""
|
|
return _datamodel.Sensor_inventory(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Sensor self, Object other) -> bool"""
|
|
return _datamodel.Sensor_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Sensor self, PublicObject parent) -> bool"""
|
|
return _datamodel.Sensor_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Sensor self, PublicObject parent) -> bool"""
|
|
return _datamodel.Sensor_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Sensor self) -> bool"""
|
|
return _datamodel.Sensor_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Sensor self) -> Object"""
|
|
return _datamodel.Sensor_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Sensor self, Object child) -> bool"""
|
|
return _datamodel.Sensor_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Sensor self, Visitor visitor)"""
|
|
return _datamodel.Sensor_accept(self, visitor)
|
|
|
|
# Register Sensor in _datamodel:
|
|
_datamodel.Sensor_swigregister(Sensor)
|
|
|
|
def Sensor_ClassName():
|
|
r"""Sensor_ClassName() -> char const *"""
|
|
return _datamodel.Sensor_ClassName()
|
|
|
|
def Sensor_TypeInfo():
|
|
r"""Sensor_TypeInfo() -> RTTI"""
|
|
return _datamodel.Sensor_TypeInfo()
|
|
|
|
def Sensor_Cast(*args):
|
|
r"""
|
|
Sensor_Cast(BaseObject o) -> Sensor
|
|
Sensor_Cast(Seiscomp::Core::BaseObjectPtr o) -> Sensor
|
|
"""
|
|
return _datamodel.Sensor_Cast(*args)
|
|
|
|
def Sensor_ConstCast(*args):
|
|
r"""
|
|
Sensor_ConstCast(BaseObject o) -> Sensor
|
|
Sensor_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Sensor
|
|
"""
|
|
return _datamodel.Sensor_ConstCast(*args)
|
|
|
|
def Sensor_Meta():
|
|
r"""Sensor_Meta() -> MetaObject"""
|
|
return _datamodel.Sensor_Meta()
|
|
|
|
def Sensor_Create(*args):
|
|
r"""
|
|
Sensor_Create() -> Sensor
|
|
Sensor_Create(std::string const & publicID) -> Sensor
|
|
"""
|
|
return _datamodel.Sensor_Create(*args)
|
|
|
|
def Sensor_Find(publicID):
|
|
r"""Sensor_Find(std::string const & publicID) -> Sensor"""
|
|
return _datamodel.Sensor_Find(publicID)
|
|
|
|
class ResponsePAZIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ResponsePAZIndex 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__(ResponsePAZIndex self) -> ResponsePAZIndex
|
|
__init__(ResponsePAZIndex self, std::string const & name) -> ResponsePAZIndex
|
|
__init__(ResponsePAZIndex self, ResponsePAZIndex arg2) -> ResponsePAZIndex
|
|
"""
|
|
_datamodel.ResponsePAZIndex_swiginit(self, _datamodel.new_ResponsePAZIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(ResponsePAZIndex self, ResponsePAZIndex arg2) -> bool"""
|
|
return _datamodel.ResponsePAZIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(ResponsePAZIndex self, ResponsePAZIndex arg2) -> bool"""
|
|
return _datamodel.ResponsePAZIndex___ne__(self, arg2)
|
|
name = property(_datamodel.ResponsePAZIndex_name_get, _datamodel.ResponsePAZIndex_name_set, doc=r"""name : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_ResponsePAZIndex
|
|
|
|
# Register ResponsePAZIndex in _datamodel:
|
|
_datamodel.ResponsePAZIndex_swigregister(ResponsePAZIndex)
|
|
|
|
class ResponsePAZ(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ResponsePAZ 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 _datamodel.ResponsePAZ_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ResponsePAZ_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ResponsePAZ self) -> char const *"""
|
|
return _datamodel.ResponsePAZ_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ResponsePAZ self) -> RTTI"""
|
|
return _datamodel.ResponsePAZ_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ResponsePAZ
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponsePAZ
|
|
"""
|
|
return _datamodel.ResponsePAZ_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ResponsePAZ
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponsePAZ
|
|
"""
|
|
return _datamodel.ResponsePAZ_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ResponsePAZ self, GenericArchive ar)"""
|
|
return _datamodel.ResponsePAZ_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ResponsePAZ_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ResponsePAZ self) -> MetaObject"""
|
|
return _datamodel.ResponsePAZ_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ResponsePAZ self, ResponsePAZ other) -> ResponsePAZ
|
|
__init__(ResponsePAZ self, std::string const & publicID) -> ResponsePAZ
|
|
"""
|
|
_datamodel.ResponsePAZ_swiginit(self, _datamodel.new_ResponsePAZ(*args))
|
|
__swig_destroy__ = _datamodel.delete_ResponsePAZ
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> ResponsePAZ
|
|
Create(std::string const & publicID) -> ResponsePAZ
|
|
"""
|
|
return _datamodel.ResponsePAZ_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> ResponsePAZ"""
|
|
return _datamodel.ResponsePAZ_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ResponsePAZ self, ResponsePAZ other) -> bool"""
|
|
return _datamodel.ResponsePAZ___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ResponsePAZ self, ResponsePAZ other) -> bool"""
|
|
return _datamodel.ResponsePAZ___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ResponsePAZ self, ResponsePAZ other) -> bool"""
|
|
return _datamodel.ResponsePAZ_equal(self, other)
|
|
|
|
def setName(self, name):
|
|
r"""setName(ResponsePAZ self, std::string const & name)"""
|
|
return _datamodel.ResponsePAZ_setName(self, name)
|
|
|
|
def name(self):
|
|
r"""name(ResponsePAZ self) -> std::string const &"""
|
|
return _datamodel.ResponsePAZ_name(self)
|
|
|
|
def setType(self, type):
|
|
r"""setType(ResponsePAZ self, std::string const & type)"""
|
|
return _datamodel.ResponsePAZ_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(ResponsePAZ self) -> std::string const &"""
|
|
return _datamodel.ResponsePAZ_type(self)
|
|
|
|
def setGain(self, gain):
|
|
r"""setGain(ResponsePAZ self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
|
|
return _datamodel.ResponsePAZ_setGain(self, gain)
|
|
|
|
def gain(self):
|
|
r"""gain(ResponsePAZ self) -> double"""
|
|
return _datamodel.ResponsePAZ_gain(self)
|
|
|
|
def setGainFrequency(self, gainFrequency):
|
|
r"""setGainFrequency(ResponsePAZ self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
|
|
return _datamodel.ResponsePAZ_setGainFrequency(self, gainFrequency)
|
|
|
|
def gainFrequency(self):
|
|
r"""gainFrequency(ResponsePAZ self) -> double"""
|
|
return _datamodel.ResponsePAZ_gainFrequency(self)
|
|
|
|
def setNormalizationFactor(self, normalizationFactor):
|
|
r"""setNormalizationFactor(ResponsePAZ self, Seiscomp::Core::Optional< double >::Impl const & normalizationFactor)"""
|
|
return _datamodel.ResponsePAZ_setNormalizationFactor(self, normalizationFactor)
|
|
|
|
def normalizationFactor(self):
|
|
r"""normalizationFactor(ResponsePAZ self) -> double"""
|
|
return _datamodel.ResponsePAZ_normalizationFactor(self)
|
|
|
|
def setNormalizationFrequency(self, normalizationFrequency):
|
|
r"""setNormalizationFrequency(ResponsePAZ self, Seiscomp::Core::Optional< double >::Impl const & normalizationFrequency)"""
|
|
return _datamodel.ResponsePAZ_setNormalizationFrequency(self, normalizationFrequency)
|
|
|
|
def normalizationFrequency(self):
|
|
r"""normalizationFrequency(ResponsePAZ self) -> double"""
|
|
return _datamodel.ResponsePAZ_normalizationFrequency(self)
|
|
|
|
def setNumberOfZeros(self, numberOfZeros):
|
|
r"""setNumberOfZeros(ResponsePAZ self, Seiscomp::Core::Optional< int >::Impl const & numberOfZeros)"""
|
|
return _datamodel.ResponsePAZ_setNumberOfZeros(self, numberOfZeros)
|
|
|
|
def numberOfZeros(self):
|
|
r"""numberOfZeros(ResponsePAZ self) -> int"""
|
|
return _datamodel.ResponsePAZ_numberOfZeros(self)
|
|
|
|
def setNumberOfPoles(self, numberOfPoles):
|
|
r"""setNumberOfPoles(ResponsePAZ self, Seiscomp::Core::Optional< int >::Impl const & numberOfPoles)"""
|
|
return _datamodel.ResponsePAZ_setNumberOfPoles(self, numberOfPoles)
|
|
|
|
def numberOfPoles(self):
|
|
r"""numberOfPoles(ResponsePAZ self) -> int"""
|
|
return _datamodel.ResponsePAZ_numberOfPoles(self)
|
|
|
|
def setZeros(self, zeros):
|
|
r"""setZeros(ResponsePAZ self, Seiscomp::Core::Optional< Seiscomp::DataModel::ComplexArray >::Impl const & zeros)"""
|
|
return _datamodel.ResponsePAZ_setZeros(self, zeros)
|
|
|
|
def zeros(self, *args):
|
|
r"""
|
|
zeros(ResponsePAZ self) -> ComplexArray
|
|
zeros(ResponsePAZ self) -> ComplexArray
|
|
"""
|
|
return _datamodel.ResponsePAZ_zeros(self, *args)
|
|
|
|
def setPoles(self, poles):
|
|
r"""setPoles(ResponsePAZ self, Seiscomp::Core::Optional< Seiscomp::DataModel::ComplexArray >::Impl const & poles)"""
|
|
return _datamodel.ResponsePAZ_setPoles(self, poles)
|
|
|
|
def poles(self, *args):
|
|
r"""
|
|
poles(ResponsePAZ self) -> ComplexArray
|
|
poles(ResponsePAZ self) -> ComplexArray
|
|
"""
|
|
return _datamodel.ResponsePAZ_poles(self, *args)
|
|
|
|
def setRemark(self, remark):
|
|
r"""setRemark(ResponsePAZ self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
|
|
return _datamodel.ResponsePAZ_setRemark(self, remark)
|
|
|
|
def remark(self, *args):
|
|
r"""
|
|
remark(ResponsePAZ self) -> Blob
|
|
remark(ResponsePAZ self) -> Blob
|
|
"""
|
|
return _datamodel.ResponsePAZ_remark(self, *args)
|
|
|
|
def setDecimationFactor(self, decimationFactor):
|
|
r"""setDecimationFactor(ResponsePAZ self, Seiscomp::Core::Optional< int >::Impl const & decimationFactor)"""
|
|
return _datamodel.ResponsePAZ_setDecimationFactor(self, decimationFactor)
|
|
|
|
def decimationFactor(self):
|
|
r"""decimationFactor(ResponsePAZ self) -> int"""
|
|
return _datamodel.ResponsePAZ_decimationFactor(self)
|
|
|
|
def setDelay(self, delay):
|
|
r"""setDelay(ResponsePAZ self, Seiscomp::Core::Optional< double >::Impl const & delay)"""
|
|
return _datamodel.ResponsePAZ_setDelay(self, delay)
|
|
|
|
def delay(self):
|
|
r"""delay(ResponsePAZ self) -> double"""
|
|
return _datamodel.ResponsePAZ_delay(self)
|
|
|
|
def setCorrection(self, correction):
|
|
r"""setCorrection(ResponsePAZ self, Seiscomp::Core::Optional< double >::Impl const & correction)"""
|
|
return _datamodel.ResponsePAZ_setCorrection(self, correction)
|
|
|
|
def correction(self):
|
|
r"""correction(ResponsePAZ self) -> double"""
|
|
return _datamodel.ResponsePAZ_correction(self)
|
|
|
|
def index(self):
|
|
r"""index(ResponsePAZ self) -> ResponsePAZIndex"""
|
|
return _datamodel.ResponsePAZ_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(ResponsePAZ self, ResponsePAZ lhs) -> bool"""
|
|
return _datamodel.ResponsePAZ_equalIndex(self, lhs)
|
|
|
|
def inventory(self):
|
|
r"""inventory(ResponsePAZ self) -> Inventory"""
|
|
return _datamodel.ResponsePAZ_inventory(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(ResponsePAZ self, Object other) -> bool"""
|
|
return _datamodel.ResponsePAZ_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(ResponsePAZ self, PublicObject parent) -> bool"""
|
|
return _datamodel.ResponsePAZ_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(ResponsePAZ self, PublicObject parent) -> bool"""
|
|
return _datamodel.ResponsePAZ_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(ResponsePAZ self) -> bool"""
|
|
return _datamodel.ResponsePAZ_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(ResponsePAZ self) -> Object"""
|
|
return _datamodel.ResponsePAZ_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(ResponsePAZ self, Object child) -> bool"""
|
|
return _datamodel.ResponsePAZ_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(ResponsePAZ self, Visitor visitor)"""
|
|
return _datamodel.ResponsePAZ_accept(self, visitor)
|
|
|
|
# Register ResponsePAZ in _datamodel:
|
|
_datamodel.ResponsePAZ_swigregister(ResponsePAZ)
|
|
|
|
def ResponsePAZ_ClassName():
|
|
r"""ResponsePAZ_ClassName() -> char const *"""
|
|
return _datamodel.ResponsePAZ_ClassName()
|
|
|
|
def ResponsePAZ_TypeInfo():
|
|
r"""ResponsePAZ_TypeInfo() -> RTTI"""
|
|
return _datamodel.ResponsePAZ_TypeInfo()
|
|
|
|
def ResponsePAZ_Cast(*args):
|
|
r"""
|
|
ResponsePAZ_Cast(BaseObject o) -> ResponsePAZ
|
|
ResponsePAZ_Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponsePAZ
|
|
"""
|
|
return _datamodel.ResponsePAZ_Cast(*args)
|
|
|
|
def ResponsePAZ_ConstCast(*args):
|
|
r"""
|
|
ResponsePAZ_ConstCast(BaseObject o) -> ResponsePAZ
|
|
ResponsePAZ_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponsePAZ
|
|
"""
|
|
return _datamodel.ResponsePAZ_ConstCast(*args)
|
|
|
|
def ResponsePAZ_Meta():
|
|
r"""ResponsePAZ_Meta() -> MetaObject"""
|
|
return _datamodel.ResponsePAZ_Meta()
|
|
|
|
def ResponsePAZ_Create(*args):
|
|
r"""
|
|
ResponsePAZ_Create() -> ResponsePAZ
|
|
ResponsePAZ_Create(std::string const & publicID) -> ResponsePAZ
|
|
"""
|
|
return _datamodel.ResponsePAZ_Create(*args)
|
|
|
|
def ResponsePAZ_Find(publicID):
|
|
r"""ResponsePAZ_Find(std::string const & publicID) -> ResponsePAZ"""
|
|
return _datamodel.ResponsePAZ_Find(publicID)
|
|
|
|
class ResponsePolynomialIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ResponsePolynomialIndex 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__(ResponsePolynomialIndex self) -> ResponsePolynomialIndex
|
|
__init__(ResponsePolynomialIndex self, std::string const & name) -> ResponsePolynomialIndex
|
|
__init__(ResponsePolynomialIndex self, ResponsePolynomialIndex arg2) -> ResponsePolynomialIndex
|
|
"""
|
|
_datamodel.ResponsePolynomialIndex_swiginit(self, _datamodel.new_ResponsePolynomialIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(ResponsePolynomialIndex self, ResponsePolynomialIndex arg2) -> bool"""
|
|
return _datamodel.ResponsePolynomialIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(ResponsePolynomialIndex self, ResponsePolynomialIndex arg2) -> bool"""
|
|
return _datamodel.ResponsePolynomialIndex___ne__(self, arg2)
|
|
name = property(_datamodel.ResponsePolynomialIndex_name_get, _datamodel.ResponsePolynomialIndex_name_set, doc=r"""name : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_ResponsePolynomialIndex
|
|
|
|
# Register ResponsePolynomialIndex in _datamodel:
|
|
_datamodel.ResponsePolynomialIndex_swigregister(ResponsePolynomialIndex)
|
|
|
|
class ResponsePolynomial(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ResponsePolynomial 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 _datamodel.ResponsePolynomial_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ResponsePolynomial_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ResponsePolynomial self) -> char const *"""
|
|
return _datamodel.ResponsePolynomial_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ResponsePolynomial self) -> RTTI"""
|
|
return _datamodel.ResponsePolynomial_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ResponsePolynomial
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponsePolynomial
|
|
"""
|
|
return _datamodel.ResponsePolynomial_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ResponsePolynomial
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponsePolynomial
|
|
"""
|
|
return _datamodel.ResponsePolynomial_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ResponsePolynomial self, GenericArchive ar)"""
|
|
return _datamodel.ResponsePolynomial_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ResponsePolynomial_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ResponsePolynomial self) -> MetaObject"""
|
|
return _datamodel.ResponsePolynomial_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ResponsePolynomial self, ResponsePolynomial other) -> ResponsePolynomial
|
|
__init__(ResponsePolynomial self, std::string const & publicID) -> ResponsePolynomial
|
|
"""
|
|
_datamodel.ResponsePolynomial_swiginit(self, _datamodel.new_ResponsePolynomial(*args))
|
|
__swig_destroy__ = _datamodel.delete_ResponsePolynomial
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> ResponsePolynomial
|
|
Create(std::string const & publicID) -> ResponsePolynomial
|
|
"""
|
|
return _datamodel.ResponsePolynomial_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> ResponsePolynomial"""
|
|
return _datamodel.ResponsePolynomial_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ResponsePolynomial self, ResponsePolynomial other) -> bool"""
|
|
return _datamodel.ResponsePolynomial___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ResponsePolynomial self, ResponsePolynomial other) -> bool"""
|
|
return _datamodel.ResponsePolynomial___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ResponsePolynomial self, ResponsePolynomial other) -> bool"""
|
|
return _datamodel.ResponsePolynomial_equal(self, other)
|
|
|
|
def setName(self, name):
|
|
r"""setName(ResponsePolynomial self, std::string const & name)"""
|
|
return _datamodel.ResponsePolynomial_setName(self, name)
|
|
|
|
def name(self):
|
|
r"""name(ResponsePolynomial self) -> std::string const &"""
|
|
return _datamodel.ResponsePolynomial_name(self)
|
|
|
|
def setGain(self, gain):
|
|
r"""setGain(ResponsePolynomial self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
|
|
return _datamodel.ResponsePolynomial_setGain(self, gain)
|
|
|
|
def gain(self):
|
|
r"""gain(ResponsePolynomial self) -> double"""
|
|
return _datamodel.ResponsePolynomial_gain(self)
|
|
|
|
def setGainFrequency(self, gainFrequency):
|
|
r"""setGainFrequency(ResponsePolynomial self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
|
|
return _datamodel.ResponsePolynomial_setGainFrequency(self, gainFrequency)
|
|
|
|
def gainFrequency(self):
|
|
r"""gainFrequency(ResponsePolynomial self) -> double"""
|
|
return _datamodel.ResponsePolynomial_gainFrequency(self)
|
|
|
|
def setFrequencyUnit(self, frequencyUnit):
|
|
r"""setFrequencyUnit(ResponsePolynomial self, std::string const & frequencyUnit)"""
|
|
return _datamodel.ResponsePolynomial_setFrequencyUnit(self, frequencyUnit)
|
|
|
|
def frequencyUnit(self):
|
|
r"""frequencyUnit(ResponsePolynomial self) -> std::string const &"""
|
|
return _datamodel.ResponsePolynomial_frequencyUnit(self)
|
|
|
|
def setApproximationType(self, approximationType):
|
|
r"""setApproximationType(ResponsePolynomial self, std::string const & approximationType)"""
|
|
return _datamodel.ResponsePolynomial_setApproximationType(self, approximationType)
|
|
|
|
def approximationType(self):
|
|
r"""approximationType(ResponsePolynomial self) -> std::string const &"""
|
|
return _datamodel.ResponsePolynomial_approximationType(self)
|
|
|
|
def setApproximationLowerBound(self, approximationLowerBound):
|
|
r"""setApproximationLowerBound(ResponsePolynomial self, Seiscomp::Core::Optional< double >::Impl const & approximationLowerBound)"""
|
|
return _datamodel.ResponsePolynomial_setApproximationLowerBound(self, approximationLowerBound)
|
|
|
|
def approximationLowerBound(self):
|
|
r"""approximationLowerBound(ResponsePolynomial self) -> double"""
|
|
return _datamodel.ResponsePolynomial_approximationLowerBound(self)
|
|
|
|
def setApproximationUpperBound(self, approximationUpperBound):
|
|
r"""setApproximationUpperBound(ResponsePolynomial self, Seiscomp::Core::Optional< double >::Impl const & approximationUpperBound)"""
|
|
return _datamodel.ResponsePolynomial_setApproximationUpperBound(self, approximationUpperBound)
|
|
|
|
def approximationUpperBound(self):
|
|
r"""approximationUpperBound(ResponsePolynomial self) -> double"""
|
|
return _datamodel.ResponsePolynomial_approximationUpperBound(self)
|
|
|
|
def setApproximationError(self, approximationError):
|
|
r"""setApproximationError(ResponsePolynomial self, Seiscomp::Core::Optional< double >::Impl const & approximationError)"""
|
|
return _datamodel.ResponsePolynomial_setApproximationError(self, approximationError)
|
|
|
|
def approximationError(self):
|
|
r"""approximationError(ResponsePolynomial self) -> double"""
|
|
return _datamodel.ResponsePolynomial_approximationError(self)
|
|
|
|
def setNumberOfCoefficients(self, numberOfCoefficients):
|
|
r"""setNumberOfCoefficients(ResponsePolynomial self, Seiscomp::Core::Optional< int >::Impl const & numberOfCoefficients)"""
|
|
return _datamodel.ResponsePolynomial_setNumberOfCoefficients(self, numberOfCoefficients)
|
|
|
|
def numberOfCoefficients(self):
|
|
r"""numberOfCoefficients(ResponsePolynomial self) -> int"""
|
|
return _datamodel.ResponsePolynomial_numberOfCoefficients(self)
|
|
|
|
def setCoefficients(self, coefficients):
|
|
r"""setCoefficients(ResponsePolynomial self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealArray >::Impl const & coefficients)"""
|
|
return _datamodel.ResponsePolynomial_setCoefficients(self, coefficients)
|
|
|
|
def coefficients(self, *args):
|
|
r"""
|
|
coefficients(ResponsePolynomial self) -> RealArray
|
|
coefficients(ResponsePolynomial self) -> RealArray
|
|
"""
|
|
return _datamodel.ResponsePolynomial_coefficients(self, *args)
|
|
|
|
def setRemark(self, remark):
|
|
r"""setRemark(ResponsePolynomial self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
|
|
return _datamodel.ResponsePolynomial_setRemark(self, remark)
|
|
|
|
def remark(self, *args):
|
|
r"""
|
|
remark(ResponsePolynomial self) -> Blob
|
|
remark(ResponsePolynomial self) -> Blob
|
|
"""
|
|
return _datamodel.ResponsePolynomial_remark(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(ResponsePolynomial self) -> ResponsePolynomialIndex"""
|
|
return _datamodel.ResponsePolynomial_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(ResponsePolynomial self, ResponsePolynomial lhs) -> bool"""
|
|
return _datamodel.ResponsePolynomial_equalIndex(self, lhs)
|
|
|
|
def inventory(self):
|
|
r"""inventory(ResponsePolynomial self) -> Inventory"""
|
|
return _datamodel.ResponsePolynomial_inventory(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(ResponsePolynomial self, Object other) -> bool"""
|
|
return _datamodel.ResponsePolynomial_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(ResponsePolynomial self, PublicObject parent) -> bool"""
|
|
return _datamodel.ResponsePolynomial_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(ResponsePolynomial self, PublicObject parent) -> bool"""
|
|
return _datamodel.ResponsePolynomial_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(ResponsePolynomial self) -> bool"""
|
|
return _datamodel.ResponsePolynomial_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(ResponsePolynomial self) -> Object"""
|
|
return _datamodel.ResponsePolynomial_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(ResponsePolynomial self, Object child) -> bool"""
|
|
return _datamodel.ResponsePolynomial_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(ResponsePolynomial self, Visitor visitor)"""
|
|
return _datamodel.ResponsePolynomial_accept(self, visitor)
|
|
|
|
# Register ResponsePolynomial in _datamodel:
|
|
_datamodel.ResponsePolynomial_swigregister(ResponsePolynomial)
|
|
|
|
def ResponsePolynomial_ClassName():
|
|
r"""ResponsePolynomial_ClassName() -> char const *"""
|
|
return _datamodel.ResponsePolynomial_ClassName()
|
|
|
|
def ResponsePolynomial_TypeInfo():
|
|
r"""ResponsePolynomial_TypeInfo() -> RTTI"""
|
|
return _datamodel.ResponsePolynomial_TypeInfo()
|
|
|
|
def ResponsePolynomial_Cast(*args):
|
|
r"""
|
|
ResponsePolynomial_Cast(BaseObject o) -> ResponsePolynomial
|
|
ResponsePolynomial_Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponsePolynomial
|
|
"""
|
|
return _datamodel.ResponsePolynomial_Cast(*args)
|
|
|
|
def ResponsePolynomial_ConstCast(*args):
|
|
r"""
|
|
ResponsePolynomial_ConstCast(BaseObject o) -> ResponsePolynomial
|
|
ResponsePolynomial_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponsePolynomial
|
|
"""
|
|
return _datamodel.ResponsePolynomial_ConstCast(*args)
|
|
|
|
def ResponsePolynomial_Meta():
|
|
r"""ResponsePolynomial_Meta() -> MetaObject"""
|
|
return _datamodel.ResponsePolynomial_Meta()
|
|
|
|
def ResponsePolynomial_Create(*args):
|
|
r"""
|
|
ResponsePolynomial_Create() -> ResponsePolynomial
|
|
ResponsePolynomial_Create(std::string const & publicID) -> ResponsePolynomial
|
|
"""
|
|
return _datamodel.ResponsePolynomial_Create(*args)
|
|
|
|
def ResponsePolynomial_Find(publicID):
|
|
r"""ResponsePolynomial_Find(std::string const & publicID) -> ResponsePolynomial"""
|
|
return _datamodel.ResponsePolynomial_Find(publicID)
|
|
|
|
class ResponseFAPIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ResponseFAPIndex 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__(ResponseFAPIndex self) -> ResponseFAPIndex
|
|
__init__(ResponseFAPIndex self, std::string const & name) -> ResponseFAPIndex
|
|
__init__(ResponseFAPIndex self, ResponseFAPIndex arg2) -> ResponseFAPIndex
|
|
"""
|
|
_datamodel.ResponseFAPIndex_swiginit(self, _datamodel.new_ResponseFAPIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(ResponseFAPIndex self, ResponseFAPIndex arg2) -> bool"""
|
|
return _datamodel.ResponseFAPIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(ResponseFAPIndex self, ResponseFAPIndex arg2) -> bool"""
|
|
return _datamodel.ResponseFAPIndex___ne__(self, arg2)
|
|
name = property(_datamodel.ResponseFAPIndex_name_get, _datamodel.ResponseFAPIndex_name_set, doc=r"""name : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_ResponseFAPIndex
|
|
|
|
# Register ResponseFAPIndex in _datamodel:
|
|
_datamodel.ResponseFAPIndex_swigregister(ResponseFAPIndex)
|
|
|
|
class ResponseFAP(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ResponseFAP 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 _datamodel.ResponseFAP_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ResponseFAP_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ResponseFAP self) -> char const *"""
|
|
return _datamodel.ResponseFAP_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ResponseFAP self) -> RTTI"""
|
|
return _datamodel.ResponseFAP_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ResponseFAP
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponseFAP
|
|
"""
|
|
return _datamodel.ResponseFAP_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ResponseFAP
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponseFAP
|
|
"""
|
|
return _datamodel.ResponseFAP_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ResponseFAP self, GenericArchive ar)"""
|
|
return _datamodel.ResponseFAP_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ResponseFAP_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ResponseFAP self) -> MetaObject"""
|
|
return _datamodel.ResponseFAP_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ResponseFAP self, ResponseFAP other) -> ResponseFAP
|
|
__init__(ResponseFAP self, std::string const & publicID) -> ResponseFAP
|
|
"""
|
|
_datamodel.ResponseFAP_swiginit(self, _datamodel.new_ResponseFAP(*args))
|
|
__swig_destroy__ = _datamodel.delete_ResponseFAP
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> ResponseFAP
|
|
Create(std::string const & publicID) -> ResponseFAP
|
|
"""
|
|
return _datamodel.ResponseFAP_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> ResponseFAP"""
|
|
return _datamodel.ResponseFAP_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ResponseFAP self, ResponseFAP other) -> bool"""
|
|
return _datamodel.ResponseFAP___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ResponseFAP self, ResponseFAP other) -> bool"""
|
|
return _datamodel.ResponseFAP___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ResponseFAP self, ResponseFAP other) -> bool"""
|
|
return _datamodel.ResponseFAP_equal(self, other)
|
|
|
|
def setName(self, name):
|
|
r"""setName(ResponseFAP self, std::string const & name)"""
|
|
return _datamodel.ResponseFAP_setName(self, name)
|
|
|
|
def name(self):
|
|
r"""name(ResponseFAP self) -> std::string const &"""
|
|
return _datamodel.ResponseFAP_name(self)
|
|
|
|
def setGain(self, gain):
|
|
r"""setGain(ResponseFAP self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
|
|
return _datamodel.ResponseFAP_setGain(self, gain)
|
|
|
|
def gain(self):
|
|
r"""gain(ResponseFAP self) -> double"""
|
|
return _datamodel.ResponseFAP_gain(self)
|
|
|
|
def setGainFrequency(self, gainFrequency):
|
|
r"""setGainFrequency(ResponseFAP self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
|
|
return _datamodel.ResponseFAP_setGainFrequency(self, gainFrequency)
|
|
|
|
def gainFrequency(self):
|
|
r"""gainFrequency(ResponseFAP self) -> double"""
|
|
return _datamodel.ResponseFAP_gainFrequency(self)
|
|
|
|
def setNumberOfTuples(self, numberOfTuples):
|
|
r"""setNumberOfTuples(ResponseFAP self, Seiscomp::Core::Optional< int >::Impl const & numberOfTuples)"""
|
|
return _datamodel.ResponseFAP_setNumberOfTuples(self, numberOfTuples)
|
|
|
|
def numberOfTuples(self):
|
|
r"""numberOfTuples(ResponseFAP self) -> int"""
|
|
return _datamodel.ResponseFAP_numberOfTuples(self)
|
|
|
|
def setTuples(self, tuples):
|
|
r"""setTuples(ResponseFAP self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealArray >::Impl const & tuples)"""
|
|
return _datamodel.ResponseFAP_setTuples(self, tuples)
|
|
|
|
def tuples(self, *args):
|
|
r"""
|
|
tuples(ResponseFAP self) -> RealArray
|
|
tuples(ResponseFAP self) -> RealArray
|
|
"""
|
|
return _datamodel.ResponseFAP_tuples(self, *args)
|
|
|
|
def setRemark(self, remark):
|
|
r"""setRemark(ResponseFAP self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
|
|
return _datamodel.ResponseFAP_setRemark(self, remark)
|
|
|
|
def remark(self, *args):
|
|
r"""
|
|
remark(ResponseFAP self) -> Blob
|
|
remark(ResponseFAP self) -> Blob
|
|
"""
|
|
return _datamodel.ResponseFAP_remark(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(ResponseFAP self) -> ResponseFAPIndex"""
|
|
return _datamodel.ResponseFAP_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(ResponseFAP self, ResponseFAP lhs) -> bool"""
|
|
return _datamodel.ResponseFAP_equalIndex(self, lhs)
|
|
|
|
def inventory(self):
|
|
r"""inventory(ResponseFAP self) -> Inventory"""
|
|
return _datamodel.ResponseFAP_inventory(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(ResponseFAP self, Object other) -> bool"""
|
|
return _datamodel.ResponseFAP_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(ResponseFAP self, PublicObject parent) -> bool"""
|
|
return _datamodel.ResponseFAP_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(ResponseFAP self, PublicObject parent) -> bool"""
|
|
return _datamodel.ResponseFAP_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(ResponseFAP self) -> bool"""
|
|
return _datamodel.ResponseFAP_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(ResponseFAP self) -> Object"""
|
|
return _datamodel.ResponseFAP_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(ResponseFAP self, Object child) -> bool"""
|
|
return _datamodel.ResponseFAP_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(ResponseFAP self, Visitor visitor)"""
|
|
return _datamodel.ResponseFAP_accept(self, visitor)
|
|
|
|
# Register ResponseFAP in _datamodel:
|
|
_datamodel.ResponseFAP_swigregister(ResponseFAP)
|
|
|
|
def ResponseFAP_ClassName():
|
|
r"""ResponseFAP_ClassName() -> char const *"""
|
|
return _datamodel.ResponseFAP_ClassName()
|
|
|
|
def ResponseFAP_TypeInfo():
|
|
r"""ResponseFAP_TypeInfo() -> RTTI"""
|
|
return _datamodel.ResponseFAP_TypeInfo()
|
|
|
|
def ResponseFAP_Cast(*args):
|
|
r"""
|
|
ResponseFAP_Cast(BaseObject o) -> ResponseFAP
|
|
ResponseFAP_Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponseFAP
|
|
"""
|
|
return _datamodel.ResponseFAP_Cast(*args)
|
|
|
|
def ResponseFAP_ConstCast(*args):
|
|
r"""
|
|
ResponseFAP_ConstCast(BaseObject o) -> ResponseFAP
|
|
ResponseFAP_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponseFAP
|
|
"""
|
|
return _datamodel.ResponseFAP_ConstCast(*args)
|
|
|
|
def ResponseFAP_Meta():
|
|
r"""ResponseFAP_Meta() -> MetaObject"""
|
|
return _datamodel.ResponseFAP_Meta()
|
|
|
|
def ResponseFAP_Create(*args):
|
|
r"""
|
|
ResponseFAP_Create() -> ResponseFAP
|
|
ResponseFAP_Create(std::string const & publicID) -> ResponseFAP
|
|
"""
|
|
return _datamodel.ResponseFAP_Create(*args)
|
|
|
|
def ResponseFAP_Find(publicID):
|
|
r"""ResponseFAP_Find(std::string const & publicID) -> ResponseFAP"""
|
|
return _datamodel.ResponseFAP_Find(publicID)
|
|
|
|
class ResponseFIRIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ResponseFIRIndex 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__(ResponseFIRIndex self) -> ResponseFIRIndex
|
|
__init__(ResponseFIRIndex self, std::string const & name) -> ResponseFIRIndex
|
|
__init__(ResponseFIRIndex self, ResponseFIRIndex arg2) -> ResponseFIRIndex
|
|
"""
|
|
_datamodel.ResponseFIRIndex_swiginit(self, _datamodel.new_ResponseFIRIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(ResponseFIRIndex self, ResponseFIRIndex arg2) -> bool"""
|
|
return _datamodel.ResponseFIRIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(ResponseFIRIndex self, ResponseFIRIndex arg2) -> bool"""
|
|
return _datamodel.ResponseFIRIndex___ne__(self, arg2)
|
|
name = property(_datamodel.ResponseFIRIndex_name_get, _datamodel.ResponseFIRIndex_name_set, doc=r"""name : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_ResponseFIRIndex
|
|
|
|
# Register ResponseFIRIndex in _datamodel:
|
|
_datamodel.ResponseFIRIndex_swigregister(ResponseFIRIndex)
|
|
|
|
class ResponseFIR(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ResponseFIR 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 _datamodel.ResponseFIR_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ResponseFIR_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ResponseFIR self) -> char const *"""
|
|
return _datamodel.ResponseFIR_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ResponseFIR self) -> RTTI"""
|
|
return _datamodel.ResponseFIR_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ResponseFIR
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponseFIR
|
|
"""
|
|
return _datamodel.ResponseFIR_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ResponseFIR
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponseFIR
|
|
"""
|
|
return _datamodel.ResponseFIR_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ResponseFIR self, GenericArchive ar)"""
|
|
return _datamodel.ResponseFIR_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ResponseFIR_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ResponseFIR self) -> MetaObject"""
|
|
return _datamodel.ResponseFIR_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ResponseFIR self, ResponseFIR other) -> ResponseFIR
|
|
__init__(ResponseFIR self, std::string const & publicID) -> ResponseFIR
|
|
"""
|
|
_datamodel.ResponseFIR_swiginit(self, _datamodel.new_ResponseFIR(*args))
|
|
__swig_destroy__ = _datamodel.delete_ResponseFIR
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> ResponseFIR
|
|
Create(std::string const & publicID) -> ResponseFIR
|
|
"""
|
|
return _datamodel.ResponseFIR_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> ResponseFIR"""
|
|
return _datamodel.ResponseFIR_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ResponseFIR self, ResponseFIR other) -> bool"""
|
|
return _datamodel.ResponseFIR___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ResponseFIR self, ResponseFIR other) -> bool"""
|
|
return _datamodel.ResponseFIR___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ResponseFIR self, ResponseFIR other) -> bool"""
|
|
return _datamodel.ResponseFIR_equal(self, other)
|
|
|
|
def setName(self, name):
|
|
r"""setName(ResponseFIR self, std::string const & name)"""
|
|
return _datamodel.ResponseFIR_setName(self, name)
|
|
|
|
def name(self):
|
|
r"""name(ResponseFIR self) -> std::string const &"""
|
|
return _datamodel.ResponseFIR_name(self)
|
|
|
|
def setGain(self, gain):
|
|
r"""setGain(ResponseFIR self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
|
|
return _datamodel.ResponseFIR_setGain(self, gain)
|
|
|
|
def gain(self):
|
|
r"""gain(ResponseFIR self) -> double"""
|
|
return _datamodel.ResponseFIR_gain(self)
|
|
|
|
def setGainFrequency(self, gainFrequency):
|
|
r"""setGainFrequency(ResponseFIR self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
|
|
return _datamodel.ResponseFIR_setGainFrequency(self, gainFrequency)
|
|
|
|
def gainFrequency(self):
|
|
r"""gainFrequency(ResponseFIR self) -> double"""
|
|
return _datamodel.ResponseFIR_gainFrequency(self)
|
|
|
|
def setDecimationFactor(self, decimationFactor):
|
|
r"""setDecimationFactor(ResponseFIR self, Seiscomp::Core::Optional< int >::Impl const & decimationFactor)"""
|
|
return _datamodel.ResponseFIR_setDecimationFactor(self, decimationFactor)
|
|
|
|
def decimationFactor(self):
|
|
r"""decimationFactor(ResponseFIR self) -> int"""
|
|
return _datamodel.ResponseFIR_decimationFactor(self)
|
|
|
|
def setDelay(self, delay):
|
|
r"""setDelay(ResponseFIR self, Seiscomp::Core::Optional< double >::Impl const & delay)"""
|
|
return _datamodel.ResponseFIR_setDelay(self, delay)
|
|
|
|
def delay(self):
|
|
r"""delay(ResponseFIR self) -> double"""
|
|
return _datamodel.ResponseFIR_delay(self)
|
|
|
|
def setCorrection(self, correction):
|
|
r"""setCorrection(ResponseFIR self, Seiscomp::Core::Optional< double >::Impl const & correction)"""
|
|
return _datamodel.ResponseFIR_setCorrection(self, correction)
|
|
|
|
def correction(self):
|
|
r"""correction(ResponseFIR self) -> double"""
|
|
return _datamodel.ResponseFIR_correction(self)
|
|
|
|
def setNumberOfCoefficients(self, numberOfCoefficients):
|
|
r"""setNumberOfCoefficients(ResponseFIR self, Seiscomp::Core::Optional< int >::Impl const & numberOfCoefficients)"""
|
|
return _datamodel.ResponseFIR_setNumberOfCoefficients(self, numberOfCoefficients)
|
|
|
|
def numberOfCoefficients(self):
|
|
r"""numberOfCoefficients(ResponseFIR self) -> int"""
|
|
return _datamodel.ResponseFIR_numberOfCoefficients(self)
|
|
|
|
def setSymmetry(self, symmetry):
|
|
r"""setSymmetry(ResponseFIR self, std::string const & symmetry)"""
|
|
return _datamodel.ResponseFIR_setSymmetry(self, symmetry)
|
|
|
|
def symmetry(self):
|
|
r"""symmetry(ResponseFIR self) -> std::string const &"""
|
|
return _datamodel.ResponseFIR_symmetry(self)
|
|
|
|
def setCoefficients(self, coefficients):
|
|
r"""setCoefficients(ResponseFIR self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealArray >::Impl const & coefficients)"""
|
|
return _datamodel.ResponseFIR_setCoefficients(self, coefficients)
|
|
|
|
def coefficients(self, *args):
|
|
r"""
|
|
coefficients(ResponseFIR self) -> RealArray
|
|
coefficients(ResponseFIR self) -> RealArray
|
|
"""
|
|
return _datamodel.ResponseFIR_coefficients(self, *args)
|
|
|
|
def setRemark(self, remark):
|
|
r"""setRemark(ResponseFIR self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
|
|
return _datamodel.ResponseFIR_setRemark(self, remark)
|
|
|
|
def remark(self, *args):
|
|
r"""
|
|
remark(ResponseFIR self) -> Blob
|
|
remark(ResponseFIR self) -> Blob
|
|
"""
|
|
return _datamodel.ResponseFIR_remark(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(ResponseFIR self) -> ResponseFIRIndex"""
|
|
return _datamodel.ResponseFIR_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(ResponseFIR self, ResponseFIR lhs) -> bool"""
|
|
return _datamodel.ResponseFIR_equalIndex(self, lhs)
|
|
|
|
def inventory(self):
|
|
r"""inventory(ResponseFIR self) -> Inventory"""
|
|
return _datamodel.ResponseFIR_inventory(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(ResponseFIR self, Object other) -> bool"""
|
|
return _datamodel.ResponseFIR_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(ResponseFIR self, PublicObject parent) -> bool"""
|
|
return _datamodel.ResponseFIR_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(ResponseFIR self, PublicObject parent) -> bool"""
|
|
return _datamodel.ResponseFIR_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(ResponseFIR self) -> bool"""
|
|
return _datamodel.ResponseFIR_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(ResponseFIR self) -> Object"""
|
|
return _datamodel.ResponseFIR_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(ResponseFIR self, Object child) -> bool"""
|
|
return _datamodel.ResponseFIR_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(ResponseFIR self, Visitor visitor)"""
|
|
return _datamodel.ResponseFIR_accept(self, visitor)
|
|
|
|
# Register ResponseFIR in _datamodel:
|
|
_datamodel.ResponseFIR_swigregister(ResponseFIR)
|
|
|
|
def ResponseFIR_ClassName():
|
|
r"""ResponseFIR_ClassName() -> char const *"""
|
|
return _datamodel.ResponseFIR_ClassName()
|
|
|
|
def ResponseFIR_TypeInfo():
|
|
r"""ResponseFIR_TypeInfo() -> RTTI"""
|
|
return _datamodel.ResponseFIR_TypeInfo()
|
|
|
|
def ResponseFIR_Cast(*args):
|
|
r"""
|
|
ResponseFIR_Cast(BaseObject o) -> ResponseFIR
|
|
ResponseFIR_Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponseFIR
|
|
"""
|
|
return _datamodel.ResponseFIR_Cast(*args)
|
|
|
|
def ResponseFIR_ConstCast(*args):
|
|
r"""
|
|
ResponseFIR_ConstCast(BaseObject o) -> ResponseFIR
|
|
ResponseFIR_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponseFIR
|
|
"""
|
|
return _datamodel.ResponseFIR_ConstCast(*args)
|
|
|
|
def ResponseFIR_Meta():
|
|
r"""ResponseFIR_Meta() -> MetaObject"""
|
|
return _datamodel.ResponseFIR_Meta()
|
|
|
|
def ResponseFIR_Create(*args):
|
|
r"""
|
|
ResponseFIR_Create() -> ResponseFIR
|
|
ResponseFIR_Create(std::string const & publicID) -> ResponseFIR
|
|
"""
|
|
return _datamodel.ResponseFIR_Create(*args)
|
|
|
|
def ResponseFIR_Find(publicID):
|
|
r"""ResponseFIR_Find(std::string const & publicID) -> ResponseFIR"""
|
|
return _datamodel.ResponseFIR_Find(publicID)
|
|
|
|
class ResponseIIRIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ResponseIIRIndex 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__(ResponseIIRIndex self) -> ResponseIIRIndex
|
|
__init__(ResponseIIRIndex self, std::string const & name) -> ResponseIIRIndex
|
|
__init__(ResponseIIRIndex self, ResponseIIRIndex arg2) -> ResponseIIRIndex
|
|
"""
|
|
_datamodel.ResponseIIRIndex_swiginit(self, _datamodel.new_ResponseIIRIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(ResponseIIRIndex self, ResponseIIRIndex arg2) -> bool"""
|
|
return _datamodel.ResponseIIRIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(ResponseIIRIndex self, ResponseIIRIndex arg2) -> bool"""
|
|
return _datamodel.ResponseIIRIndex___ne__(self, arg2)
|
|
name = property(_datamodel.ResponseIIRIndex_name_get, _datamodel.ResponseIIRIndex_name_set, doc=r"""name : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_ResponseIIRIndex
|
|
|
|
# Register ResponseIIRIndex in _datamodel:
|
|
_datamodel.ResponseIIRIndex_swigregister(ResponseIIRIndex)
|
|
|
|
class ResponseIIR(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ResponseIIR 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 _datamodel.ResponseIIR_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ResponseIIR_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ResponseIIR self) -> char const *"""
|
|
return _datamodel.ResponseIIR_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ResponseIIR self) -> RTTI"""
|
|
return _datamodel.ResponseIIR_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ResponseIIR
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponseIIR
|
|
"""
|
|
return _datamodel.ResponseIIR_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ResponseIIR
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponseIIR
|
|
"""
|
|
return _datamodel.ResponseIIR_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ResponseIIR self, GenericArchive ar)"""
|
|
return _datamodel.ResponseIIR_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ResponseIIR_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ResponseIIR self) -> MetaObject"""
|
|
return _datamodel.ResponseIIR_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ResponseIIR self, ResponseIIR other) -> ResponseIIR
|
|
__init__(ResponseIIR self, std::string const & publicID) -> ResponseIIR
|
|
"""
|
|
_datamodel.ResponseIIR_swiginit(self, _datamodel.new_ResponseIIR(*args))
|
|
__swig_destroy__ = _datamodel.delete_ResponseIIR
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> ResponseIIR
|
|
Create(std::string const & publicID) -> ResponseIIR
|
|
"""
|
|
return _datamodel.ResponseIIR_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> ResponseIIR"""
|
|
return _datamodel.ResponseIIR_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ResponseIIR self, ResponseIIR other) -> bool"""
|
|
return _datamodel.ResponseIIR___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ResponseIIR self, ResponseIIR other) -> bool"""
|
|
return _datamodel.ResponseIIR___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ResponseIIR self, ResponseIIR other) -> bool"""
|
|
return _datamodel.ResponseIIR_equal(self, other)
|
|
|
|
def setName(self, name):
|
|
r"""setName(ResponseIIR self, std::string const & name)"""
|
|
return _datamodel.ResponseIIR_setName(self, name)
|
|
|
|
def name(self):
|
|
r"""name(ResponseIIR self) -> std::string const &"""
|
|
return _datamodel.ResponseIIR_name(self)
|
|
|
|
def setType(self, type):
|
|
r"""setType(ResponseIIR self, std::string const & type)"""
|
|
return _datamodel.ResponseIIR_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(ResponseIIR self) -> std::string const &"""
|
|
return _datamodel.ResponseIIR_type(self)
|
|
|
|
def setGain(self, gain):
|
|
r"""setGain(ResponseIIR self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
|
|
return _datamodel.ResponseIIR_setGain(self, gain)
|
|
|
|
def gain(self):
|
|
r"""gain(ResponseIIR self) -> double"""
|
|
return _datamodel.ResponseIIR_gain(self)
|
|
|
|
def setGainFrequency(self, gainFrequency):
|
|
r"""setGainFrequency(ResponseIIR self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
|
|
return _datamodel.ResponseIIR_setGainFrequency(self, gainFrequency)
|
|
|
|
def gainFrequency(self):
|
|
r"""gainFrequency(ResponseIIR self) -> double"""
|
|
return _datamodel.ResponseIIR_gainFrequency(self)
|
|
|
|
def setDecimationFactor(self, decimationFactor):
|
|
r"""setDecimationFactor(ResponseIIR self, Seiscomp::Core::Optional< int >::Impl const & decimationFactor)"""
|
|
return _datamodel.ResponseIIR_setDecimationFactor(self, decimationFactor)
|
|
|
|
def decimationFactor(self):
|
|
r"""decimationFactor(ResponseIIR self) -> int"""
|
|
return _datamodel.ResponseIIR_decimationFactor(self)
|
|
|
|
def setDelay(self, delay):
|
|
r"""setDelay(ResponseIIR self, Seiscomp::Core::Optional< double >::Impl const & delay)"""
|
|
return _datamodel.ResponseIIR_setDelay(self, delay)
|
|
|
|
def delay(self):
|
|
r"""delay(ResponseIIR self) -> double"""
|
|
return _datamodel.ResponseIIR_delay(self)
|
|
|
|
def setCorrection(self, correction):
|
|
r"""setCorrection(ResponseIIR self, Seiscomp::Core::Optional< double >::Impl const & correction)"""
|
|
return _datamodel.ResponseIIR_setCorrection(self, correction)
|
|
|
|
def correction(self):
|
|
r"""correction(ResponseIIR self) -> double"""
|
|
return _datamodel.ResponseIIR_correction(self)
|
|
|
|
def setNumberOfNumerators(self, numberOfNumerators):
|
|
r"""setNumberOfNumerators(ResponseIIR self, Seiscomp::Core::Optional< int >::Impl const & numberOfNumerators)"""
|
|
return _datamodel.ResponseIIR_setNumberOfNumerators(self, numberOfNumerators)
|
|
|
|
def numberOfNumerators(self):
|
|
r"""numberOfNumerators(ResponseIIR self) -> int"""
|
|
return _datamodel.ResponseIIR_numberOfNumerators(self)
|
|
|
|
def setNumberOfDenominators(self, numberOfDenominators):
|
|
r"""setNumberOfDenominators(ResponseIIR self, Seiscomp::Core::Optional< int >::Impl const & numberOfDenominators)"""
|
|
return _datamodel.ResponseIIR_setNumberOfDenominators(self, numberOfDenominators)
|
|
|
|
def numberOfDenominators(self):
|
|
r"""numberOfDenominators(ResponseIIR self) -> int"""
|
|
return _datamodel.ResponseIIR_numberOfDenominators(self)
|
|
|
|
def setNumerators(self, numerators):
|
|
r"""setNumerators(ResponseIIR self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealArray >::Impl const & numerators)"""
|
|
return _datamodel.ResponseIIR_setNumerators(self, numerators)
|
|
|
|
def numerators(self, *args):
|
|
r"""
|
|
numerators(ResponseIIR self) -> RealArray
|
|
numerators(ResponseIIR self) -> RealArray
|
|
"""
|
|
return _datamodel.ResponseIIR_numerators(self, *args)
|
|
|
|
def setDenominators(self, denominators):
|
|
r"""setDenominators(ResponseIIR self, Seiscomp::Core::Optional< Seiscomp::DataModel::RealArray >::Impl const & denominators)"""
|
|
return _datamodel.ResponseIIR_setDenominators(self, denominators)
|
|
|
|
def denominators(self, *args):
|
|
r"""
|
|
denominators(ResponseIIR self) -> RealArray
|
|
denominators(ResponseIIR self) -> RealArray
|
|
"""
|
|
return _datamodel.ResponseIIR_denominators(self, *args)
|
|
|
|
def setRemark(self, remark):
|
|
r"""setRemark(ResponseIIR self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
|
|
return _datamodel.ResponseIIR_setRemark(self, remark)
|
|
|
|
def remark(self, *args):
|
|
r"""
|
|
remark(ResponseIIR self) -> Blob
|
|
remark(ResponseIIR self) -> Blob
|
|
"""
|
|
return _datamodel.ResponseIIR_remark(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(ResponseIIR self) -> ResponseIIRIndex"""
|
|
return _datamodel.ResponseIIR_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(ResponseIIR self, ResponseIIR lhs) -> bool"""
|
|
return _datamodel.ResponseIIR_equalIndex(self, lhs)
|
|
|
|
def inventory(self):
|
|
r"""inventory(ResponseIIR self) -> Inventory"""
|
|
return _datamodel.ResponseIIR_inventory(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(ResponseIIR self, Object other) -> bool"""
|
|
return _datamodel.ResponseIIR_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(ResponseIIR self, PublicObject parent) -> bool"""
|
|
return _datamodel.ResponseIIR_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(ResponseIIR self, PublicObject parent) -> bool"""
|
|
return _datamodel.ResponseIIR_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(ResponseIIR self) -> bool"""
|
|
return _datamodel.ResponseIIR_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(ResponseIIR self) -> Object"""
|
|
return _datamodel.ResponseIIR_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(ResponseIIR self, Object child) -> bool"""
|
|
return _datamodel.ResponseIIR_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(ResponseIIR self, Visitor visitor)"""
|
|
return _datamodel.ResponseIIR_accept(self, visitor)
|
|
|
|
# Register ResponseIIR in _datamodel:
|
|
_datamodel.ResponseIIR_swigregister(ResponseIIR)
|
|
|
|
def ResponseIIR_ClassName():
|
|
r"""ResponseIIR_ClassName() -> char const *"""
|
|
return _datamodel.ResponseIIR_ClassName()
|
|
|
|
def ResponseIIR_TypeInfo():
|
|
r"""ResponseIIR_TypeInfo() -> RTTI"""
|
|
return _datamodel.ResponseIIR_TypeInfo()
|
|
|
|
def ResponseIIR_Cast(*args):
|
|
r"""
|
|
ResponseIIR_Cast(BaseObject o) -> ResponseIIR
|
|
ResponseIIR_Cast(Seiscomp::Core::BaseObjectPtr o) -> ResponseIIR
|
|
"""
|
|
return _datamodel.ResponseIIR_Cast(*args)
|
|
|
|
def ResponseIIR_ConstCast(*args):
|
|
r"""
|
|
ResponseIIR_ConstCast(BaseObject o) -> ResponseIIR
|
|
ResponseIIR_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ResponseIIR
|
|
"""
|
|
return _datamodel.ResponseIIR_ConstCast(*args)
|
|
|
|
def ResponseIIR_Meta():
|
|
r"""ResponseIIR_Meta() -> MetaObject"""
|
|
return _datamodel.ResponseIIR_Meta()
|
|
|
|
def ResponseIIR_Create(*args):
|
|
r"""
|
|
ResponseIIR_Create() -> ResponseIIR
|
|
ResponseIIR_Create(std::string const & publicID) -> ResponseIIR
|
|
"""
|
|
return _datamodel.ResponseIIR_Create(*args)
|
|
|
|
def ResponseIIR_Find(publicID):
|
|
r"""ResponseIIR_Find(std::string const & publicID) -> ResponseIIR"""
|
|
return _datamodel.ResponseIIR_Find(publicID)
|
|
|
|
class DataloggerCalibrationIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DataloggerCalibrationIndex 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__(DataloggerCalibrationIndex self) -> DataloggerCalibrationIndex
|
|
__init__(DataloggerCalibrationIndex self, std::string const & serialNumber, int channel, Time start) -> DataloggerCalibrationIndex
|
|
__init__(DataloggerCalibrationIndex self, DataloggerCalibrationIndex arg2) -> DataloggerCalibrationIndex
|
|
"""
|
|
_datamodel.DataloggerCalibrationIndex_swiginit(self, _datamodel.new_DataloggerCalibrationIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(DataloggerCalibrationIndex self, DataloggerCalibrationIndex arg2) -> bool"""
|
|
return _datamodel.DataloggerCalibrationIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(DataloggerCalibrationIndex self, DataloggerCalibrationIndex arg2) -> bool"""
|
|
return _datamodel.DataloggerCalibrationIndex___ne__(self, arg2)
|
|
serialNumber = property(_datamodel.DataloggerCalibrationIndex_serialNumber_get, _datamodel.DataloggerCalibrationIndex_serialNumber_set, doc=r"""serialNumber : std::string""")
|
|
channel = property(_datamodel.DataloggerCalibrationIndex_channel_get, _datamodel.DataloggerCalibrationIndex_channel_set, doc=r"""channel : int""")
|
|
start = property(_datamodel.DataloggerCalibrationIndex_start_get, _datamodel.DataloggerCalibrationIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
|
|
__swig_destroy__ = _datamodel.delete_DataloggerCalibrationIndex
|
|
|
|
# Register DataloggerCalibrationIndex in _datamodel:
|
|
_datamodel.DataloggerCalibrationIndex_swigregister(DataloggerCalibrationIndex)
|
|
|
|
class DataloggerCalibration(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DataloggerCalibration 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 _datamodel.DataloggerCalibration_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.DataloggerCalibration_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(DataloggerCalibration self) -> char const *"""
|
|
return _datamodel.DataloggerCalibration_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(DataloggerCalibration self) -> RTTI"""
|
|
return _datamodel.DataloggerCalibration_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> DataloggerCalibration
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> DataloggerCalibration
|
|
"""
|
|
return _datamodel.DataloggerCalibration_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> DataloggerCalibration
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataloggerCalibration
|
|
"""
|
|
return _datamodel.DataloggerCalibration_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(DataloggerCalibration self, GenericArchive ar)"""
|
|
return _datamodel.DataloggerCalibration_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.DataloggerCalibration_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(DataloggerCalibration self) -> MetaObject"""
|
|
return _datamodel.DataloggerCalibration_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(DataloggerCalibration self) -> DataloggerCalibration
|
|
__init__(DataloggerCalibration self, DataloggerCalibration other) -> DataloggerCalibration
|
|
"""
|
|
_datamodel.DataloggerCalibration_swiginit(self, _datamodel.new_DataloggerCalibration(*args))
|
|
__swig_destroy__ = _datamodel.delete_DataloggerCalibration
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(DataloggerCalibration self, DataloggerCalibration other) -> bool"""
|
|
return _datamodel.DataloggerCalibration___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(DataloggerCalibration self, DataloggerCalibration other) -> bool"""
|
|
return _datamodel.DataloggerCalibration___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(DataloggerCalibration self, DataloggerCalibration other) -> bool"""
|
|
return _datamodel.DataloggerCalibration_equal(self, other)
|
|
|
|
def setSerialNumber(self, serialNumber):
|
|
r"""setSerialNumber(DataloggerCalibration self, std::string const & serialNumber)"""
|
|
return _datamodel.DataloggerCalibration_setSerialNumber(self, serialNumber)
|
|
|
|
def serialNumber(self):
|
|
r"""serialNumber(DataloggerCalibration self) -> std::string const &"""
|
|
return _datamodel.DataloggerCalibration_serialNumber(self)
|
|
|
|
def setChannel(self, channel):
|
|
r"""setChannel(DataloggerCalibration self, int channel)"""
|
|
return _datamodel.DataloggerCalibration_setChannel(self, channel)
|
|
|
|
def channel(self):
|
|
r"""channel(DataloggerCalibration self) -> int"""
|
|
return _datamodel.DataloggerCalibration_channel(self)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(DataloggerCalibration self, Time start)"""
|
|
return _datamodel.DataloggerCalibration_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(DataloggerCalibration self) -> Time"""
|
|
return _datamodel.DataloggerCalibration_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(DataloggerCalibration self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
|
|
return _datamodel.DataloggerCalibration_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(DataloggerCalibration self) -> Time"""
|
|
return _datamodel.DataloggerCalibration_end(self)
|
|
|
|
def setGain(self, gain):
|
|
r"""setGain(DataloggerCalibration self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
|
|
return _datamodel.DataloggerCalibration_setGain(self, gain)
|
|
|
|
def gain(self):
|
|
r"""gain(DataloggerCalibration self) -> double"""
|
|
return _datamodel.DataloggerCalibration_gain(self)
|
|
|
|
def setGainFrequency(self, gainFrequency):
|
|
r"""setGainFrequency(DataloggerCalibration self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
|
|
return _datamodel.DataloggerCalibration_setGainFrequency(self, gainFrequency)
|
|
|
|
def gainFrequency(self):
|
|
r"""gainFrequency(DataloggerCalibration self) -> double"""
|
|
return _datamodel.DataloggerCalibration_gainFrequency(self)
|
|
|
|
def setRemark(self, remark):
|
|
r"""setRemark(DataloggerCalibration self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
|
|
return _datamodel.DataloggerCalibration_setRemark(self, remark)
|
|
|
|
def remark(self, *args):
|
|
r"""
|
|
remark(DataloggerCalibration self) -> Blob
|
|
remark(DataloggerCalibration self) -> Blob
|
|
"""
|
|
return _datamodel.DataloggerCalibration_remark(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(DataloggerCalibration self) -> DataloggerCalibrationIndex"""
|
|
return _datamodel.DataloggerCalibration_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(DataloggerCalibration self, DataloggerCalibration lhs) -> bool"""
|
|
return _datamodel.DataloggerCalibration_equalIndex(self, lhs)
|
|
|
|
def datalogger(self):
|
|
r"""datalogger(DataloggerCalibration self) -> Datalogger"""
|
|
return _datamodel.DataloggerCalibration_datalogger(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(DataloggerCalibration self, Object other) -> bool"""
|
|
return _datamodel.DataloggerCalibration_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(DataloggerCalibration self, PublicObject parent) -> bool"""
|
|
return _datamodel.DataloggerCalibration_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(DataloggerCalibration self, PublicObject parent) -> bool"""
|
|
return _datamodel.DataloggerCalibration_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(DataloggerCalibration self) -> bool"""
|
|
return _datamodel.DataloggerCalibration_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(DataloggerCalibration self) -> Object"""
|
|
return _datamodel.DataloggerCalibration_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(DataloggerCalibration self, Visitor visitor)"""
|
|
return _datamodel.DataloggerCalibration_accept(self, visitor)
|
|
|
|
# Register DataloggerCalibration in _datamodel:
|
|
_datamodel.DataloggerCalibration_swigregister(DataloggerCalibration)
|
|
|
|
def DataloggerCalibration_ClassName():
|
|
r"""DataloggerCalibration_ClassName() -> char const *"""
|
|
return _datamodel.DataloggerCalibration_ClassName()
|
|
|
|
def DataloggerCalibration_TypeInfo():
|
|
r"""DataloggerCalibration_TypeInfo() -> RTTI"""
|
|
return _datamodel.DataloggerCalibration_TypeInfo()
|
|
|
|
def DataloggerCalibration_Cast(*args):
|
|
r"""
|
|
DataloggerCalibration_Cast(BaseObject o) -> DataloggerCalibration
|
|
DataloggerCalibration_Cast(Seiscomp::Core::BaseObjectPtr o) -> DataloggerCalibration
|
|
"""
|
|
return _datamodel.DataloggerCalibration_Cast(*args)
|
|
|
|
def DataloggerCalibration_ConstCast(*args):
|
|
r"""
|
|
DataloggerCalibration_ConstCast(BaseObject o) -> DataloggerCalibration
|
|
DataloggerCalibration_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataloggerCalibration
|
|
"""
|
|
return _datamodel.DataloggerCalibration_ConstCast(*args)
|
|
|
|
def DataloggerCalibration_Meta():
|
|
r"""DataloggerCalibration_Meta() -> MetaObject"""
|
|
return _datamodel.DataloggerCalibration_Meta()
|
|
|
|
class DecimationIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DecimationIndex 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__(DecimationIndex self) -> DecimationIndex
|
|
__init__(DecimationIndex self, int sampleRateNumerator, int sampleRateDenominator) -> DecimationIndex
|
|
__init__(DecimationIndex self, DecimationIndex arg2) -> DecimationIndex
|
|
"""
|
|
_datamodel.DecimationIndex_swiginit(self, _datamodel.new_DecimationIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(DecimationIndex self, DecimationIndex arg2) -> bool"""
|
|
return _datamodel.DecimationIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(DecimationIndex self, DecimationIndex arg2) -> bool"""
|
|
return _datamodel.DecimationIndex___ne__(self, arg2)
|
|
sampleRateNumerator = property(_datamodel.DecimationIndex_sampleRateNumerator_get, _datamodel.DecimationIndex_sampleRateNumerator_set, doc=r"""sampleRateNumerator : int""")
|
|
sampleRateDenominator = property(_datamodel.DecimationIndex_sampleRateDenominator_get, _datamodel.DecimationIndex_sampleRateDenominator_set, doc=r"""sampleRateDenominator : int""")
|
|
__swig_destroy__ = _datamodel.delete_DecimationIndex
|
|
|
|
# Register DecimationIndex in _datamodel:
|
|
_datamodel.DecimationIndex_swigregister(DecimationIndex)
|
|
|
|
class Decimation(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Decimation 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 _datamodel.Decimation_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Decimation_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Decimation self) -> char const *"""
|
|
return _datamodel.Decimation_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Decimation self) -> RTTI"""
|
|
return _datamodel.Decimation_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Decimation
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Decimation
|
|
"""
|
|
return _datamodel.Decimation_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Decimation
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Decimation
|
|
"""
|
|
return _datamodel.Decimation_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Decimation self, GenericArchive ar)"""
|
|
return _datamodel.Decimation_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Decimation_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Decimation self) -> MetaObject"""
|
|
return _datamodel.Decimation_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Decimation self) -> Decimation
|
|
__init__(Decimation self, Decimation other) -> Decimation
|
|
"""
|
|
_datamodel.Decimation_swiginit(self, _datamodel.new_Decimation(*args))
|
|
__swig_destroy__ = _datamodel.delete_Decimation
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Decimation self, Decimation other) -> bool"""
|
|
return _datamodel.Decimation___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Decimation self, Decimation other) -> bool"""
|
|
return _datamodel.Decimation___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Decimation self, Decimation other) -> bool"""
|
|
return _datamodel.Decimation_equal(self, other)
|
|
|
|
def setSampleRateNumerator(self, sampleRateNumerator):
|
|
r"""setSampleRateNumerator(Decimation self, int sampleRateNumerator)"""
|
|
return _datamodel.Decimation_setSampleRateNumerator(self, sampleRateNumerator)
|
|
|
|
def sampleRateNumerator(self):
|
|
r"""sampleRateNumerator(Decimation self) -> int"""
|
|
return _datamodel.Decimation_sampleRateNumerator(self)
|
|
|
|
def setSampleRateDenominator(self, sampleRateDenominator):
|
|
r"""setSampleRateDenominator(Decimation self, int sampleRateDenominator)"""
|
|
return _datamodel.Decimation_setSampleRateDenominator(self, sampleRateDenominator)
|
|
|
|
def sampleRateDenominator(self):
|
|
r"""sampleRateDenominator(Decimation self) -> int"""
|
|
return _datamodel.Decimation_sampleRateDenominator(self)
|
|
|
|
def setAnalogueFilterChain(self, analogueFilterChain):
|
|
r"""setAnalogueFilterChain(Decimation self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & analogueFilterChain)"""
|
|
return _datamodel.Decimation_setAnalogueFilterChain(self, analogueFilterChain)
|
|
|
|
def analogueFilterChain(self, *args):
|
|
r"""
|
|
analogueFilterChain(Decimation self) -> Blob
|
|
analogueFilterChain(Decimation self) -> Blob
|
|
"""
|
|
return _datamodel.Decimation_analogueFilterChain(self, *args)
|
|
|
|
def setDigitalFilterChain(self, digitalFilterChain):
|
|
r"""setDigitalFilterChain(Decimation self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & digitalFilterChain)"""
|
|
return _datamodel.Decimation_setDigitalFilterChain(self, digitalFilterChain)
|
|
|
|
def digitalFilterChain(self, *args):
|
|
r"""
|
|
digitalFilterChain(Decimation self) -> Blob
|
|
digitalFilterChain(Decimation self) -> Blob
|
|
"""
|
|
return _datamodel.Decimation_digitalFilterChain(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(Decimation self) -> DecimationIndex"""
|
|
return _datamodel.Decimation_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(Decimation self, Decimation lhs) -> bool"""
|
|
return _datamodel.Decimation_equalIndex(self, lhs)
|
|
|
|
def datalogger(self):
|
|
r"""datalogger(Decimation self) -> Datalogger"""
|
|
return _datamodel.Decimation_datalogger(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Decimation self, Object other) -> bool"""
|
|
return _datamodel.Decimation_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Decimation self, PublicObject parent) -> bool"""
|
|
return _datamodel.Decimation_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Decimation self, PublicObject parent) -> bool"""
|
|
return _datamodel.Decimation_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Decimation self) -> bool"""
|
|
return _datamodel.Decimation_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Decimation self) -> Object"""
|
|
return _datamodel.Decimation_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Decimation self, Visitor visitor)"""
|
|
return _datamodel.Decimation_accept(self, visitor)
|
|
|
|
# Register Decimation in _datamodel:
|
|
_datamodel.Decimation_swigregister(Decimation)
|
|
|
|
def Decimation_ClassName():
|
|
r"""Decimation_ClassName() -> char const *"""
|
|
return _datamodel.Decimation_ClassName()
|
|
|
|
def Decimation_TypeInfo():
|
|
r"""Decimation_TypeInfo() -> RTTI"""
|
|
return _datamodel.Decimation_TypeInfo()
|
|
|
|
def Decimation_Cast(*args):
|
|
r"""
|
|
Decimation_Cast(BaseObject o) -> Decimation
|
|
Decimation_Cast(Seiscomp::Core::BaseObjectPtr o) -> Decimation
|
|
"""
|
|
return _datamodel.Decimation_Cast(*args)
|
|
|
|
def Decimation_ConstCast(*args):
|
|
r"""
|
|
Decimation_ConstCast(BaseObject o) -> Decimation
|
|
Decimation_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Decimation
|
|
"""
|
|
return _datamodel.Decimation_ConstCast(*args)
|
|
|
|
def Decimation_Meta():
|
|
r"""Decimation_Meta() -> MetaObject"""
|
|
return _datamodel.Decimation_Meta()
|
|
|
|
class DataloggerIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DataloggerIndex 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__(DataloggerIndex self) -> DataloggerIndex
|
|
__init__(DataloggerIndex self, std::string const & name) -> DataloggerIndex
|
|
__init__(DataloggerIndex self, DataloggerIndex arg2) -> DataloggerIndex
|
|
"""
|
|
_datamodel.DataloggerIndex_swiginit(self, _datamodel.new_DataloggerIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(DataloggerIndex self, DataloggerIndex arg2) -> bool"""
|
|
return _datamodel.DataloggerIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(DataloggerIndex self, DataloggerIndex arg2) -> bool"""
|
|
return _datamodel.DataloggerIndex___ne__(self, arg2)
|
|
name = property(_datamodel.DataloggerIndex_name_get, _datamodel.DataloggerIndex_name_set, doc=r"""name : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_DataloggerIndex
|
|
|
|
# Register DataloggerIndex in _datamodel:
|
|
_datamodel.DataloggerIndex_swigregister(DataloggerIndex)
|
|
|
|
class Datalogger(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Datalogger 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 _datamodel.Datalogger_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Datalogger_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Datalogger self) -> char const *"""
|
|
return _datamodel.Datalogger_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Datalogger self) -> RTTI"""
|
|
return _datamodel.Datalogger_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Datalogger
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Datalogger
|
|
"""
|
|
return _datamodel.Datalogger_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Datalogger
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Datalogger
|
|
"""
|
|
return _datamodel.Datalogger_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Datalogger self, GenericArchive ar)"""
|
|
return _datamodel.Datalogger_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Datalogger_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Datalogger self) -> MetaObject"""
|
|
return _datamodel.Datalogger_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Datalogger self, Datalogger other) -> Datalogger
|
|
__init__(Datalogger self, std::string const & publicID) -> Datalogger
|
|
"""
|
|
_datamodel.Datalogger_swiginit(self, _datamodel.new_Datalogger(*args))
|
|
__swig_destroy__ = _datamodel.delete_Datalogger
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> Datalogger
|
|
Create(std::string const & publicID) -> Datalogger
|
|
"""
|
|
return _datamodel.Datalogger_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> Datalogger"""
|
|
return _datamodel.Datalogger_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Datalogger self, Datalogger other) -> bool"""
|
|
return _datamodel.Datalogger___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Datalogger self, Datalogger other) -> bool"""
|
|
return _datamodel.Datalogger___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Datalogger self, Datalogger other) -> bool"""
|
|
return _datamodel.Datalogger_equal(self, other)
|
|
|
|
def setName(self, name):
|
|
r"""setName(Datalogger self, std::string const & name)"""
|
|
return _datamodel.Datalogger_setName(self, name)
|
|
|
|
def name(self):
|
|
r"""name(Datalogger self) -> std::string const &"""
|
|
return _datamodel.Datalogger_name(self)
|
|
|
|
def setDescription(self, description):
|
|
r"""setDescription(Datalogger self, std::string const & description)"""
|
|
return _datamodel.Datalogger_setDescription(self, description)
|
|
|
|
def description(self):
|
|
r"""description(Datalogger self) -> std::string const &"""
|
|
return _datamodel.Datalogger_description(self)
|
|
|
|
def setDigitizerModel(self, digitizerModel):
|
|
r"""setDigitizerModel(Datalogger self, std::string const & digitizerModel)"""
|
|
return _datamodel.Datalogger_setDigitizerModel(self, digitizerModel)
|
|
|
|
def digitizerModel(self):
|
|
r"""digitizerModel(Datalogger self) -> std::string const &"""
|
|
return _datamodel.Datalogger_digitizerModel(self)
|
|
|
|
def setDigitizerManufacturer(self, digitizerManufacturer):
|
|
r"""setDigitizerManufacturer(Datalogger self, std::string const & digitizerManufacturer)"""
|
|
return _datamodel.Datalogger_setDigitizerManufacturer(self, digitizerManufacturer)
|
|
|
|
def digitizerManufacturer(self):
|
|
r"""digitizerManufacturer(Datalogger self) -> std::string const &"""
|
|
return _datamodel.Datalogger_digitizerManufacturer(self)
|
|
|
|
def setRecorderModel(self, recorderModel):
|
|
r"""setRecorderModel(Datalogger self, std::string const & recorderModel)"""
|
|
return _datamodel.Datalogger_setRecorderModel(self, recorderModel)
|
|
|
|
def recorderModel(self):
|
|
r"""recorderModel(Datalogger self) -> std::string const &"""
|
|
return _datamodel.Datalogger_recorderModel(self)
|
|
|
|
def setRecorderManufacturer(self, recorderManufacturer):
|
|
r"""setRecorderManufacturer(Datalogger self, std::string const & recorderManufacturer)"""
|
|
return _datamodel.Datalogger_setRecorderManufacturer(self, recorderManufacturer)
|
|
|
|
def recorderManufacturer(self):
|
|
r"""recorderManufacturer(Datalogger self) -> std::string const &"""
|
|
return _datamodel.Datalogger_recorderManufacturer(self)
|
|
|
|
def setClockModel(self, clockModel):
|
|
r"""setClockModel(Datalogger self, std::string const & clockModel)"""
|
|
return _datamodel.Datalogger_setClockModel(self, clockModel)
|
|
|
|
def clockModel(self):
|
|
r"""clockModel(Datalogger self) -> std::string const &"""
|
|
return _datamodel.Datalogger_clockModel(self)
|
|
|
|
def setClockManufacturer(self, clockManufacturer):
|
|
r"""setClockManufacturer(Datalogger self, std::string const & clockManufacturer)"""
|
|
return _datamodel.Datalogger_setClockManufacturer(self, clockManufacturer)
|
|
|
|
def clockManufacturer(self):
|
|
r"""clockManufacturer(Datalogger self) -> std::string const &"""
|
|
return _datamodel.Datalogger_clockManufacturer(self)
|
|
|
|
def setClockType(self, clockType):
|
|
r"""setClockType(Datalogger self, std::string const & clockType)"""
|
|
return _datamodel.Datalogger_setClockType(self, clockType)
|
|
|
|
def clockType(self):
|
|
r"""clockType(Datalogger self) -> std::string const &"""
|
|
return _datamodel.Datalogger_clockType(self)
|
|
|
|
def setGain(self, gain):
|
|
r"""setGain(Datalogger self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
|
|
return _datamodel.Datalogger_setGain(self, gain)
|
|
|
|
def gain(self):
|
|
r"""gain(Datalogger self) -> double"""
|
|
return _datamodel.Datalogger_gain(self)
|
|
|
|
def setMaxClockDrift(self, maxClockDrift):
|
|
r"""setMaxClockDrift(Datalogger self, Seiscomp::Core::Optional< double >::Impl const & maxClockDrift)"""
|
|
return _datamodel.Datalogger_setMaxClockDrift(self, maxClockDrift)
|
|
|
|
def maxClockDrift(self):
|
|
r"""maxClockDrift(Datalogger self) -> double"""
|
|
return _datamodel.Datalogger_maxClockDrift(self)
|
|
|
|
def setRemark(self, remark):
|
|
r"""setRemark(Datalogger self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
|
|
return _datamodel.Datalogger_setRemark(self, remark)
|
|
|
|
def remark(self, *args):
|
|
r"""
|
|
remark(Datalogger self) -> Blob
|
|
remark(Datalogger self) -> Blob
|
|
"""
|
|
return _datamodel.Datalogger_remark(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(Datalogger self) -> DataloggerIndex"""
|
|
return _datamodel.Datalogger_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(Datalogger self, Datalogger lhs) -> bool"""
|
|
return _datamodel.Datalogger_equalIndex(self, lhs)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(Datalogger self, DataloggerCalibration obj) -> bool
|
|
add(Datalogger self, Decimation obj) -> bool
|
|
"""
|
|
return _datamodel.Datalogger_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(Datalogger self, DataloggerCalibration obj) -> bool
|
|
remove(Datalogger self, Decimation obj) -> bool
|
|
"""
|
|
return _datamodel.Datalogger_remove(self, *args)
|
|
|
|
def removeDataloggerCalibration(self, *args):
|
|
r"""
|
|
removeDataloggerCalibration(Datalogger self, size_t i) -> bool
|
|
removeDataloggerCalibration(Datalogger self, DataloggerCalibrationIndex i) -> bool
|
|
"""
|
|
return _datamodel.Datalogger_removeDataloggerCalibration(self, *args)
|
|
|
|
def removeDecimation(self, *args):
|
|
r"""
|
|
removeDecimation(Datalogger self, size_t i) -> bool
|
|
removeDecimation(Datalogger self, DecimationIndex i) -> bool
|
|
"""
|
|
return _datamodel.Datalogger_removeDecimation(self, *args)
|
|
|
|
def dataloggerCalibrationCount(self):
|
|
r"""dataloggerCalibrationCount(Datalogger self) -> size_t"""
|
|
return _datamodel.Datalogger_dataloggerCalibrationCount(self)
|
|
|
|
def decimationCount(self):
|
|
r"""decimationCount(Datalogger self) -> size_t"""
|
|
return _datamodel.Datalogger_decimationCount(self)
|
|
|
|
def dataloggerCalibration(self, *args):
|
|
r"""
|
|
dataloggerCalibration(Datalogger self, size_t i) -> DataloggerCalibration
|
|
dataloggerCalibration(Datalogger self, DataloggerCalibrationIndex i) -> DataloggerCalibration
|
|
"""
|
|
return _datamodel.Datalogger_dataloggerCalibration(self, *args)
|
|
|
|
def decimation(self, *args):
|
|
r"""
|
|
decimation(Datalogger self, size_t i) -> Decimation
|
|
decimation(Datalogger self, DecimationIndex i) -> Decimation
|
|
"""
|
|
return _datamodel.Datalogger_decimation(self, *args)
|
|
|
|
def inventory(self):
|
|
r"""inventory(Datalogger self) -> Inventory"""
|
|
return _datamodel.Datalogger_inventory(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Datalogger self, Object other) -> bool"""
|
|
return _datamodel.Datalogger_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Datalogger self, PublicObject parent) -> bool"""
|
|
return _datamodel.Datalogger_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Datalogger self, PublicObject parent) -> bool"""
|
|
return _datamodel.Datalogger_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Datalogger self) -> bool"""
|
|
return _datamodel.Datalogger_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Datalogger self) -> Object"""
|
|
return _datamodel.Datalogger_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Datalogger self, Object child) -> bool"""
|
|
return _datamodel.Datalogger_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Datalogger self, Visitor visitor)"""
|
|
return _datamodel.Datalogger_accept(self, visitor)
|
|
|
|
# Register Datalogger in _datamodel:
|
|
_datamodel.Datalogger_swigregister(Datalogger)
|
|
|
|
def Datalogger_ClassName():
|
|
r"""Datalogger_ClassName() -> char const *"""
|
|
return _datamodel.Datalogger_ClassName()
|
|
|
|
def Datalogger_TypeInfo():
|
|
r"""Datalogger_TypeInfo() -> RTTI"""
|
|
return _datamodel.Datalogger_TypeInfo()
|
|
|
|
def Datalogger_Cast(*args):
|
|
r"""
|
|
Datalogger_Cast(BaseObject o) -> Datalogger
|
|
Datalogger_Cast(Seiscomp::Core::BaseObjectPtr o) -> Datalogger
|
|
"""
|
|
return _datamodel.Datalogger_Cast(*args)
|
|
|
|
def Datalogger_ConstCast(*args):
|
|
r"""
|
|
Datalogger_ConstCast(BaseObject o) -> Datalogger
|
|
Datalogger_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Datalogger
|
|
"""
|
|
return _datamodel.Datalogger_ConstCast(*args)
|
|
|
|
def Datalogger_Meta():
|
|
r"""Datalogger_Meta() -> MetaObject"""
|
|
return _datamodel.Datalogger_Meta()
|
|
|
|
def Datalogger_Create(*args):
|
|
r"""
|
|
Datalogger_Create() -> Datalogger
|
|
Datalogger_Create(std::string const & publicID) -> Datalogger
|
|
"""
|
|
return _datamodel.Datalogger_Create(*args)
|
|
|
|
def Datalogger_Find(publicID):
|
|
r"""Datalogger_Find(std::string const & publicID) -> Datalogger"""
|
|
return _datamodel.Datalogger_Find(publicID)
|
|
|
|
class AuxStreamIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::AuxStreamIndex 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__(AuxStreamIndex self) -> AuxStreamIndex
|
|
__init__(AuxStreamIndex self, std::string const & code, Time start) -> AuxStreamIndex
|
|
__init__(AuxStreamIndex self, AuxStreamIndex arg2) -> AuxStreamIndex
|
|
"""
|
|
_datamodel.AuxStreamIndex_swiginit(self, _datamodel.new_AuxStreamIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(AuxStreamIndex self, AuxStreamIndex arg2) -> bool"""
|
|
return _datamodel.AuxStreamIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(AuxStreamIndex self, AuxStreamIndex arg2) -> bool"""
|
|
return _datamodel.AuxStreamIndex___ne__(self, arg2)
|
|
code = property(_datamodel.AuxStreamIndex_code_get, _datamodel.AuxStreamIndex_code_set, doc=r"""code : std::string""")
|
|
start = property(_datamodel.AuxStreamIndex_start_get, _datamodel.AuxStreamIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
|
|
__swig_destroy__ = _datamodel.delete_AuxStreamIndex
|
|
|
|
# Register AuxStreamIndex in _datamodel:
|
|
_datamodel.AuxStreamIndex_swigregister(AuxStreamIndex)
|
|
|
|
class AuxStream(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::AuxStream 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 _datamodel.AuxStream_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.AuxStream_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(AuxStream self) -> char const *"""
|
|
return _datamodel.AuxStream_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(AuxStream self) -> RTTI"""
|
|
return _datamodel.AuxStream_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> AuxStream
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> AuxStream
|
|
"""
|
|
return _datamodel.AuxStream_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> AuxStream
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AuxStream
|
|
"""
|
|
return _datamodel.AuxStream_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(AuxStream self, GenericArchive ar)"""
|
|
return _datamodel.AuxStream_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.AuxStream_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(AuxStream self) -> MetaObject"""
|
|
return _datamodel.AuxStream_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(AuxStream self) -> AuxStream
|
|
__init__(AuxStream self, AuxStream other) -> AuxStream
|
|
"""
|
|
_datamodel.AuxStream_swiginit(self, _datamodel.new_AuxStream(*args))
|
|
__swig_destroy__ = _datamodel.delete_AuxStream
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(AuxStream self, AuxStream other) -> bool"""
|
|
return _datamodel.AuxStream___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(AuxStream self, AuxStream other) -> bool"""
|
|
return _datamodel.AuxStream___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(AuxStream self, AuxStream other) -> bool"""
|
|
return _datamodel.AuxStream_equal(self, other)
|
|
|
|
def setCode(self, code):
|
|
r"""setCode(AuxStream self, std::string const & code)"""
|
|
return _datamodel.AuxStream_setCode(self, code)
|
|
|
|
def code(self):
|
|
r"""code(AuxStream self) -> std::string const &"""
|
|
return _datamodel.AuxStream_code(self)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(AuxStream self, Time start)"""
|
|
return _datamodel.AuxStream_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(AuxStream self) -> Time"""
|
|
return _datamodel.AuxStream_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(AuxStream self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
|
|
return _datamodel.AuxStream_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(AuxStream self) -> Time"""
|
|
return _datamodel.AuxStream_end(self)
|
|
|
|
def setDevice(self, device):
|
|
r"""setDevice(AuxStream self, std::string const & device)"""
|
|
return _datamodel.AuxStream_setDevice(self, device)
|
|
|
|
def device(self):
|
|
r"""device(AuxStream self) -> std::string const &"""
|
|
return _datamodel.AuxStream_device(self)
|
|
|
|
def setDeviceSerialNumber(self, deviceSerialNumber):
|
|
r"""setDeviceSerialNumber(AuxStream self, std::string const & deviceSerialNumber)"""
|
|
return _datamodel.AuxStream_setDeviceSerialNumber(self, deviceSerialNumber)
|
|
|
|
def deviceSerialNumber(self):
|
|
r"""deviceSerialNumber(AuxStream self) -> std::string const &"""
|
|
return _datamodel.AuxStream_deviceSerialNumber(self)
|
|
|
|
def setSource(self, source):
|
|
r"""setSource(AuxStream self, std::string const & source)"""
|
|
return _datamodel.AuxStream_setSource(self, source)
|
|
|
|
def source(self):
|
|
r"""source(AuxStream self) -> std::string const &"""
|
|
return _datamodel.AuxStream_source(self)
|
|
|
|
def setFormat(self, format):
|
|
r"""setFormat(AuxStream self, std::string const & format)"""
|
|
return _datamodel.AuxStream_setFormat(self, format)
|
|
|
|
def format(self):
|
|
r"""format(AuxStream self) -> std::string const &"""
|
|
return _datamodel.AuxStream_format(self)
|
|
|
|
def setFlags(self, flags):
|
|
r"""setFlags(AuxStream self, std::string const & flags)"""
|
|
return _datamodel.AuxStream_setFlags(self, flags)
|
|
|
|
def flags(self):
|
|
r"""flags(AuxStream self) -> std::string const &"""
|
|
return _datamodel.AuxStream_flags(self)
|
|
|
|
def setRestricted(self, restricted):
|
|
r"""setRestricted(AuxStream self, Seiscomp::Core::Optional< bool >::Impl const & restricted)"""
|
|
return _datamodel.AuxStream_setRestricted(self, restricted)
|
|
|
|
def restricted(self):
|
|
r"""restricted(AuxStream self) -> bool"""
|
|
return _datamodel.AuxStream_restricted(self)
|
|
|
|
def setShared(self, shared):
|
|
r"""setShared(AuxStream self, Seiscomp::Core::Optional< bool >::Impl const & shared)"""
|
|
return _datamodel.AuxStream_setShared(self, shared)
|
|
|
|
def shared(self):
|
|
r"""shared(AuxStream self) -> bool"""
|
|
return _datamodel.AuxStream_shared(self)
|
|
|
|
def index(self):
|
|
r"""index(AuxStream self) -> AuxStreamIndex"""
|
|
return _datamodel.AuxStream_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(AuxStream self, AuxStream lhs) -> bool"""
|
|
return _datamodel.AuxStream_equalIndex(self, lhs)
|
|
|
|
def sensorLocation(self):
|
|
r"""sensorLocation(AuxStream self) -> SensorLocation"""
|
|
return _datamodel.AuxStream_sensorLocation(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(AuxStream self, Object other) -> bool"""
|
|
return _datamodel.AuxStream_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(AuxStream self, PublicObject parent) -> bool"""
|
|
return _datamodel.AuxStream_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(AuxStream self, PublicObject parent) -> bool"""
|
|
return _datamodel.AuxStream_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(AuxStream self) -> bool"""
|
|
return _datamodel.AuxStream_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(AuxStream self) -> Object"""
|
|
return _datamodel.AuxStream_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(AuxStream self, Visitor visitor)"""
|
|
return _datamodel.AuxStream_accept(self, visitor)
|
|
|
|
# Register AuxStream in _datamodel:
|
|
_datamodel.AuxStream_swigregister(AuxStream)
|
|
|
|
def AuxStream_ClassName():
|
|
r"""AuxStream_ClassName() -> char const *"""
|
|
return _datamodel.AuxStream_ClassName()
|
|
|
|
def AuxStream_TypeInfo():
|
|
r"""AuxStream_TypeInfo() -> RTTI"""
|
|
return _datamodel.AuxStream_TypeInfo()
|
|
|
|
def AuxStream_Cast(*args):
|
|
r"""
|
|
AuxStream_Cast(BaseObject o) -> AuxStream
|
|
AuxStream_Cast(Seiscomp::Core::BaseObjectPtr o) -> AuxStream
|
|
"""
|
|
return _datamodel.AuxStream_Cast(*args)
|
|
|
|
def AuxStream_ConstCast(*args):
|
|
r"""
|
|
AuxStream_ConstCast(BaseObject o) -> AuxStream
|
|
AuxStream_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> AuxStream
|
|
"""
|
|
return _datamodel.AuxStream_ConstCast(*args)
|
|
|
|
def AuxStream_Meta():
|
|
r"""AuxStream_Meta() -> MetaObject"""
|
|
return _datamodel.AuxStream_Meta()
|
|
|
|
class StreamIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::StreamIndex 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__(StreamIndex self) -> StreamIndex
|
|
__init__(StreamIndex self, std::string const & code, Time start) -> StreamIndex
|
|
__init__(StreamIndex self, StreamIndex arg2) -> StreamIndex
|
|
"""
|
|
_datamodel.StreamIndex_swiginit(self, _datamodel.new_StreamIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(StreamIndex self, StreamIndex arg2) -> bool"""
|
|
return _datamodel.StreamIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(StreamIndex self, StreamIndex arg2) -> bool"""
|
|
return _datamodel.StreamIndex___ne__(self, arg2)
|
|
code = property(_datamodel.StreamIndex_code_get, _datamodel.StreamIndex_code_set, doc=r"""code : std::string""")
|
|
start = property(_datamodel.StreamIndex_start_get, _datamodel.StreamIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
|
|
__swig_destroy__ = _datamodel.delete_StreamIndex
|
|
|
|
# Register StreamIndex in _datamodel:
|
|
_datamodel.StreamIndex_swigregister(StreamIndex)
|
|
|
|
class Stream(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Stream 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 _datamodel.Stream_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Stream_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Stream self) -> char const *"""
|
|
return _datamodel.Stream_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Stream self) -> RTTI"""
|
|
return _datamodel.Stream_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Stream
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Stream
|
|
"""
|
|
return _datamodel.Stream_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Stream
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Stream
|
|
"""
|
|
return _datamodel.Stream_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Stream self, GenericArchive ar)"""
|
|
return _datamodel.Stream_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Stream_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Stream self) -> MetaObject"""
|
|
return _datamodel.Stream_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Stream self, Stream other) -> Stream
|
|
__init__(Stream self, std::string const & publicID) -> Stream
|
|
"""
|
|
_datamodel.Stream_swiginit(self, _datamodel.new_Stream(*args))
|
|
__swig_destroy__ = _datamodel.delete_Stream
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> Stream
|
|
Create(std::string const & publicID) -> Stream
|
|
"""
|
|
return _datamodel.Stream_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> Stream"""
|
|
return _datamodel.Stream_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Stream self, Stream other) -> bool"""
|
|
return _datamodel.Stream___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Stream self, Stream other) -> bool"""
|
|
return _datamodel.Stream___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Stream self, Stream other) -> bool"""
|
|
return _datamodel.Stream_equal(self, other)
|
|
|
|
def setCode(self, code):
|
|
r"""setCode(Stream self, std::string const & code)"""
|
|
return _datamodel.Stream_setCode(self, code)
|
|
|
|
def code(self):
|
|
r"""code(Stream self) -> std::string const &"""
|
|
return _datamodel.Stream_code(self)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(Stream self, Time start)"""
|
|
return _datamodel.Stream_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(Stream self) -> Time"""
|
|
return _datamodel.Stream_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(Stream self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
|
|
return _datamodel.Stream_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(Stream self) -> Time"""
|
|
return _datamodel.Stream_end(self)
|
|
|
|
def setDatalogger(self, datalogger):
|
|
r"""setDatalogger(Stream self, std::string const & datalogger)"""
|
|
return _datamodel.Stream_setDatalogger(self, datalogger)
|
|
|
|
def datalogger(self):
|
|
r"""datalogger(Stream self) -> std::string const &"""
|
|
return _datamodel.Stream_datalogger(self)
|
|
|
|
def setDataloggerSerialNumber(self, dataloggerSerialNumber):
|
|
r"""setDataloggerSerialNumber(Stream self, std::string const & dataloggerSerialNumber)"""
|
|
return _datamodel.Stream_setDataloggerSerialNumber(self, dataloggerSerialNumber)
|
|
|
|
def dataloggerSerialNumber(self):
|
|
r"""dataloggerSerialNumber(Stream self) -> std::string const &"""
|
|
return _datamodel.Stream_dataloggerSerialNumber(self)
|
|
|
|
def setDataloggerChannel(self, dataloggerChannel):
|
|
r"""setDataloggerChannel(Stream self, Seiscomp::Core::Optional< int >::Impl const & dataloggerChannel)"""
|
|
return _datamodel.Stream_setDataloggerChannel(self, dataloggerChannel)
|
|
|
|
def dataloggerChannel(self):
|
|
r"""dataloggerChannel(Stream self) -> int"""
|
|
return _datamodel.Stream_dataloggerChannel(self)
|
|
|
|
def setSensor(self, sensor):
|
|
r"""setSensor(Stream self, std::string const & sensor)"""
|
|
return _datamodel.Stream_setSensor(self, sensor)
|
|
|
|
def sensor(self):
|
|
r"""sensor(Stream self) -> std::string const &"""
|
|
return _datamodel.Stream_sensor(self)
|
|
|
|
def setSensorSerialNumber(self, sensorSerialNumber):
|
|
r"""setSensorSerialNumber(Stream self, std::string const & sensorSerialNumber)"""
|
|
return _datamodel.Stream_setSensorSerialNumber(self, sensorSerialNumber)
|
|
|
|
def sensorSerialNumber(self):
|
|
r"""sensorSerialNumber(Stream self) -> std::string const &"""
|
|
return _datamodel.Stream_sensorSerialNumber(self)
|
|
|
|
def setSensorChannel(self, sensorChannel):
|
|
r"""setSensorChannel(Stream self, Seiscomp::Core::Optional< int >::Impl const & sensorChannel)"""
|
|
return _datamodel.Stream_setSensorChannel(self, sensorChannel)
|
|
|
|
def sensorChannel(self):
|
|
r"""sensorChannel(Stream self) -> int"""
|
|
return _datamodel.Stream_sensorChannel(self)
|
|
|
|
def setClockSerialNumber(self, clockSerialNumber):
|
|
r"""setClockSerialNumber(Stream self, std::string const & clockSerialNumber)"""
|
|
return _datamodel.Stream_setClockSerialNumber(self, clockSerialNumber)
|
|
|
|
def clockSerialNumber(self):
|
|
r"""clockSerialNumber(Stream self) -> std::string const &"""
|
|
return _datamodel.Stream_clockSerialNumber(self)
|
|
|
|
def setSampleRateNumerator(self, sampleRateNumerator):
|
|
r"""setSampleRateNumerator(Stream self, Seiscomp::Core::Optional< int >::Impl const & sampleRateNumerator)"""
|
|
return _datamodel.Stream_setSampleRateNumerator(self, sampleRateNumerator)
|
|
|
|
def sampleRateNumerator(self):
|
|
r"""sampleRateNumerator(Stream self) -> int"""
|
|
return _datamodel.Stream_sampleRateNumerator(self)
|
|
|
|
def setSampleRateDenominator(self, sampleRateDenominator):
|
|
r"""setSampleRateDenominator(Stream self, Seiscomp::Core::Optional< int >::Impl const & sampleRateDenominator)"""
|
|
return _datamodel.Stream_setSampleRateDenominator(self, sampleRateDenominator)
|
|
|
|
def sampleRateDenominator(self):
|
|
r"""sampleRateDenominator(Stream self) -> int"""
|
|
return _datamodel.Stream_sampleRateDenominator(self)
|
|
|
|
def setDepth(self, depth):
|
|
r"""setDepth(Stream self, Seiscomp::Core::Optional< double >::Impl const & depth)"""
|
|
return _datamodel.Stream_setDepth(self, depth)
|
|
|
|
def depth(self):
|
|
r"""depth(Stream self) -> double"""
|
|
return _datamodel.Stream_depth(self)
|
|
|
|
def setAzimuth(self, azimuth):
|
|
r"""setAzimuth(Stream self, Seiscomp::Core::Optional< double >::Impl const & azimuth)"""
|
|
return _datamodel.Stream_setAzimuth(self, azimuth)
|
|
|
|
def azimuth(self):
|
|
r"""azimuth(Stream self) -> double"""
|
|
return _datamodel.Stream_azimuth(self)
|
|
|
|
def setDip(self, dip):
|
|
r"""setDip(Stream self, Seiscomp::Core::Optional< double >::Impl const & dip)"""
|
|
return _datamodel.Stream_setDip(self, dip)
|
|
|
|
def dip(self):
|
|
r"""dip(Stream self) -> double"""
|
|
return _datamodel.Stream_dip(self)
|
|
|
|
def setGain(self, gain):
|
|
r"""setGain(Stream self, Seiscomp::Core::Optional< double >::Impl const & gain)"""
|
|
return _datamodel.Stream_setGain(self, gain)
|
|
|
|
def gain(self):
|
|
r"""gain(Stream self) -> double"""
|
|
return _datamodel.Stream_gain(self)
|
|
|
|
def setGainFrequency(self, gainFrequency):
|
|
r"""setGainFrequency(Stream self, Seiscomp::Core::Optional< double >::Impl const & gainFrequency)"""
|
|
return _datamodel.Stream_setGainFrequency(self, gainFrequency)
|
|
|
|
def gainFrequency(self):
|
|
r"""gainFrequency(Stream self) -> double"""
|
|
return _datamodel.Stream_gainFrequency(self)
|
|
|
|
def setGainUnit(self, gainUnit):
|
|
r"""setGainUnit(Stream self, std::string const & gainUnit)"""
|
|
return _datamodel.Stream_setGainUnit(self, gainUnit)
|
|
|
|
def gainUnit(self):
|
|
r"""gainUnit(Stream self) -> std::string const &"""
|
|
return _datamodel.Stream_gainUnit(self)
|
|
|
|
def setFormat(self, format):
|
|
r"""setFormat(Stream self, std::string const & format)"""
|
|
return _datamodel.Stream_setFormat(self, format)
|
|
|
|
def format(self):
|
|
r"""format(Stream self) -> std::string const &"""
|
|
return _datamodel.Stream_format(self)
|
|
|
|
def setFlags(self, flags):
|
|
r"""setFlags(Stream self, std::string const & flags)"""
|
|
return _datamodel.Stream_setFlags(self, flags)
|
|
|
|
def flags(self):
|
|
r"""flags(Stream self) -> std::string const &"""
|
|
return _datamodel.Stream_flags(self)
|
|
|
|
def setRestricted(self, restricted):
|
|
r"""setRestricted(Stream self, Seiscomp::Core::Optional< bool >::Impl const & restricted)"""
|
|
return _datamodel.Stream_setRestricted(self, restricted)
|
|
|
|
def restricted(self):
|
|
r"""restricted(Stream self) -> bool"""
|
|
return _datamodel.Stream_restricted(self)
|
|
|
|
def setShared(self, shared):
|
|
r"""setShared(Stream self, Seiscomp::Core::Optional< bool >::Impl const & shared)"""
|
|
return _datamodel.Stream_setShared(self, shared)
|
|
|
|
def shared(self):
|
|
r"""shared(Stream self) -> bool"""
|
|
return _datamodel.Stream_shared(self)
|
|
|
|
def index(self):
|
|
r"""index(Stream self) -> StreamIndex"""
|
|
return _datamodel.Stream_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(Stream self, Stream lhs) -> bool"""
|
|
return _datamodel.Stream_equalIndex(self, lhs)
|
|
|
|
def add(self, obj):
|
|
r"""add(Stream self, Comment obj) -> bool"""
|
|
return _datamodel.Stream_add(self, obj)
|
|
|
|
def remove(self, obj):
|
|
r"""remove(Stream self, Comment obj) -> bool"""
|
|
return _datamodel.Stream_remove(self, obj)
|
|
|
|
def removeComment(self, *args):
|
|
r"""
|
|
removeComment(Stream self, size_t i) -> bool
|
|
removeComment(Stream self, CommentIndex i) -> bool
|
|
"""
|
|
return _datamodel.Stream_removeComment(self, *args)
|
|
|
|
def commentCount(self):
|
|
r"""commentCount(Stream self) -> size_t"""
|
|
return _datamodel.Stream_commentCount(self)
|
|
|
|
def comment(self, *args):
|
|
r"""
|
|
comment(Stream self, size_t i) -> Comment
|
|
comment(Stream self, CommentIndex i) -> Comment
|
|
"""
|
|
return _datamodel.Stream_comment(self, *args)
|
|
|
|
def sensorLocation(self):
|
|
r"""sensorLocation(Stream self) -> SensorLocation"""
|
|
return _datamodel.Stream_sensorLocation(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Stream self, Object other) -> bool"""
|
|
return _datamodel.Stream_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Stream self, PublicObject parent) -> bool"""
|
|
return _datamodel.Stream_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Stream self, PublicObject parent) -> bool"""
|
|
return _datamodel.Stream_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Stream self) -> bool"""
|
|
return _datamodel.Stream_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Stream self) -> Object"""
|
|
return _datamodel.Stream_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Stream self, Object child) -> bool"""
|
|
return _datamodel.Stream_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Stream self, Visitor visitor)"""
|
|
return _datamodel.Stream_accept(self, visitor)
|
|
|
|
# Register Stream in _datamodel:
|
|
_datamodel.Stream_swigregister(Stream)
|
|
|
|
def Stream_ClassName():
|
|
r"""Stream_ClassName() -> char const *"""
|
|
return _datamodel.Stream_ClassName()
|
|
|
|
def Stream_TypeInfo():
|
|
r"""Stream_TypeInfo() -> RTTI"""
|
|
return _datamodel.Stream_TypeInfo()
|
|
|
|
def Stream_Cast(*args):
|
|
r"""
|
|
Stream_Cast(BaseObject o) -> Stream
|
|
Stream_Cast(Seiscomp::Core::BaseObjectPtr o) -> Stream
|
|
"""
|
|
return _datamodel.Stream_Cast(*args)
|
|
|
|
def Stream_ConstCast(*args):
|
|
r"""
|
|
Stream_ConstCast(BaseObject o) -> Stream
|
|
Stream_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Stream
|
|
"""
|
|
return _datamodel.Stream_ConstCast(*args)
|
|
|
|
def Stream_Meta():
|
|
r"""Stream_Meta() -> MetaObject"""
|
|
return _datamodel.Stream_Meta()
|
|
|
|
def Stream_Create(*args):
|
|
r"""
|
|
Stream_Create() -> Stream
|
|
Stream_Create(std::string const & publicID) -> Stream
|
|
"""
|
|
return _datamodel.Stream_Create(*args)
|
|
|
|
def Stream_Find(publicID):
|
|
r"""Stream_Find(std::string const & publicID) -> Stream"""
|
|
return _datamodel.Stream_Find(publicID)
|
|
|
|
class SensorLocationIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::SensorLocationIndex 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__(SensorLocationIndex self) -> SensorLocationIndex
|
|
__init__(SensorLocationIndex self, std::string const & code, Time start) -> SensorLocationIndex
|
|
__init__(SensorLocationIndex self, SensorLocationIndex arg2) -> SensorLocationIndex
|
|
"""
|
|
_datamodel.SensorLocationIndex_swiginit(self, _datamodel.new_SensorLocationIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(SensorLocationIndex self, SensorLocationIndex arg2) -> bool"""
|
|
return _datamodel.SensorLocationIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(SensorLocationIndex self, SensorLocationIndex arg2) -> bool"""
|
|
return _datamodel.SensorLocationIndex___ne__(self, arg2)
|
|
code = property(_datamodel.SensorLocationIndex_code_get, _datamodel.SensorLocationIndex_code_set, doc=r"""code : std::string""")
|
|
start = property(_datamodel.SensorLocationIndex_start_get, _datamodel.SensorLocationIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
|
|
__swig_destroy__ = _datamodel.delete_SensorLocationIndex
|
|
|
|
# Register SensorLocationIndex in _datamodel:
|
|
_datamodel.SensorLocationIndex_swigregister(SensorLocationIndex)
|
|
|
|
class SensorLocation(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::SensorLocation 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 _datamodel.SensorLocation_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.SensorLocation_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(SensorLocation self) -> char const *"""
|
|
return _datamodel.SensorLocation_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(SensorLocation self) -> RTTI"""
|
|
return _datamodel.SensorLocation_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> SensorLocation
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> SensorLocation
|
|
"""
|
|
return _datamodel.SensorLocation_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> SensorLocation
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SensorLocation
|
|
"""
|
|
return _datamodel.SensorLocation_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(SensorLocation self, GenericArchive ar)"""
|
|
return _datamodel.SensorLocation_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.SensorLocation_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(SensorLocation self) -> MetaObject"""
|
|
return _datamodel.SensorLocation_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(SensorLocation self, SensorLocation other) -> SensorLocation
|
|
__init__(SensorLocation self, std::string const & publicID) -> SensorLocation
|
|
"""
|
|
_datamodel.SensorLocation_swiginit(self, _datamodel.new_SensorLocation(*args))
|
|
__swig_destroy__ = _datamodel.delete_SensorLocation
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> SensorLocation
|
|
Create(std::string const & publicID) -> SensorLocation
|
|
"""
|
|
return _datamodel.SensorLocation_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> SensorLocation"""
|
|
return _datamodel.SensorLocation_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(SensorLocation self, SensorLocation other) -> bool"""
|
|
return _datamodel.SensorLocation___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(SensorLocation self, SensorLocation other) -> bool"""
|
|
return _datamodel.SensorLocation___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(SensorLocation self, SensorLocation other) -> bool"""
|
|
return _datamodel.SensorLocation_equal(self, other)
|
|
|
|
def setCode(self, code):
|
|
r"""setCode(SensorLocation self, std::string const & code)"""
|
|
return _datamodel.SensorLocation_setCode(self, code)
|
|
|
|
def code(self):
|
|
r"""code(SensorLocation self) -> std::string const &"""
|
|
return _datamodel.SensorLocation_code(self)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(SensorLocation self, Time start)"""
|
|
return _datamodel.SensorLocation_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(SensorLocation self) -> Time"""
|
|
return _datamodel.SensorLocation_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(SensorLocation self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
|
|
return _datamodel.SensorLocation_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(SensorLocation self) -> Time"""
|
|
return _datamodel.SensorLocation_end(self)
|
|
|
|
def setLatitude(self, latitude):
|
|
r"""setLatitude(SensorLocation self, Seiscomp::Core::Optional< double >::Impl const & latitude)"""
|
|
return _datamodel.SensorLocation_setLatitude(self, latitude)
|
|
|
|
def latitude(self):
|
|
r"""latitude(SensorLocation self) -> double"""
|
|
return _datamodel.SensorLocation_latitude(self)
|
|
|
|
def setLongitude(self, longitude):
|
|
r"""setLongitude(SensorLocation self, Seiscomp::Core::Optional< double >::Impl const & longitude)"""
|
|
return _datamodel.SensorLocation_setLongitude(self, longitude)
|
|
|
|
def longitude(self):
|
|
r"""longitude(SensorLocation self) -> double"""
|
|
return _datamodel.SensorLocation_longitude(self)
|
|
|
|
def setElevation(self, elevation):
|
|
r"""setElevation(SensorLocation self, Seiscomp::Core::Optional< double >::Impl const & elevation)"""
|
|
return _datamodel.SensorLocation_setElevation(self, elevation)
|
|
|
|
def elevation(self):
|
|
r"""elevation(SensorLocation self) -> double"""
|
|
return _datamodel.SensorLocation_elevation(self)
|
|
|
|
def index(self):
|
|
r"""index(SensorLocation self) -> SensorLocationIndex"""
|
|
return _datamodel.SensorLocation_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(SensorLocation self, SensorLocation lhs) -> bool"""
|
|
return _datamodel.SensorLocation_equalIndex(self, lhs)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(SensorLocation self, Comment obj) -> bool
|
|
add(SensorLocation self, AuxStream obj) -> bool
|
|
add(SensorLocation self, Stream obj) -> bool
|
|
"""
|
|
return _datamodel.SensorLocation_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(SensorLocation self, Comment obj) -> bool
|
|
remove(SensorLocation self, AuxStream obj) -> bool
|
|
remove(SensorLocation self, Stream obj) -> bool
|
|
"""
|
|
return _datamodel.SensorLocation_remove(self, *args)
|
|
|
|
def removeComment(self, *args):
|
|
r"""
|
|
removeComment(SensorLocation self, size_t i) -> bool
|
|
removeComment(SensorLocation self, CommentIndex i) -> bool
|
|
"""
|
|
return _datamodel.SensorLocation_removeComment(self, *args)
|
|
|
|
def removeAuxStream(self, *args):
|
|
r"""
|
|
removeAuxStream(SensorLocation self, size_t i) -> bool
|
|
removeAuxStream(SensorLocation self, AuxStreamIndex i) -> bool
|
|
"""
|
|
return _datamodel.SensorLocation_removeAuxStream(self, *args)
|
|
|
|
def removeStream(self, *args):
|
|
r"""
|
|
removeStream(SensorLocation self, size_t i) -> bool
|
|
removeStream(SensorLocation self, StreamIndex i) -> bool
|
|
"""
|
|
return _datamodel.SensorLocation_removeStream(self, *args)
|
|
|
|
def commentCount(self):
|
|
r"""commentCount(SensorLocation self) -> size_t"""
|
|
return _datamodel.SensorLocation_commentCount(self)
|
|
|
|
def auxStreamCount(self):
|
|
r"""auxStreamCount(SensorLocation self) -> size_t"""
|
|
return _datamodel.SensorLocation_auxStreamCount(self)
|
|
|
|
def streamCount(self):
|
|
r"""streamCount(SensorLocation self) -> size_t"""
|
|
return _datamodel.SensorLocation_streamCount(self)
|
|
|
|
def comment(self, *args):
|
|
r"""
|
|
comment(SensorLocation self, size_t i) -> Comment
|
|
comment(SensorLocation self, CommentIndex i) -> Comment
|
|
"""
|
|
return _datamodel.SensorLocation_comment(self, *args)
|
|
|
|
def auxStream(self, *args):
|
|
r"""
|
|
auxStream(SensorLocation self, size_t i) -> AuxStream
|
|
auxStream(SensorLocation self, AuxStreamIndex i) -> AuxStream
|
|
"""
|
|
return _datamodel.SensorLocation_auxStream(self, *args)
|
|
|
|
def stream(self, *args):
|
|
r"""
|
|
stream(SensorLocation self, size_t i) -> Stream
|
|
stream(SensorLocation self, StreamIndex i) -> Stream
|
|
"""
|
|
return _datamodel.SensorLocation_stream(self, *args)
|
|
|
|
def findStream(self, publicID):
|
|
r"""findStream(SensorLocation self, std::string const & publicID) -> Stream"""
|
|
return _datamodel.SensorLocation_findStream(self, publicID)
|
|
|
|
def station(self):
|
|
r"""station(SensorLocation self) -> Station"""
|
|
return _datamodel.SensorLocation_station(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(SensorLocation self, Object other) -> bool"""
|
|
return _datamodel.SensorLocation_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(SensorLocation self, PublicObject parent) -> bool"""
|
|
return _datamodel.SensorLocation_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(SensorLocation self, PublicObject parent) -> bool"""
|
|
return _datamodel.SensorLocation_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(SensorLocation self) -> bool"""
|
|
return _datamodel.SensorLocation_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(SensorLocation self) -> Object"""
|
|
return _datamodel.SensorLocation_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(SensorLocation self, Object child) -> bool"""
|
|
return _datamodel.SensorLocation_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(SensorLocation self, Visitor visitor)"""
|
|
return _datamodel.SensorLocation_accept(self, visitor)
|
|
|
|
# Register SensorLocation in _datamodel:
|
|
_datamodel.SensorLocation_swigregister(SensorLocation)
|
|
|
|
def SensorLocation_ClassName():
|
|
r"""SensorLocation_ClassName() -> char const *"""
|
|
return _datamodel.SensorLocation_ClassName()
|
|
|
|
def SensorLocation_TypeInfo():
|
|
r"""SensorLocation_TypeInfo() -> RTTI"""
|
|
return _datamodel.SensorLocation_TypeInfo()
|
|
|
|
def SensorLocation_Cast(*args):
|
|
r"""
|
|
SensorLocation_Cast(BaseObject o) -> SensorLocation
|
|
SensorLocation_Cast(Seiscomp::Core::BaseObjectPtr o) -> SensorLocation
|
|
"""
|
|
return _datamodel.SensorLocation_Cast(*args)
|
|
|
|
def SensorLocation_ConstCast(*args):
|
|
r"""
|
|
SensorLocation_ConstCast(BaseObject o) -> SensorLocation
|
|
SensorLocation_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SensorLocation
|
|
"""
|
|
return _datamodel.SensorLocation_ConstCast(*args)
|
|
|
|
def SensorLocation_Meta():
|
|
r"""SensorLocation_Meta() -> MetaObject"""
|
|
return _datamodel.SensorLocation_Meta()
|
|
|
|
def SensorLocation_Create(*args):
|
|
r"""
|
|
SensorLocation_Create() -> SensorLocation
|
|
SensorLocation_Create(std::string const & publicID) -> SensorLocation
|
|
"""
|
|
return _datamodel.SensorLocation_Create(*args)
|
|
|
|
def SensorLocation_Find(publicID):
|
|
r"""SensorLocation_Find(std::string const & publicID) -> SensorLocation"""
|
|
return _datamodel.SensorLocation_Find(publicID)
|
|
|
|
class StationIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::StationIndex 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__(StationIndex self) -> StationIndex
|
|
__init__(StationIndex self, std::string const & code, Time start) -> StationIndex
|
|
__init__(StationIndex self, StationIndex arg2) -> StationIndex
|
|
"""
|
|
_datamodel.StationIndex_swiginit(self, _datamodel.new_StationIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(StationIndex self, StationIndex arg2) -> bool"""
|
|
return _datamodel.StationIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(StationIndex self, StationIndex arg2) -> bool"""
|
|
return _datamodel.StationIndex___ne__(self, arg2)
|
|
code = property(_datamodel.StationIndex_code_get, _datamodel.StationIndex_code_set, doc=r"""code : std::string""")
|
|
start = property(_datamodel.StationIndex_start_get, _datamodel.StationIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
|
|
__swig_destroy__ = _datamodel.delete_StationIndex
|
|
|
|
# Register StationIndex in _datamodel:
|
|
_datamodel.StationIndex_swigregister(StationIndex)
|
|
|
|
class Station(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Station 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 _datamodel.Station_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Station_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Station self) -> char const *"""
|
|
return _datamodel.Station_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Station self) -> RTTI"""
|
|
return _datamodel.Station_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Station
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Station
|
|
"""
|
|
return _datamodel.Station_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Station
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Station
|
|
"""
|
|
return _datamodel.Station_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Station self, GenericArchive ar)"""
|
|
return _datamodel.Station_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Station_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Station self) -> MetaObject"""
|
|
return _datamodel.Station_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Station self, Station other) -> Station
|
|
__init__(Station self, std::string const & publicID) -> Station
|
|
"""
|
|
_datamodel.Station_swiginit(self, _datamodel.new_Station(*args))
|
|
__swig_destroy__ = _datamodel.delete_Station
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> Station
|
|
Create(std::string const & publicID) -> Station
|
|
"""
|
|
return _datamodel.Station_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> Station"""
|
|
return _datamodel.Station_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Station self, Station other) -> bool"""
|
|
return _datamodel.Station___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Station self, Station other) -> bool"""
|
|
return _datamodel.Station___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Station self, Station other) -> bool"""
|
|
return _datamodel.Station_equal(self, other)
|
|
|
|
def setCode(self, code):
|
|
r"""setCode(Station self, std::string const & code)"""
|
|
return _datamodel.Station_setCode(self, code)
|
|
|
|
def code(self):
|
|
r"""code(Station self) -> std::string const &"""
|
|
return _datamodel.Station_code(self)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(Station self, Time start)"""
|
|
return _datamodel.Station_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(Station self) -> Time"""
|
|
return _datamodel.Station_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(Station self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
|
|
return _datamodel.Station_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(Station self) -> Time"""
|
|
return _datamodel.Station_end(self)
|
|
|
|
def setDescription(self, description):
|
|
r"""setDescription(Station self, std::string const & description)"""
|
|
return _datamodel.Station_setDescription(self, description)
|
|
|
|
def description(self):
|
|
r"""description(Station self) -> std::string const &"""
|
|
return _datamodel.Station_description(self)
|
|
|
|
def setLatitude(self, latitude):
|
|
r"""setLatitude(Station self, Seiscomp::Core::Optional< double >::Impl const & latitude)"""
|
|
return _datamodel.Station_setLatitude(self, latitude)
|
|
|
|
def latitude(self):
|
|
r"""latitude(Station self) -> double"""
|
|
return _datamodel.Station_latitude(self)
|
|
|
|
def setLongitude(self, longitude):
|
|
r"""setLongitude(Station self, Seiscomp::Core::Optional< double >::Impl const & longitude)"""
|
|
return _datamodel.Station_setLongitude(self, longitude)
|
|
|
|
def longitude(self):
|
|
r"""longitude(Station self) -> double"""
|
|
return _datamodel.Station_longitude(self)
|
|
|
|
def setElevation(self, elevation):
|
|
r"""setElevation(Station self, Seiscomp::Core::Optional< double >::Impl const & elevation)"""
|
|
return _datamodel.Station_setElevation(self, elevation)
|
|
|
|
def elevation(self):
|
|
r"""elevation(Station self) -> double"""
|
|
return _datamodel.Station_elevation(self)
|
|
|
|
def setPlace(self, place):
|
|
r"""setPlace(Station self, std::string const & place)"""
|
|
return _datamodel.Station_setPlace(self, place)
|
|
|
|
def place(self):
|
|
r"""place(Station self) -> std::string const &"""
|
|
return _datamodel.Station_place(self)
|
|
|
|
def setCountry(self, country):
|
|
r"""setCountry(Station self, std::string const & country)"""
|
|
return _datamodel.Station_setCountry(self, country)
|
|
|
|
def country(self):
|
|
r"""country(Station self) -> std::string const &"""
|
|
return _datamodel.Station_country(self)
|
|
|
|
def setAffiliation(self, affiliation):
|
|
r"""setAffiliation(Station self, std::string const & affiliation)"""
|
|
return _datamodel.Station_setAffiliation(self, affiliation)
|
|
|
|
def affiliation(self):
|
|
r"""affiliation(Station self) -> std::string const &"""
|
|
return _datamodel.Station_affiliation(self)
|
|
|
|
def setType(self, type):
|
|
r"""setType(Station self, std::string const & type)"""
|
|
return _datamodel.Station_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(Station self) -> std::string const &"""
|
|
return _datamodel.Station_type(self)
|
|
|
|
def setArchive(self, archive):
|
|
r"""setArchive(Station self, std::string const & archive)"""
|
|
return _datamodel.Station_setArchive(self, archive)
|
|
|
|
def archive(self):
|
|
r"""archive(Station self) -> std::string const &"""
|
|
return _datamodel.Station_archive(self)
|
|
|
|
def setArchiveNetworkCode(self, archiveNetworkCode):
|
|
r"""setArchiveNetworkCode(Station self, std::string const & archiveNetworkCode)"""
|
|
return _datamodel.Station_setArchiveNetworkCode(self, archiveNetworkCode)
|
|
|
|
def archiveNetworkCode(self):
|
|
r"""archiveNetworkCode(Station self) -> std::string const &"""
|
|
return _datamodel.Station_archiveNetworkCode(self)
|
|
|
|
def setRestricted(self, restricted):
|
|
r"""setRestricted(Station self, Seiscomp::Core::Optional< bool >::Impl const & restricted)"""
|
|
return _datamodel.Station_setRestricted(self, restricted)
|
|
|
|
def restricted(self):
|
|
r"""restricted(Station self) -> bool"""
|
|
return _datamodel.Station_restricted(self)
|
|
|
|
def setShared(self, shared):
|
|
r"""setShared(Station self, Seiscomp::Core::Optional< bool >::Impl const & shared)"""
|
|
return _datamodel.Station_setShared(self, shared)
|
|
|
|
def shared(self):
|
|
r"""shared(Station self) -> bool"""
|
|
return _datamodel.Station_shared(self)
|
|
|
|
def setRemark(self, remark):
|
|
r"""setRemark(Station self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
|
|
return _datamodel.Station_setRemark(self, remark)
|
|
|
|
def remark(self, *args):
|
|
r"""
|
|
remark(Station self) -> Blob
|
|
remark(Station self) -> Blob
|
|
"""
|
|
return _datamodel.Station_remark(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(Station self) -> StationIndex"""
|
|
return _datamodel.Station_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(Station self, Station lhs) -> bool"""
|
|
return _datamodel.Station_equalIndex(self, lhs)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(Station self, Comment obj) -> bool
|
|
add(Station self, SensorLocation obj) -> bool
|
|
"""
|
|
return _datamodel.Station_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(Station self, Comment obj) -> bool
|
|
remove(Station self, SensorLocation obj) -> bool
|
|
"""
|
|
return _datamodel.Station_remove(self, *args)
|
|
|
|
def removeComment(self, *args):
|
|
r"""
|
|
removeComment(Station self, size_t i) -> bool
|
|
removeComment(Station self, CommentIndex i) -> bool
|
|
"""
|
|
return _datamodel.Station_removeComment(self, *args)
|
|
|
|
def removeSensorLocation(self, *args):
|
|
r"""
|
|
removeSensorLocation(Station self, size_t i) -> bool
|
|
removeSensorLocation(Station self, SensorLocationIndex i) -> bool
|
|
"""
|
|
return _datamodel.Station_removeSensorLocation(self, *args)
|
|
|
|
def commentCount(self):
|
|
r"""commentCount(Station self) -> size_t"""
|
|
return _datamodel.Station_commentCount(self)
|
|
|
|
def sensorLocationCount(self):
|
|
r"""sensorLocationCount(Station self) -> size_t"""
|
|
return _datamodel.Station_sensorLocationCount(self)
|
|
|
|
def comment(self, *args):
|
|
r"""
|
|
comment(Station self, size_t i) -> Comment
|
|
comment(Station self, CommentIndex i) -> Comment
|
|
"""
|
|
return _datamodel.Station_comment(self, *args)
|
|
|
|
def sensorLocation(self, *args):
|
|
r"""
|
|
sensorLocation(Station self, size_t i) -> SensorLocation
|
|
sensorLocation(Station self, SensorLocationIndex i) -> SensorLocation
|
|
"""
|
|
return _datamodel.Station_sensorLocation(self, *args)
|
|
|
|
def findSensorLocation(self, publicID):
|
|
r"""findSensorLocation(Station self, std::string const & publicID) -> SensorLocation"""
|
|
return _datamodel.Station_findSensorLocation(self, publicID)
|
|
|
|
def network(self):
|
|
r"""network(Station self) -> Network"""
|
|
return _datamodel.Station_network(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Station self, Object other) -> bool"""
|
|
return _datamodel.Station_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Station self, PublicObject parent) -> bool"""
|
|
return _datamodel.Station_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Station self, PublicObject parent) -> bool"""
|
|
return _datamodel.Station_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Station self) -> bool"""
|
|
return _datamodel.Station_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Station self) -> Object"""
|
|
return _datamodel.Station_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Station self, Object child) -> bool"""
|
|
return _datamodel.Station_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Station self, Visitor visitor)"""
|
|
return _datamodel.Station_accept(self, visitor)
|
|
|
|
# Register Station in _datamodel:
|
|
_datamodel.Station_swigregister(Station)
|
|
|
|
def Station_ClassName():
|
|
r"""Station_ClassName() -> char const *"""
|
|
return _datamodel.Station_ClassName()
|
|
|
|
def Station_TypeInfo():
|
|
r"""Station_TypeInfo() -> RTTI"""
|
|
return _datamodel.Station_TypeInfo()
|
|
|
|
def Station_Cast(*args):
|
|
r"""
|
|
Station_Cast(BaseObject o) -> Station
|
|
Station_Cast(Seiscomp::Core::BaseObjectPtr o) -> Station
|
|
"""
|
|
return _datamodel.Station_Cast(*args)
|
|
|
|
def Station_ConstCast(*args):
|
|
r"""
|
|
Station_ConstCast(BaseObject o) -> Station
|
|
Station_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Station
|
|
"""
|
|
return _datamodel.Station_ConstCast(*args)
|
|
|
|
def Station_Meta():
|
|
r"""Station_Meta() -> MetaObject"""
|
|
return _datamodel.Station_Meta()
|
|
|
|
def Station_Create(*args):
|
|
r"""
|
|
Station_Create() -> Station
|
|
Station_Create(std::string const & publicID) -> Station
|
|
"""
|
|
return _datamodel.Station_Create(*args)
|
|
|
|
def Station_Find(publicID):
|
|
r"""Station_Find(std::string const & publicID) -> Station"""
|
|
return _datamodel.Station_Find(publicID)
|
|
|
|
class NetworkIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::NetworkIndex 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__(NetworkIndex self) -> NetworkIndex
|
|
__init__(NetworkIndex self, std::string const & code, Time start) -> NetworkIndex
|
|
__init__(NetworkIndex self, NetworkIndex arg2) -> NetworkIndex
|
|
"""
|
|
_datamodel.NetworkIndex_swiginit(self, _datamodel.new_NetworkIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(NetworkIndex self, NetworkIndex arg2) -> bool"""
|
|
return _datamodel.NetworkIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(NetworkIndex self, NetworkIndex arg2) -> bool"""
|
|
return _datamodel.NetworkIndex___ne__(self, arg2)
|
|
code = property(_datamodel.NetworkIndex_code_get, _datamodel.NetworkIndex_code_set, doc=r"""code : std::string""")
|
|
start = property(_datamodel.NetworkIndex_start_get, _datamodel.NetworkIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
|
|
__swig_destroy__ = _datamodel.delete_NetworkIndex
|
|
|
|
# Register NetworkIndex in _datamodel:
|
|
_datamodel.NetworkIndex_swigregister(NetworkIndex)
|
|
|
|
class Network(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Network 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 _datamodel.Network_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Network_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Network self) -> char const *"""
|
|
return _datamodel.Network_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Network self) -> RTTI"""
|
|
return _datamodel.Network_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Network
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Network
|
|
"""
|
|
return _datamodel.Network_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Network
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Network
|
|
"""
|
|
return _datamodel.Network_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Network self, GenericArchive ar)"""
|
|
return _datamodel.Network_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Network_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Network self) -> MetaObject"""
|
|
return _datamodel.Network_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Network self, Network other) -> Network
|
|
__init__(Network self, std::string const & publicID) -> Network
|
|
"""
|
|
_datamodel.Network_swiginit(self, _datamodel.new_Network(*args))
|
|
__swig_destroy__ = _datamodel.delete_Network
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> Network
|
|
Create(std::string const & publicID) -> Network
|
|
"""
|
|
return _datamodel.Network_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> Network"""
|
|
return _datamodel.Network_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Network self, Network other) -> bool"""
|
|
return _datamodel.Network___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Network self, Network other) -> bool"""
|
|
return _datamodel.Network___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Network self, Network other) -> bool"""
|
|
return _datamodel.Network_equal(self, other)
|
|
|
|
def setCode(self, code):
|
|
r"""setCode(Network self, std::string const & code)"""
|
|
return _datamodel.Network_setCode(self, code)
|
|
|
|
def code(self):
|
|
r"""code(Network self) -> std::string const &"""
|
|
return _datamodel.Network_code(self)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(Network self, Time start)"""
|
|
return _datamodel.Network_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(Network self) -> Time"""
|
|
return _datamodel.Network_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(Network self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
|
|
return _datamodel.Network_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(Network self) -> Time"""
|
|
return _datamodel.Network_end(self)
|
|
|
|
def setDescription(self, description):
|
|
r"""setDescription(Network self, std::string const & description)"""
|
|
return _datamodel.Network_setDescription(self, description)
|
|
|
|
def description(self):
|
|
r"""description(Network self) -> std::string const &"""
|
|
return _datamodel.Network_description(self)
|
|
|
|
def setInstitutions(self, institutions):
|
|
r"""setInstitutions(Network self, std::string const & institutions)"""
|
|
return _datamodel.Network_setInstitutions(self, institutions)
|
|
|
|
def institutions(self):
|
|
r"""institutions(Network self) -> std::string const &"""
|
|
return _datamodel.Network_institutions(self)
|
|
|
|
def setRegion(self, region):
|
|
r"""setRegion(Network self, std::string const & region)"""
|
|
return _datamodel.Network_setRegion(self, region)
|
|
|
|
def region(self):
|
|
r"""region(Network self) -> std::string const &"""
|
|
return _datamodel.Network_region(self)
|
|
|
|
def setType(self, type):
|
|
r"""setType(Network self, std::string const & type)"""
|
|
return _datamodel.Network_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(Network self) -> std::string const &"""
|
|
return _datamodel.Network_type(self)
|
|
|
|
def setNetClass(self, netClass):
|
|
r"""setNetClass(Network self, std::string const & netClass)"""
|
|
return _datamodel.Network_setNetClass(self, netClass)
|
|
|
|
def netClass(self):
|
|
r"""netClass(Network self) -> std::string const &"""
|
|
return _datamodel.Network_netClass(self)
|
|
|
|
def setArchive(self, archive):
|
|
r"""setArchive(Network self, std::string const & archive)"""
|
|
return _datamodel.Network_setArchive(self, archive)
|
|
|
|
def archive(self):
|
|
r"""archive(Network self) -> std::string const &"""
|
|
return _datamodel.Network_archive(self)
|
|
|
|
def setRestricted(self, restricted):
|
|
r"""setRestricted(Network self, Seiscomp::Core::Optional< bool >::Impl const & restricted)"""
|
|
return _datamodel.Network_setRestricted(self, restricted)
|
|
|
|
def restricted(self):
|
|
r"""restricted(Network self) -> bool"""
|
|
return _datamodel.Network_restricted(self)
|
|
|
|
def setShared(self, shared):
|
|
r"""setShared(Network self, Seiscomp::Core::Optional< bool >::Impl const & shared)"""
|
|
return _datamodel.Network_setShared(self, shared)
|
|
|
|
def shared(self):
|
|
r"""shared(Network self) -> bool"""
|
|
return _datamodel.Network_shared(self)
|
|
|
|
def setRemark(self, remark):
|
|
r"""setRemark(Network self, Seiscomp::Core::Optional< Seiscomp::DataModel::Blob >::Impl const & remark)"""
|
|
return _datamodel.Network_setRemark(self, remark)
|
|
|
|
def remark(self, *args):
|
|
r"""
|
|
remark(Network self) -> Blob
|
|
remark(Network self) -> Blob
|
|
"""
|
|
return _datamodel.Network_remark(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(Network self) -> NetworkIndex"""
|
|
return _datamodel.Network_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(Network self, Network lhs) -> bool"""
|
|
return _datamodel.Network_equalIndex(self, lhs)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(Network self, Comment obj) -> bool
|
|
add(Network self, Station obj) -> bool
|
|
"""
|
|
return _datamodel.Network_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(Network self, Comment obj) -> bool
|
|
remove(Network self, Station obj) -> bool
|
|
"""
|
|
return _datamodel.Network_remove(self, *args)
|
|
|
|
def removeComment(self, *args):
|
|
r"""
|
|
removeComment(Network self, size_t i) -> bool
|
|
removeComment(Network self, CommentIndex i) -> bool
|
|
"""
|
|
return _datamodel.Network_removeComment(self, *args)
|
|
|
|
def removeStation(self, *args):
|
|
r"""
|
|
removeStation(Network self, size_t i) -> bool
|
|
removeStation(Network self, StationIndex i) -> bool
|
|
"""
|
|
return _datamodel.Network_removeStation(self, *args)
|
|
|
|
def commentCount(self):
|
|
r"""commentCount(Network self) -> size_t"""
|
|
return _datamodel.Network_commentCount(self)
|
|
|
|
def stationCount(self):
|
|
r"""stationCount(Network self) -> size_t"""
|
|
return _datamodel.Network_stationCount(self)
|
|
|
|
def comment(self, *args):
|
|
r"""
|
|
comment(Network self, size_t i) -> Comment
|
|
comment(Network self, CommentIndex i) -> Comment
|
|
"""
|
|
return _datamodel.Network_comment(self, *args)
|
|
|
|
def station(self, *args):
|
|
r"""
|
|
station(Network self, size_t i) -> Station
|
|
station(Network self, StationIndex i) -> Station
|
|
"""
|
|
return _datamodel.Network_station(self, *args)
|
|
|
|
def findStation(self, publicID):
|
|
r"""findStation(Network self, std::string const & publicID) -> Station"""
|
|
return _datamodel.Network_findStation(self, publicID)
|
|
|
|
def inventory(self):
|
|
r"""inventory(Network self) -> Inventory"""
|
|
return _datamodel.Network_inventory(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Network self, Object other) -> bool"""
|
|
return _datamodel.Network_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Network self, PublicObject parent) -> bool"""
|
|
return _datamodel.Network_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Network self, PublicObject parent) -> bool"""
|
|
return _datamodel.Network_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Network self) -> bool"""
|
|
return _datamodel.Network_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Network self) -> Object"""
|
|
return _datamodel.Network_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Network self, Object child) -> bool"""
|
|
return _datamodel.Network_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Network self, Visitor visitor)"""
|
|
return _datamodel.Network_accept(self, visitor)
|
|
|
|
# Register Network in _datamodel:
|
|
_datamodel.Network_swigregister(Network)
|
|
|
|
def Network_ClassName():
|
|
r"""Network_ClassName() -> char const *"""
|
|
return _datamodel.Network_ClassName()
|
|
|
|
def Network_TypeInfo():
|
|
r"""Network_TypeInfo() -> RTTI"""
|
|
return _datamodel.Network_TypeInfo()
|
|
|
|
def Network_Cast(*args):
|
|
r"""
|
|
Network_Cast(BaseObject o) -> Network
|
|
Network_Cast(Seiscomp::Core::BaseObjectPtr o) -> Network
|
|
"""
|
|
return _datamodel.Network_Cast(*args)
|
|
|
|
def Network_ConstCast(*args):
|
|
r"""
|
|
Network_ConstCast(BaseObject o) -> Network
|
|
Network_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Network
|
|
"""
|
|
return _datamodel.Network_ConstCast(*args)
|
|
|
|
def Network_Meta():
|
|
r"""Network_Meta() -> MetaObject"""
|
|
return _datamodel.Network_Meta()
|
|
|
|
def Network_Create(*args):
|
|
r"""
|
|
Network_Create() -> Network
|
|
Network_Create(std::string const & publicID) -> Network
|
|
"""
|
|
return _datamodel.Network_Create(*args)
|
|
|
|
def Network_Find(publicID):
|
|
r"""Network_Find(std::string const & publicID) -> Network"""
|
|
return _datamodel.Network_Find(publicID)
|
|
|
|
class Inventory(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Inventory 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 _datamodel.Inventory_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Inventory_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Inventory self) -> char const *"""
|
|
return _datamodel.Inventory_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Inventory self) -> RTTI"""
|
|
return _datamodel.Inventory_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Inventory
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Inventory
|
|
"""
|
|
return _datamodel.Inventory_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Inventory
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Inventory
|
|
"""
|
|
return _datamodel.Inventory_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Inventory self, GenericArchive ar)"""
|
|
return _datamodel.Inventory_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Inventory_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Inventory self) -> MetaObject"""
|
|
return _datamodel.Inventory_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Inventory self) -> Inventory
|
|
__init__(Inventory self, Inventory other) -> Inventory
|
|
"""
|
|
_datamodel.Inventory_swiginit(self, _datamodel.new_Inventory(*args))
|
|
__swig_destroy__ = _datamodel.delete_Inventory
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Inventory self, Inventory other) -> bool"""
|
|
return _datamodel.Inventory___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Inventory self, Inventory other) -> bool"""
|
|
return _datamodel.Inventory___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Inventory self, Inventory other) -> bool"""
|
|
return _datamodel.Inventory_equal(self, other)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(Inventory self, StationGroup obj) -> bool
|
|
add(Inventory self, AuxDevice obj) -> bool
|
|
add(Inventory self, Sensor obj) -> bool
|
|
add(Inventory self, Datalogger obj) -> bool
|
|
add(Inventory self, ResponsePAZ obj) -> bool
|
|
add(Inventory self, ResponseFIR obj) -> bool
|
|
add(Inventory self, ResponseIIR obj) -> bool
|
|
add(Inventory self, ResponsePolynomial obj) -> bool
|
|
add(Inventory self, ResponseFAP obj) -> bool
|
|
add(Inventory self, Network obj) -> bool
|
|
"""
|
|
return _datamodel.Inventory_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(Inventory self, StationGroup obj) -> bool
|
|
remove(Inventory self, AuxDevice obj) -> bool
|
|
remove(Inventory self, Sensor obj) -> bool
|
|
remove(Inventory self, Datalogger obj) -> bool
|
|
remove(Inventory self, ResponsePAZ obj) -> bool
|
|
remove(Inventory self, ResponseFIR obj) -> bool
|
|
remove(Inventory self, ResponseIIR obj) -> bool
|
|
remove(Inventory self, ResponsePolynomial obj) -> bool
|
|
remove(Inventory self, ResponseFAP obj) -> bool
|
|
remove(Inventory self, Network obj) -> bool
|
|
"""
|
|
return _datamodel.Inventory_remove(self, *args)
|
|
|
|
def removeStationGroup(self, *args):
|
|
r"""
|
|
removeStationGroup(Inventory self, size_t i) -> bool
|
|
removeStationGroup(Inventory self, StationGroupIndex i) -> bool
|
|
"""
|
|
return _datamodel.Inventory_removeStationGroup(self, *args)
|
|
|
|
def removeAuxDevice(self, *args):
|
|
r"""
|
|
removeAuxDevice(Inventory self, size_t i) -> bool
|
|
removeAuxDevice(Inventory self, AuxDeviceIndex i) -> bool
|
|
"""
|
|
return _datamodel.Inventory_removeAuxDevice(self, *args)
|
|
|
|
def removeSensor(self, *args):
|
|
r"""
|
|
removeSensor(Inventory self, size_t i) -> bool
|
|
removeSensor(Inventory self, SensorIndex i) -> bool
|
|
"""
|
|
return _datamodel.Inventory_removeSensor(self, *args)
|
|
|
|
def removeDatalogger(self, *args):
|
|
r"""
|
|
removeDatalogger(Inventory self, size_t i) -> bool
|
|
removeDatalogger(Inventory self, DataloggerIndex i) -> bool
|
|
"""
|
|
return _datamodel.Inventory_removeDatalogger(self, *args)
|
|
|
|
def removeResponsePAZ(self, *args):
|
|
r"""
|
|
removeResponsePAZ(Inventory self, size_t i) -> bool
|
|
removeResponsePAZ(Inventory self, ResponsePAZIndex i) -> bool
|
|
"""
|
|
return _datamodel.Inventory_removeResponsePAZ(self, *args)
|
|
|
|
def removeResponseFIR(self, *args):
|
|
r"""
|
|
removeResponseFIR(Inventory self, size_t i) -> bool
|
|
removeResponseFIR(Inventory self, ResponseFIRIndex i) -> bool
|
|
"""
|
|
return _datamodel.Inventory_removeResponseFIR(self, *args)
|
|
|
|
def removeResponseIIR(self, *args):
|
|
r"""
|
|
removeResponseIIR(Inventory self, size_t i) -> bool
|
|
removeResponseIIR(Inventory self, ResponseIIRIndex i) -> bool
|
|
"""
|
|
return _datamodel.Inventory_removeResponseIIR(self, *args)
|
|
|
|
def removeResponsePolynomial(self, *args):
|
|
r"""
|
|
removeResponsePolynomial(Inventory self, size_t i) -> bool
|
|
removeResponsePolynomial(Inventory self, ResponsePolynomialIndex i) -> bool
|
|
"""
|
|
return _datamodel.Inventory_removeResponsePolynomial(self, *args)
|
|
|
|
def removeResponseFAP(self, *args):
|
|
r"""
|
|
removeResponseFAP(Inventory self, size_t i) -> bool
|
|
removeResponseFAP(Inventory self, ResponseFAPIndex i) -> bool
|
|
"""
|
|
return _datamodel.Inventory_removeResponseFAP(self, *args)
|
|
|
|
def removeNetwork(self, *args):
|
|
r"""
|
|
removeNetwork(Inventory self, size_t i) -> bool
|
|
removeNetwork(Inventory self, NetworkIndex i) -> bool
|
|
"""
|
|
return _datamodel.Inventory_removeNetwork(self, *args)
|
|
|
|
def stationGroupCount(self):
|
|
r"""stationGroupCount(Inventory self) -> size_t"""
|
|
return _datamodel.Inventory_stationGroupCount(self)
|
|
|
|
def auxDeviceCount(self):
|
|
r"""auxDeviceCount(Inventory self) -> size_t"""
|
|
return _datamodel.Inventory_auxDeviceCount(self)
|
|
|
|
def sensorCount(self):
|
|
r"""sensorCount(Inventory self) -> size_t"""
|
|
return _datamodel.Inventory_sensorCount(self)
|
|
|
|
def dataloggerCount(self):
|
|
r"""dataloggerCount(Inventory self) -> size_t"""
|
|
return _datamodel.Inventory_dataloggerCount(self)
|
|
|
|
def responsePAZCount(self):
|
|
r"""responsePAZCount(Inventory self) -> size_t"""
|
|
return _datamodel.Inventory_responsePAZCount(self)
|
|
|
|
def responseFIRCount(self):
|
|
r"""responseFIRCount(Inventory self) -> size_t"""
|
|
return _datamodel.Inventory_responseFIRCount(self)
|
|
|
|
def responseIIRCount(self):
|
|
r"""responseIIRCount(Inventory self) -> size_t"""
|
|
return _datamodel.Inventory_responseIIRCount(self)
|
|
|
|
def responsePolynomialCount(self):
|
|
r"""responsePolynomialCount(Inventory self) -> size_t"""
|
|
return _datamodel.Inventory_responsePolynomialCount(self)
|
|
|
|
def responseFAPCount(self):
|
|
r"""responseFAPCount(Inventory self) -> size_t"""
|
|
return _datamodel.Inventory_responseFAPCount(self)
|
|
|
|
def networkCount(self):
|
|
r"""networkCount(Inventory self) -> size_t"""
|
|
return _datamodel.Inventory_networkCount(self)
|
|
|
|
def stationGroup(self, *args):
|
|
r"""
|
|
stationGroup(Inventory self, size_t i) -> StationGroup
|
|
stationGroup(Inventory self, StationGroupIndex i) -> StationGroup
|
|
"""
|
|
return _datamodel.Inventory_stationGroup(self, *args)
|
|
|
|
def auxDevice(self, *args):
|
|
r"""
|
|
auxDevice(Inventory self, size_t i) -> AuxDevice
|
|
auxDevice(Inventory self, AuxDeviceIndex i) -> AuxDevice
|
|
"""
|
|
return _datamodel.Inventory_auxDevice(self, *args)
|
|
|
|
def sensor(self, *args):
|
|
r"""
|
|
sensor(Inventory self, size_t i) -> Sensor
|
|
sensor(Inventory self, SensorIndex i) -> Sensor
|
|
"""
|
|
return _datamodel.Inventory_sensor(self, *args)
|
|
|
|
def datalogger(self, *args):
|
|
r"""
|
|
datalogger(Inventory self, size_t i) -> Datalogger
|
|
datalogger(Inventory self, DataloggerIndex i) -> Datalogger
|
|
"""
|
|
return _datamodel.Inventory_datalogger(self, *args)
|
|
|
|
def responsePAZ(self, *args):
|
|
r"""
|
|
responsePAZ(Inventory self, size_t i) -> ResponsePAZ
|
|
responsePAZ(Inventory self, ResponsePAZIndex i) -> ResponsePAZ
|
|
"""
|
|
return _datamodel.Inventory_responsePAZ(self, *args)
|
|
|
|
def responseFIR(self, *args):
|
|
r"""
|
|
responseFIR(Inventory self, size_t i) -> ResponseFIR
|
|
responseFIR(Inventory self, ResponseFIRIndex i) -> ResponseFIR
|
|
"""
|
|
return _datamodel.Inventory_responseFIR(self, *args)
|
|
|
|
def responseIIR(self, *args):
|
|
r"""
|
|
responseIIR(Inventory self, size_t i) -> ResponseIIR
|
|
responseIIR(Inventory self, ResponseIIRIndex i) -> ResponseIIR
|
|
"""
|
|
return _datamodel.Inventory_responseIIR(self, *args)
|
|
|
|
def responsePolynomial(self, *args):
|
|
r"""
|
|
responsePolynomial(Inventory self, size_t i) -> ResponsePolynomial
|
|
responsePolynomial(Inventory self, ResponsePolynomialIndex i) -> ResponsePolynomial
|
|
"""
|
|
return _datamodel.Inventory_responsePolynomial(self, *args)
|
|
|
|
def responseFAP(self, *args):
|
|
r"""
|
|
responseFAP(Inventory self, size_t i) -> ResponseFAP
|
|
responseFAP(Inventory self, ResponseFAPIndex i) -> ResponseFAP
|
|
"""
|
|
return _datamodel.Inventory_responseFAP(self, *args)
|
|
|
|
def network(self, *args):
|
|
r"""
|
|
network(Inventory self, size_t i) -> Network
|
|
network(Inventory self, NetworkIndex i) -> Network
|
|
"""
|
|
return _datamodel.Inventory_network(self, *args)
|
|
|
|
def findStationGroup(self, publicID):
|
|
r"""findStationGroup(Inventory self, std::string const & publicID) -> StationGroup"""
|
|
return _datamodel.Inventory_findStationGroup(self, publicID)
|
|
|
|
def findAuxDevice(self, publicID):
|
|
r"""findAuxDevice(Inventory self, std::string const & publicID) -> AuxDevice"""
|
|
return _datamodel.Inventory_findAuxDevice(self, publicID)
|
|
|
|
def findSensor(self, publicID):
|
|
r"""findSensor(Inventory self, std::string const & publicID) -> Sensor"""
|
|
return _datamodel.Inventory_findSensor(self, publicID)
|
|
|
|
def findDatalogger(self, publicID):
|
|
r"""findDatalogger(Inventory self, std::string const & publicID) -> Datalogger"""
|
|
return _datamodel.Inventory_findDatalogger(self, publicID)
|
|
|
|
def findResponsePAZ(self, publicID):
|
|
r"""findResponsePAZ(Inventory self, std::string const & publicID) -> ResponsePAZ"""
|
|
return _datamodel.Inventory_findResponsePAZ(self, publicID)
|
|
|
|
def findResponseFIR(self, publicID):
|
|
r"""findResponseFIR(Inventory self, std::string const & publicID) -> ResponseFIR"""
|
|
return _datamodel.Inventory_findResponseFIR(self, publicID)
|
|
|
|
def findResponseIIR(self, publicID):
|
|
r"""findResponseIIR(Inventory self, std::string const & publicID) -> ResponseIIR"""
|
|
return _datamodel.Inventory_findResponseIIR(self, publicID)
|
|
|
|
def findResponsePolynomial(self, publicID):
|
|
r"""findResponsePolynomial(Inventory self, std::string const & publicID) -> ResponsePolynomial"""
|
|
return _datamodel.Inventory_findResponsePolynomial(self, publicID)
|
|
|
|
def findResponseFAP(self, publicID):
|
|
r"""findResponseFAP(Inventory self, std::string const & publicID) -> ResponseFAP"""
|
|
return _datamodel.Inventory_findResponseFAP(self, publicID)
|
|
|
|
def findNetwork(self, publicID):
|
|
r"""findNetwork(Inventory self, std::string const & publicID) -> Network"""
|
|
return _datamodel.Inventory_findNetwork(self, publicID)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Inventory self, Object other) -> bool"""
|
|
return _datamodel.Inventory_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Inventory self, PublicObject parent) -> bool"""
|
|
return _datamodel.Inventory_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Inventory self, PublicObject parent) -> bool"""
|
|
return _datamodel.Inventory_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Inventory self) -> bool"""
|
|
return _datamodel.Inventory_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Inventory self) -> Object"""
|
|
return _datamodel.Inventory_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Inventory self, Object child) -> bool"""
|
|
return _datamodel.Inventory_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Inventory self, Visitor visitor)"""
|
|
return _datamodel.Inventory_accept(self, visitor)
|
|
|
|
# Register Inventory in _datamodel:
|
|
_datamodel.Inventory_swigregister(Inventory)
|
|
|
|
def Inventory_ClassName():
|
|
r"""Inventory_ClassName() -> char const *"""
|
|
return _datamodel.Inventory_ClassName()
|
|
|
|
def Inventory_TypeInfo():
|
|
r"""Inventory_TypeInfo() -> RTTI"""
|
|
return _datamodel.Inventory_TypeInfo()
|
|
|
|
def Inventory_Cast(*args):
|
|
r"""
|
|
Inventory_Cast(BaseObject o) -> Inventory
|
|
Inventory_Cast(Seiscomp::Core::BaseObjectPtr o) -> Inventory
|
|
"""
|
|
return _datamodel.Inventory_Cast(*args)
|
|
|
|
def Inventory_ConstCast(*args):
|
|
r"""
|
|
Inventory_ConstCast(BaseObject o) -> Inventory
|
|
Inventory_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Inventory
|
|
"""
|
|
return _datamodel.Inventory_ConstCast(*args)
|
|
|
|
def Inventory_Meta():
|
|
r"""Inventory_Meta() -> MetaObject"""
|
|
return _datamodel.Inventory_Meta()
|
|
|
|
class RouteArclinkIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::RouteArclinkIndex 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__(RouteArclinkIndex self) -> RouteArclinkIndex
|
|
__init__(RouteArclinkIndex self, std::string const & address, Time start) -> RouteArclinkIndex
|
|
__init__(RouteArclinkIndex self, RouteArclinkIndex arg2) -> RouteArclinkIndex
|
|
"""
|
|
_datamodel.RouteArclinkIndex_swiginit(self, _datamodel.new_RouteArclinkIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(RouteArclinkIndex self, RouteArclinkIndex arg2) -> bool"""
|
|
return _datamodel.RouteArclinkIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(RouteArclinkIndex self, RouteArclinkIndex arg2) -> bool"""
|
|
return _datamodel.RouteArclinkIndex___ne__(self, arg2)
|
|
address = property(_datamodel.RouteArclinkIndex_address_get, _datamodel.RouteArclinkIndex_address_set, doc=r"""address : std::string""")
|
|
start = property(_datamodel.RouteArclinkIndex_start_get, _datamodel.RouteArclinkIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
|
|
__swig_destroy__ = _datamodel.delete_RouteArclinkIndex
|
|
|
|
# Register RouteArclinkIndex in _datamodel:
|
|
_datamodel.RouteArclinkIndex_swigregister(RouteArclinkIndex)
|
|
|
|
class RouteArclink(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::RouteArclink 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 _datamodel.RouteArclink_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.RouteArclink_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(RouteArclink self) -> char const *"""
|
|
return _datamodel.RouteArclink_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(RouteArclink self) -> RTTI"""
|
|
return _datamodel.RouteArclink_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> RouteArclink
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> RouteArclink
|
|
"""
|
|
return _datamodel.RouteArclink_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> RouteArclink
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RouteArclink
|
|
"""
|
|
return _datamodel.RouteArclink_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(RouteArclink self, GenericArchive ar)"""
|
|
return _datamodel.RouteArclink_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.RouteArclink_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(RouteArclink self) -> MetaObject"""
|
|
return _datamodel.RouteArclink_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(RouteArclink self) -> RouteArclink
|
|
__init__(RouteArclink self, RouteArclink other) -> RouteArclink
|
|
"""
|
|
_datamodel.RouteArclink_swiginit(self, _datamodel.new_RouteArclink(*args))
|
|
__swig_destroy__ = _datamodel.delete_RouteArclink
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(RouteArclink self, RouteArclink other) -> bool"""
|
|
return _datamodel.RouteArclink___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(RouteArclink self, RouteArclink other) -> bool"""
|
|
return _datamodel.RouteArclink___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(RouteArclink self, RouteArclink other) -> bool"""
|
|
return _datamodel.RouteArclink_equal(self, other)
|
|
|
|
def setAddress(self, address):
|
|
r"""setAddress(RouteArclink self, std::string const & address)"""
|
|
return _datamodel.RouteArclink_setAddress(self, address)
|
|
|
|
def address(self):
|
|
r"""address(RouteArclink self) -> std::string const &"""
|
|
return _datamodel.RouteArclink_address(self)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(RouteArclink self, Time start)"""
|
|
return _datamodel.RouteArclink_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(RouteArclink self) -> Time"""
|
|
return _datamodel.RouteArclink_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(RouteArclink self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
|
|
return _datamodel.RouteArclink_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(RouteArclink self) -> Time"""
|
|
return _datamodel.RouteArclink_end(self)
|
|
|
|
def setPriority(self, priority):
|
|
r"""setPriority(RouteArclink self, Seiscomp::Core::Optional< int >::Impl const & priority)"""
|
|
return _datamodel.RouteArclink_setPriority(self, priority)
|
|
|
|
def priority(self):
|
|
r"""priority(RouteArclink self) -> int"""
|
|
return _datamodel.RouteArclink_priority(self)
|
|
|
|
def index(self):
|
|
r"""index(RouteArclink self) -> RouteArclinkIndex"""
|
|
return _datamodel.RouteArclink_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(RouteArclink self, RouteArclink lhs) -> bool"""
|
|
return _datamodel.RouteArclink_equalIndex(self, lhs)
|
|
|
|
def route(self):
|
|
r"""route(RouteArclink self) -> Route"""
|
|
return _datamodel.RouteArclink_route(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(RouteArclink self, Object other) -> bool"""
|
|
return _datamodel.RouteArclink_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(RouteArclink self, PublicObject parent) -> bool"""
|
|
return _datamodel.RouteArclink_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(RouteArclink self, PublicObject parent) -> bool"""
|
|
return _datamodel.RouteArclink_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(RouteArclink self) -> bool"""
|
|
return _datamodel.RouteArclink_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(RouteArclink self) -> Object"""
|
|
return _datamodel.RouteArclink_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(RouteArclink self, Visitor visitor)"""
|
|
return _datamodel.RouteArclink_accept(self, visitor)
|
|
|
|
# Register RouteArclink in _datamodel:
|
|
_datamodel.RouteArclink_swigregister(RouteArclink)
|
|
|
|
def RouteArclink_ClassName():
|
|
r"""RouteArclink_ClassName() -> char const *"""
|
|
return _datamodel.RouteArclink_ClassName()
|
|
|
|
def RouteArclink_TypeInfo():
|
|
r"""RouteArclink_TypeInfo() -> RTTI"""
|
|
return _datamodel.RouteArclink_TypeInfo()
|
|
|
|
def RouteArclink_Cast(*args):
|
|
r"""
|
|
RouteArclink_Cast(BaseObject o) -> RouteArclink
|
|
RouteArclink_Cast(Seiscomp::Core::BaseObjectPtr o) -> RouteArclink
|
|
"""
|
|
return _datamodel.RouteArclink_Cast(*args)
|
|
|
|
def RouteArclink_ConstCast(*args):
|
|
r"""
|
|
RouteArclink_ConstCast(BaseObject o) -> RouteArclink
|
|
RouteArclink_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RouteArclink
|
|
"""
|
|
return _datamodel.RouteArclink_ConstCast(*args)
|
|
|
|
def RouteArclink_Meta():
|
|
r"""RouteArclink_Meta() -> MetaObject"""
|
|
return _datamodel.RouteArclink_Meta()
|
|
|
|
class RouteSeedlinkIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::RouteSeedlinkIndex 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__(RouteSeedlinkIndex self) -> RouteSeedlinkIndex
|
|
__init__(RouteSeedlinkIndex self, std::string const & address) -> RouteSeedlinkIndex
|
|
__init__(RouteSeedlinkIndex self, RouteSeedlinkIndex arg2) -> RouteSeedlinkIndex
|
|
"""
|
|
_datamodel.RouteSeedlinkIndex_swiginit(self, _datamodel.new_RouteSeedlinkIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(RouteSeedlinkIndex self, RouteSeedlinkIndex arg2) -> bool"""
|
|
return _datamodel.RouteSeedlinkIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(RouteSeedlinkIndex self, RouteSeedlinkIndex arg2) -> bool"""
|
|
return _datamodel.RouteSeedlinkIndex___ne__(self, arg2)
|
|
address = property(_datamodel.RouteSeedlinkIndex_address_get, _datamodel.RouteSeedlinkIndex_address_set, doc=r"""address : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_RouteSeedlinkIndex
|
|
|
|
# Register RouteSeedlinkIndex in _datamodel:
|
|
_datamodel.RouteSeedlinkIndex_swigregister(RouteSeedlinkIndex)
|
|
|
|
class RouteSeedlink(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::RouteSeedlink 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 _datamodel.RouteSeedlink_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.RouteSeedlink_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(RouteSeedlink self) -> char const *"""
|
|
return _datamodel.RouteSeedlink_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(RouteSeedlink self) -> RTTI"""
|
|
return _datamodel.RouteSeedlink_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> RouteSeedlink
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> RouteSeedlink
|
|
"""
|
|
return _datamodel.RouteSeedlink_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> RouteSeedlink
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RouteSeedlink
|
|
"""
|
|
return _datamodel.RouteSeedlink_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(RouteSeedlink self, GenericArchive ar)"""
|
|
return _datamodel.RouteSeedlink_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.RouteSeedlink_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(RouteSeedlink self) -> MetaObject"""
|
|
return _datamodel.RouteSeedlink_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(RouteSeedlink self) -> RouteSeedlink
|
|
__init__(RouteSeedlink self, RouteSeedlink other) -> RouteSeedlink
|
|
"""
|
|
_datamodel.RouteSeedlink_swiginit(self, _datamodel.new_RouteSeedlink(*args))
|
|
__swig_destroy__ = _datamodel.delete_RouteSeedlink
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(RouteSeedlink self, RouteSeedlink other) -> bool"""
|
|
return _datamodel.RouteSeedlink___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(RouteSeedlink self, RouteSeedlink other) -> bool"""
|
|
return _datamodel.RouteSeedlink___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(RouteSeedlink self, RouteSeedlink other) -> bool"""
|
|
return _datamodel.RouteSeedlink_equal(self, other)
|
|
|
|
def setAddress(self, address):
|
|
r"""setAddress(RouteSeedlink self, std::string const & address)"""
|
|
return _datamodel.RouteSeedlink_setAddress(self, address)
|
|
|
|
def address(self):
|
|
r"""address(RouteSeedlink self) -> std::string const &"""
|
|
return _datamodel.RouteSeedlink_address(self)
|
|
|
|
def setPriority(self, priority):
|
|
r"""setPriority(RouteSeedlink self, Seiscomp::Core::Optional< int >::Impl const & priority)"""
|
|
return _datamodel.RouteSeedlink_setPriority(self, priority)
|
|
|
|
def priority(self):
|
|
r"""priority(RouteSeedlink self) -> int"""
|
|
return _datamodel.RouteSeedlink_priority(self)
|
|
|
|
def index(self):
|
|
r"""index(RouteSeedlink self) -> RouteSeedlinkIndex"""
|
|
return _datamodel.RouteSeedlink_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(RouteSeedlink self, RouteSeedlink lhs) -> bool"""
|
|
return _datamodel.RouteSeedlink_equalIndex(self, lhs)
|
|
|
|
def route(self):
|
|
r"""route(RouteSeedlink self) -> Route"""
|
|
return _datamodel.RouteSeedlink_route(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(RouteSeedlink self, Object other) -> bool"""
|
|
return _datamodel.RouteSeedlink_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(RouteSeedlink self, PublicObject parent) -> bool"""
|
|
return _datamodel.RouteSeedlink_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(RouteSeedlink self, PublicObject parent) -> bool"""
|
|
return _datamodel.RouteSeedlink_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(RouteSeedlink self) -> bool"""
|
|
return _datamodel.RouteSeedlink_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(RouteSeedlink self) -> Object"""
|
|
return _datamodel.RouteSeedlink_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(RouteSeedlink self, Visitor visitor)"""
|
|
return _datamodel.RouteSeedlink_accept(self, visitor)
|
|
|
|
# Register RouteSeedlink in _datamodel:
|
|
_datamodel.RouteSeedlink_swigregister(RouteSeedlink)
|
|
|
|
def RouteSeedlink_ClassName():
|
|
r"""RouteSeedlink_ClassName() -> char const *"""
|
|
return _datamodel.RouteSeedlink_ClassName()
|
|
|
|
def RouteSeedlink_TypeInfo():
|
|
r"""RouteSeedlink_TypeInfo() -> RTTI"""
|
|
return _datamodel.RouteSeedlink_TypeInfo()
|
|
|
|
def RouteSeedlink_Cast(*args):
|
|
r"""
|
|
RouteSeedlink_Cast(BaseObject o) -> RouteSeedlink
|
|
RouteSeedlink_Cast(Seiscomp::Core::BaseObjectPtr o) -> RouteSeedlink
|
|
"""
|
|
return _datamodel.RouteSeedlink_Cast(*args)
|
|
|
|
def RouteSeedlink_ConstCast(*args):
|
|
r"""
|
|
RouteSeedlink_ConstCast(BaseObject o) -> RouteSeedlink
|
|
RouteSeedlink_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RouteSeedlink
|
|
"""
|
|
return _datamodel.RouteSeedlink_ConstCast(*args)
|
|
|
|
def RouteSeedlink_Meta():
|
|
r"""RouteSeedlink_Meta() -> MetaObject"""
|
|
return _datamodel.RouteSeedlink_Meta()
|
|
|
|
class RouteIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::RouteIndex 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__(RouteIndex self) -> RouteIndex
|
|
__init__(RouteIndex self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & streamCode) -> RouteIndex
|
|
__init__(RouteIndex self, RouteIndex arg2) -> RouteIndex
|
|
"""
|
|
_datamodel.RouteIndex_swiginit(self, _datamodel.new_RouteIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(RouteIndex self, RouteIndex arg2) -> bool"""
|
|
return _datamodel.RouteIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(RouteIndex self, RouteIndex arg2) -> bool"""
|
|
return _datamodel.RouteIndex___ne__(self, arg2)
|
|
networkCode = property(_datamodel.RouteIndex_networkCode_get, _datamodel.RouteIndex_networkCode_set, doc=r"""networkCode : std::string""")
|
|
stationCode = property(_datamodel.RouteIndex_stationCode_get, _datamodel.RouteIndex_stationCode_set, doc=r"""stationCode : std::string""")
|
|
locationCode = property(_datamodel.RouteIndex_locationCode_get, _datamodel.RouteIndex_locationCode_set, doc=r"""locationCode : std::string""")
|
|
streamCode = property(_datamodel.RouteIndex_streamCode_get, _datamodel.RouteIndex_streamCode_set, doc=r"""streamCode : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_RouteIndex
|
|
|
|
# Register RouteIndex in _datamodel:
|
|
_datamodel.RouteIndex_swigregister(RouteIndex)
|
|
|
|
class Route(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Route 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 _datamodel.Route_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Route_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Route self) -> char const *"""
|
|
return _datamodel.Route_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Route self) -> RTTI"""
|
|
return _datamodel.Route_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Route
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Route
|
|
"""
|
|
return _datamodel.Route_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Route
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Route
|
|
"""
|
|
return _datamodel.Route_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Route self, GenericArchive ar)"""
|
|
return _datamodel.Route_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Route_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Route self) -> MetaObject"""
|
|
return _datamodel.Route_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Route self, Route other) -> Route
|
|
__init__(Route self, std::string const & publicID) -> Route
|
|
"""
|
|
_datamodel.Route_swiginit(self, _datamodel.new_Route(*args))
|
|
__swig_destroy__ = _datamodel.delete_Route
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> Route
|
|
Create(std::string const & publicID) -> Route
|
|
"""
|
|
return _datamodel.Route_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> Route"""
|
|
return _datamodel.Route_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Route self, Route other) -> bool"""
|
|
return _datamodel.Route___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Route self, Route other) -> bool"""
|
|
return _datamodel.Route___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Route self, Route other) -> bool"""
|
|
return _datamodel.Route_equal(self, other)
|
|
|
|
def setNetworkCode(self, networkCode):
|
|
r"""setNetworkCode(Route self, std::string const & networkCode)"""
|
|
return _datamodel.Route_setNetworkCode(self, networkCode)
|
|
|
|
def networkCode(self):
|
|
r"""networkCode(Route self) -> std::string const &"""
|
|
return _datamodel.Route_networkCode(self)
|
|
|
|
def setStationCode(self, stationCode):
|
|
r"""setStationCode(Route self, std::string const & stationCode)"""
|
|
return _datamodel.Route_setStationCode(self, stationCode)
|
|
|
|
def stationCode(self):
|
|
r"""stationCode(Route self) -> std::string const &"""
|
|
return _datamodel.Route_stationCode(self)
|
|
|
|
def setLocationCode(self, locationCode):
|
|
r"""setLocationCode(Route self, std::string const & locationCode)"""
|
|
return _datamodel.Route_setLocationCode(self, locationCode)
|
|
|
|
def locationCode(self):
|
|
r"""locationCode(Route self) -> std::string const &"""
|
|
return _datamodel.Route_locationCode(self)
|
|
|
|
def setStreamCode(self, streamCode):
|
|
r"""setStreamCode(Route self, std::string const & streamCode)"""
|
|
return _datamodel.Route_setStreamCode(self, streamCode)
|
|
|
|
def streamCode(self):
|
|
r"""streamCode(Route self) -> std::string const &"""
|
|
return _datamodel.Route_streamCode(self)
|
|
|
|
def index(self):
|
|
r"""index(Route self) -> RouteIndex"""
|
|
return _datamodel.Route_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(Route self, Route lhs) -> bool"""
|
|
return _datamodel.Route_equalIndex(self, lhs)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(Route self, RouteArclink obj) -> bool
|
|
add(Route self, RouteSeedlink obj) -> bool
|
|
"""
|
|
return _datamodel.Route_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(Route self, RouteArclink obj) -> bool
|
|
remove(Route self, RouteSeedlink obj) -> bool
|
|
"""
|
|
return _datamodel.Route_remove(self, *args)
|
|
|
|
def removeRouteArclink(self, *args):
|
|
r"""
|
|
removeRouteArclink(Route self, size_t i) -> bool
|
|
removeRouteArclink(Route self, RouteArclinkIndex i) -> bool
|
|
"""
|
|
return _datamodel.Route_removeRouteArclink(self, *args)
|
|
|
|
def removeRouteSeedlink(self, *args):
|
|
r"""
|
|
removeRouteSeedlink(Route self, size_t i) -> bool
|
|
removeRouteSeedlink(Route self, RouteSeedlinkIndex i) -> bool
|
|
"""
|
|
return _datamodel.Route_removeRouteSeedlink(self, *args)
|
|
|
|
def routeArclinkCount(self):
|
|
r"""routeArclinkCount(Route self) -> size_t"""
|
|
return _datamodel.Route_routeArclinkCount(self)
|
|
|
|
def routeSeedlinkCount(self):
|
|
r"""routeSeedlinkCount(Route self) -> size_t"""
|
|
return _datamodel.Route_routeSeedlinkCount(self)
|
|
|
|
def routeArclink(self, *args):
|
|
r"""
|
|
routeArclink(Route self, size_t i) -> RouteArclink
|
|
routeArclink(Route self, RouteArclinkIndex i) -> RouteArclink
|
|
"""
|
|
return _datamodel.Route_routeArclink(self, *args)
|
|
|
|
def routeSeedlink(self, *args):
|
|
r"""
|
|
routeSeedlink(Route self, size_t i) -> RouteSeedlink
|
|
routeSeedlink(Route self, RouteSeedlinkIndex i) -> RouteSeedlink
|
|
"""
|
|
return _datamodel.Route_routeSeedlink(self, *args)
|
|
|
|
def routing(self):
|
|
r"""routing(Route self) -> Routing"""
|
|
return _datamodel.Route_routing(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Route self, Object other) -> bool"""
|
|
return _datamodel.Route_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Route self, PublicObject parent) -> bool"""
|
|
return _datamodel.Route_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Route self, PublicObject parent) -> bool"""
|
|
return _datamodel.Route_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Route self) -> bool"""
|
|
return _datamodel.Route_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Route self) -> Object"""
|
|
return _datamodel.Route_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Route self, Object child) -> bool"""
|
|
return _datamodel.Route_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Route self, Visitor visitor)"""
|
|
return _datamodel.Route_accept(self, visitor)
|
|
|
|
# Register Route in _datamodel:
|
|
_datamodel.Route_swigregister(Route)
|
|
|
|
def Route_ClassName():
|
|
r"""Route_ClassName() -> char const *"""
|
|
return _datamodel.Route_ClassName()
|
|
|
|
def Route_TypeInfo():
|
|
r"""Route_TypeInfo() -> RTTI"""
|
|
return _datamodel.Route_TypeInfo()
|
|
|
|
def Route_Cast(*args):
|
|
r"""
|
|
Route_Cast(BaseObject o) -> Route
|
|
Route_Cast(Seiscomp::Core::BaseObjectPtr o) -> Route
|
|
"""
|
|
return _datamodel.Route_Cast(*args)
|
|
|
|
def Route_ConstCast(*args):
|
|
r"""
|
|
Route_ConstCast(BaseObject o) -> Route
|
|
Route_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Route
|
|
"""
|
|
return _datamodel.Route_ConstCast(*args)
|
|
|
|
def Route_Meta():
|
|
r"""Route_Meta() -> MetaObject"""
|
|
return _datamodel.Route_Meta()
|
|
|
|
def Route_Create(*args):
|
|
r"""
|
|
Route_Create() -> Route
|
|
Route_Create(std::string const & publicID) -> Route
|
|
"""
|
|
return _datamodel.Route_Create(*args)
|
|
|
|
def Route_Find(publicID):
|
|
r"""Route_Find(std::string const & publicID) -> Route"""
|
|
return _datamodel.Route_Find(publicID)
|
|
|
|
class AccessIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::AccessIndex 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__(AccessIndex self) -> AccessIndex
|
|
__init__(AccessIndex self, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & streamCode, std::string const & user, Time start) -> AccessIndex
|
|
__init__(AccessIndex self, AccessIndex arg2) -> AccessIndex
|
|
"""
|
|
_datamodel.AccessIndex_swiginit(self, _datamodel.new_AccessIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(AccessIndex self, AccessIndex arg2) -> bool"""
|
|
return _datamodel.AccessIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(AccessIndex self, AccessIndex arg2) -> bool"""
|
|
return _datamodel.AccessIndex___ne__(self, arg2)
|
|
networkCode = property(_datamodel.AccessIndex_networkCode_get, _datamodel.AccessIndex_networkCode_set, doc=r"""networkCode : std::string""")
|
|
stationCode = property(_datamodel.AccessIndex_stationCode_get, _datamodel.AccessIndex_stationCode_set, doc=r"""stationCode : std::string""")
|
|
locationCode = property(_datamodel.AccessIndex_locationCode_get, _datamodel.AccessIndex_locationCode_set, doc=r"""locationCode : std::string""")
|
|
streamCode = property(_datamodel.AccessIndex_streamCode_get, _datamodel.AccessIndex_streamCode_set, doc=r"""streamCode : std::string""")
|
|
user = property(_datamodel.AccessIndex_user_get, _datamodel.AccessIndex_user_set, doc=r"""user : std::string""")
|
|
start = property(_datamodel.AccessIndex_start_get, _datamodel.AccessIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
|
|
__swig_destroy__ = _datamodel.delete_AccessIndex
|
|
|
|
# Register AccessIndex in _datamodel:
|
|
_datamodel.AccessIndex_swigregister(AccessIndex)
|
|
|
|
class Access(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Access 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 _datamodel.Access_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Access_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Access self) -> char const *"""
|
|
return _datamodel.Access_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Access self) -> RTTI"""
|
|
return _datamodel.Access_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Access
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Access
|
|
"""
|
|
return _datamodel.Access_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Access
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Access
|
|
"""
|
|
return _datamodel.Access_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Access self, GenericArchive ar)"""
|
|
return _datamodel.Access_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Access_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Access self) -> MetaObject"""
|
|
return _datamodel.Access_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Access self) -> Access
|
|
__init__(Access self, Access other) -> Access
|
|
"""
|
|
_datamodel.Access_swiginit(self, _datamodel.new_Access(*args))
|
|
__swig_destroy__ = _datamodel.delete_Access
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Access self, Access other) -> bool"""
|
|
return _datamodel.Access___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Access self, Access other) -> bool"""
|
|
return _datamodel.Access___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Access self, Access other) -> bool"""
|
|
return _datamodel.Access_equal(self, other)
|
|
|
|
def setNetworkCode(self, networkCode):
|
|
r"""setNetworkCode(Access self, std::string const & networkCode)"""
|
|
return _datamodel.Access_setNetworkCode(self, networkCode)
|
|
|
|
def networkCode(self):
|
|
r"""networkCode(Access self) -> std::string const &"""
|
|
return _datamodel.Access_networkCode(self)
|
|
|
|
def setStationCode(self, stationCode):
|
|
r"""setStationCode(Access self, std::string const & stationCode)"""
|
|
return _datamodel.Access_setStationCode(self, stationCode)
|
|
|
|
def stationCode(self):
|
|
r"""stationCode(Access self) -> std::string const &"""
|
|
return _datamodel.Access_stationCode(self)
|
|
|
|
def setLocationCode(self, locationCode):
|
|
r"""setLocationCode(Access self, std::string const & locationCode)"""
|
|
return _datamodel.Access_setLocationCode(self, locationCode)
|
|
|
|
def locationCode(self):
|
|
r"""locationCode(Access self) -> std::string const &"""
|
|
return _datamodel.Access_locationCode(self)
|
|
|
|
def setStreamCode(self, streamCode):
|
|
r"""setStreamCode(Access self, std::string const & streamCode)"""
|
|
return _datamodel.Access_setStreamCode(self, streamCode)
|
|
|
|
def streamCode(self):
|
|
r"""streamCode(Access self) -> std::string const &"""
|
|
return _datamodel.Access_streamCode(self)
|
|
|
|
def setUser(self, user):
|
|
r"""setUser(Access self, std::string const & user)"""
|
|
return _datamodel.Access_setUser(self, user)
|
|
|
|
def user(self):
|
|
r"""user(Access self) -> std::string const &"""
|
|
return _datamodel.Access_user(self)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(Access self, Time start)"""
|
|
return _datamodel.Access_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(Access self) -> Time"""
|
|
return _datamodel.Access_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(Access self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & end)"""
|
|
return _datamodel.Access_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(Access self) -> Time"""
|
|
return _datamodel.Access_end(self)
|
|
|
|
def index(self):
|
|
r"""index(Access self) -> AccessIndex"""
|
|
return _datamodel.Access_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(Access self, Access lhs) -> bool"""
|
|
return _datamodel.Access_equalIndex(self, lhs)
|
|
|
|
def routing(self):
|
|
r"""routing(Access self) -> Routing"""
|
|
return _datamodel.Access_routing(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Access self, Object other) -> bool"""
|
|
return _datamodel.Access_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Access self, PublicObject parent) -> bool"""
|
|
return _datamodel.Access_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Access self, PublicObject parent) -> bool"""
|
|
return _datamodel.Access_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Access self) -> bool"""
|
|
return _datamodel.Access_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Access self) -> Object"""
|
|
return _datamodel.Access_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Access self, Visitor visitor)"""
|
|
return _datamodel.Access_accept(self, visitor)
|
|
|
|
# Register Access in _datamodel:
|
|
_datamodel.Access_swigregister(Access)
|
|
|
|
def Access_ClassName():
|
|
r"""Access_ClassName() -> char const *"""
|
|
return _datamodel.Access_ClassName()
|
|
|
|
def Access_TypeInfo():
|
|
r"""Access_TypeInfo() -> RTTI"""
|
|
return _datamodel.Access_TypeInfo()
|
|
|
|
def Access_Cast(*args):
|
|
r"""
|
|
Access_Cast(BaseObject o) -> Access
|
|
Access_Cast(Seiscomp::Core::BaseObjectPtr o) -> Access
|
|
"""
|
|
return _datamodel.Access_Cast(*args)
|
|
|
|
def Access_ConstCast(*args):
|
|
r"""
|
|
Access_ConstCast(BaseObject o) -> Access
|
|
Access_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Access
|
|
"""
|
|
return _datamodel.Access_ConstCast(*args)
|
|
|
|
def Access_Meta():
|
|
r"""Access_Meta() -> MetaObject"""
|
|
return _datamodel.Access_Meta()
|
|
|
|
class Routing(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Routing 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 _datamodel.Routing_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Routing_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Routing self) -> char const *"""
|
|
return _datamodel.Routing_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Routing self) -> RTTI"""
|
|
return _datamodel.Routing_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Routing
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Routing
|
|
"""
|
|
return _datamodel.Routing_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Routing
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Routing
|
|
"""
|
|
return _datamodel.Routing_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Routing self, GenericArchive ar)"""
|
|
return _datamodel.Routing_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Routing_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Routing self) -> MetaObject"""
|
|
return _datamodel.Routing_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Routing self) -> Routing
|
|
__init__(Routing self, Routing other) -> Routing
|
|
"""
|
|
_datamodel.Routing_swiginit(self, _datamodel.new_Routing(*args))
|
|
__swig_destroy__ = _datamodel.delete_Routing
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Routing self, Routing other) -> bool"""
|
|
return _datamodel.Routing___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Routing self, Routing other) -> bool"""
|
|
return _datamodel.Routing___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Routing self, Routing other) -> bool"""
|
|
return _datamodel.Routing_equal(self, other)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(Routing self, Route obj) -> bool
|
|
add(Routing self, Access obj) -> bool
|
|
"""
|
|
return _datamodel.Routing_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(Routing self, Route obj) -> bool
|
|
remove(Routing self, Access obj) -> bool
|
|
"""
|
|
return _datamodel.Routing_remove(self, *args)
|
|
|
|
def removeRoute(self, *args):
|
|
r"""
|
|
removeRoute(Routing self, size_t i) -> bool
|
|
removeRoute(Routing self, RouteIndex i) -> bool
|
|
"""
|
|
return _datamodel.Routing_removeRoute(self, *args)
|
|
|
|
def removeAccess(self, *args):
|
|
r"""
|
|
removeAccess(Routing self, size_t i) -> bool
|
|
removeAccess(Routing self, AccessIndex i) -> bool
|
|
"""
|
|
return _datamodel.Routing_removeAccess(self, *args)
|
|
|
|
def routeCount(self):
|
|
r"""routeCount(Routing self) -> size_t"""
|
|
return _datamodel.Routing_routeCount(self)
|
|
|
|
def accessCount(self):
|
|
r"""accessCount(Routing self) -> size_t"""
|
|
return _datamodel.Routing_accessCount(self)
|
|
|
|
def route(self, *args):
|
|
r"""
|
|
route(Routing self, size_t i) -> Route
|
|
route(Routing self, RouteIndex i) -> Route
|
|
"""
|
|
return _datamodel.Routing_route(self, *args)
|
|
|
|
def access(self, *args):
|
|
r"""
|
|
access(Routing self, size_t i) -> Access
|
|
access(Routing self, AccessIndex i) -> Access
|
|
"""
|
|
return _datamodel.Routing_access(self, *args)
|
|
|
|
def findRoute(self, publicID):
|
|
r"""findRoute(Routing self, std::string const & publicID) -> Route"""
|
|
return _datamodel.Routing_findRoute(self, publicID)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Routing self, Object other) -> bool"""
|
|
return _datamodel.Routing_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Routing self, PublicObject parent) -> bool"""
|
|
return _datamodel.Routing_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Routing self, PublicObject parent) -> bool"""
|
|
return _datamodel.Routing_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Routing self) -> bool"""
|
|
return _datamodel.Routing_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Routing self) -> Object"""
|
|
return _datamodel.Routing_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Routing self, Object child) -> bool"""
|
|
return _datamodel.Routing_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Routing self, Visitor visitor)"""
|
|
return _datamodel.Routing_accept(self, visitor)
|
|
|
|
# Register Routing in _datamodel:
|
|
_datamodel.Routing_swigregister(Routing)
|
|
|
|
def Routing_ClassName():
|
|
r"""Routing_ClassName() -> char const *"""
|
|
return _datamodel.Routing_ClassName()
|
|
|
|
def Routing_TypeInfo():
|
|
r"""Routing_TypeInfo() -> RTTI"""
|
|
return _datamodel.Routing_TypeInfo()
|
|
|
|
def Routing_Cast(*args):
|
|
r"""
|
|
Routing_Cast(BaseObject o) -> Routing
|
|
Routing_Cast(Seiscomp::Core::BaseObjectPtr o) -> Routing
|
|
"""
|
|
return _datamodel.Routing_Cast(*args)
|
|
|
|
def Routing_ConstCast(*args):
|
|
r"""
|
|
Routing_ConstCast(BaseObject o) -> Routing
|
|
Routing_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Routing
|
|
"""
|
|
return _datamodel.Routing_ConstCast(*args)
|
|
|
|
def Routing_Meta():
|
|
r"""Routing_Meta() -> MetaObject"""
|
|
return _datamodel.Routing_Meta()
|
|
|
|
class JournalEntry(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::JournalEntry 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 _datamodel.JournalEntry_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.JournalEntry_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(JournalEntry self) -> char const *"""
|
|
return _datamodel.JournalEntry_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(JournalEntry self) -> RTTI"""
|
|
return _datamodel.JournalEntry_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> JournalEntry
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> JournalEntry
|
|
"""
|
|
return _datamodel.JournalEntry_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> JournalEntry
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> JournalEntry
|
|
"""
|
|
return _datamodel.JournalEntry_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(JournalEntry self, GenericArchive ar)"""
|
|
return _datamodel.JournalEntry_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.JournalEntry_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(JournalEntry self) -> MetaObject"""
|
|
return _datamodel.JournalEntry_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(JournalEntry self) -> JournalEntry
|
|
__init__(JournalEntry self, JournalEntry other) -> JournalEntry
|
|
"""
|
|
_datamodel.JournalEntry_swiginit(self, _datamodel.new_JournalEntry(*args))
|
|
__swig_destroy__ = _datamodel.delete_JournalEntry
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(JournalEntry self, JournalEntry other) -> bool"""
|
|
return _datamodel.JournalEntry___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(JournalEntry self, JournalEntry other) -> bool"""
|
|
return _datamodel.JournalEntry___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(JournalEntry self, JournalEntry other) -> bool"""
|
|
return _datamodel.JournalEntry_equal(self, other)
|
|
|
|
def setCreated(self, created):
|
|
r"""setCreated(JournalEntry self, Seiscomp::Core::Optional< Seiscomp::Core::Time >::Impl const & created)"""
|
|
return _datamodel.JournalEntry_setCreated(self, created)
|
|
|
|
def created(self):
|
|
r"""created(JournalEntry self) -> Time"""
|
|
return _datamodel.JournalEntry_created(self)
|
|
|
|
def setObjectID(self, objectID):
|
|
r"""setObjectID(JournalEntry self, std::string const & objectID)"""
|
|
return _datamodel.JournalEntry_setObjectID(self, objectID)
|
|
|
|
def objectID(self):
|
|
r"""objectID(JournalEntry self) -> std::string const &"""
|
|
return _datamodel.JournalEntry_objectID(self)
|
|
|
|
def setSender(self, sender):
|
|
r"""setSender(JournalEntry self, std::string const & sender)"""
|
|
return _datamodel.JournalEntry_setSender(self, sender)
|
|
|
|
def sender(self):
|
|
r"""sender(JournalEntry self) -> std::string const &"""
|
|
return _datamodel.JournalEntry_sender(self)
|
|
|
|
def setAction(self, action):
|
|
r"""setAction(JournalEntry self, std::string const & action)"""
|
|
return _datamodel.JournalEntry_setAction(self, action)
|
|
|
|
def action(self):
|
|
r"""action(JournalEntry self) -> std::string const &"""
|
|
return _datamodel.JournalEntry_action(self)
|
|
|
|
def setParameters(self, parameters):
|
|
r"""setParameters(JournalEntry self, std::string const & parameters)"""
|
|
return _datamodel.JournalEntry_setParameters(self, parameters)
|
|
|
|
def parameters(self):
|
|
r"""parameters(JournalEntry self) -> std::string const &"""
|
|
return _datamodel.JournalEntry_parameters(self)
|
|
|
|
def journaling(self):
|
|
r"""journaling(JournalEntry self) -> Journaling"""
|
|
return _datamodel.JournalEntry_journaling(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(JournalEntry self, Object other) -> bool"""
|
|
return _datamodel.JournalEntry_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(JournalEntry self, PublicObject parent) -> bool"""
|
|
return _datamodel.JournalEntry_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(JournalEntry self, PublicObject parent) -> bool"""
|
|
return _datamodel.JournalEntry_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(JournalEntry self) -> bool"""
|
|
return _datamodel.JournalEntry_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(JournalEntry self) -> Object"""
|
|
return _datamodel.JournalEntry_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(JournalEntry self, Visitor visitor)"""
|
|
return _datamodel.JournalEntry_accept(self, visitor)
|
|
|
|
# Register JournalEntry in _datamodel:
|
|
_datamodel.JournalEntry_swigregister(JournalEntry)
|
|
|
|
def JournalEntry_ClassName():
|
|
r"""JournalEntry_ClassName() -> char const *"""
|
|
return _datamodel.JournalEntry_ClassName()
|
|
|
|
def JournalEntry_TypeInfo():
|
|
r"""JournalEntry_TypeInfo() -> RTTI"""
|
|
return _datamodel.JournalEntry_TypeInfo()
|
|
|
|
def JournalEntry_Cast(*args):
|
|
r"""
|
|
JournalEntry_Cast(BaseObject o) -> JournalEntry
|
|
JournalEntry_Cast(Seiscomp::Core::BaseObjectPtr o) -> JournalEntry
|
|
"""
|
|
return _datamodel.JournalEntry_Cast(*args)
|
|
|
|
def JournalEntry_ConstCast(*args):
|
|
r"""
|
|
JournalEntry_ConstCast(BaseObject o) -> JournalEntry
|
|
JournalEntry_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> JournalEntry
|
|
"""
|
|
return _datamodel.JournalEntry_ConstCast(*args)
|
|
|
|
def JournalEntry_Meta():
|
|
r"""JournalEntry_Meta() -> MetaObject"""
|
|
return _datamodel.JournalEntry_Meta()
|
|
|
|
class Journaling(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Journaling 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 _datamodel.Journaling_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.Journaling_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(Journaling self) -> char const *"""
|
|
return _datamodel.Journaling_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(Journaling self) -> RTTI"""
|
|
return _datamodel.Journaling_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> Journaling
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> Journaling
|
|
"""
|
|
return _datamodel.Journaling_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> Journaling
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Journaling
|
|
"""
|
|
return _datamodel.Journaling_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(Journaling self, GenericArchive ar)"""
|
|
return _datamodel.Journaling_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.Journaling_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(Journaling self) -> MetaObject"""
|
|
return _datamodel.Journaling_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Journaling self) -> Journaling
|
|
__init__(Journaling self, Journaling other) -> Journaling
|
|
"""
|
|
_datamodel.Journaling_swiginit(self, _datamodel.new_Journaling(*args))
|
|
__swig_destroy__ = _datamodel.delete_Journaling
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(Journaling self, Journaling other) -> bool"""
|
|
return _datamodel.Journaling___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(Journaling self, Journaling other) -> bool"""
|
|
return _datamodel.Journaling___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(Journaling self, Journaling other) -> bool"""
|
|
return _datamodel.Journaling_equal(self, other)
|
|
|
|
def add(self, obj):
|
|
r"""add(Journaling self, JournalEntry obj) -> bool"""
|
|
return _datamodel.Journaling_add(self, obj)
|
|
|
|
def remove(self, obj):
|
|
r"""remove(Journaling self, JournalEntry obj) -> bool"""
|
|
return _datamodel.Journaling_remove(self, obj)
|
|
|
|
def removeJournalEntry(self, i):
|
|
r"""removeJournalEntry(Journaling self, size_t i) -> bool"""
|
|
return _datamodel.Journaling_removeJournalEntry(self, i)
|
|
|
|
def journalEntryCount(self):
|
|
r"""journalEntryCount(Journaling self) -> size_t"""
|
|
return _datamodel.Journaling_journalEntryCount(self)
|
|
|
|
def journalEntry(self, i):
|
|
r"""journalEntry(Journaling self, size_t i) -> JournalEntry"""
|
|
return _datamodel.Journaling_journalEntry(self, i)
|
|
|
|
def findJournalEntry(self, journalEntry):
|
|
r"""findJournalEntry(Journaling self, JournalEntry journalEntry) -> JournalEntry"""
|
|
return _datamodel.Journaling_findJournalEntry(self, journalEntry)
|
|
|
|
def assign(self, other):
|
|
r"""assign(Journaling self, Object other) -> bool"""
|
|
return _datamodel.Journaling_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(Journaling self, PublicObject parent) -> bool"""
|
|
return _datamodel.Journaling_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(Journaling self, PublicObject parent) -> bool"""
|
|
return _datamodel.Journaling_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(Journaling self) -> bool"""
|
|
return _datamodel.Journaling_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(Journaling self) -> Object"""
|
|
return _datamodel.Journaling_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(Journaling self, Object child) -> bool"""
|
|
return _datamodel.Journaling_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(Journaling self, Visitor visitor)"""
|
|
return _datamodel.Journaling_accept(self, visitor)
|
|
|
|
# Register Journaling in _datamodel:
|
|
_datamodel.Journaling_swigregister(Journaling)
|
|
|
|
def Journaling_ClassName():
|
|
r"""Journaling_ClassName() -> char const *"""
|
|
return _datamodel.Journaling_ClassName()
|
|
|
|
def Journaling_TypeInfo():
|
|
r"""Journaling_TypeInfo() -> RTTI"""
|
|
return _datamodel.Journaling_TypeInfo()
|
|
|
|
def Journaling_Cast(*args):
|
|
r"""
|
|
Journaling_Cast(BaseObject o) -> Journaling
|
|
Journaling_Cast(Seiscomp::Core::BaseObjectPtr o) -> Journaling
|
|
"""
|
|
return _datamodel.Journaling_Cast(*args)
|
|
|
|
def Journaling_ConstCast(*args):
|
|
r"""
|
|
Journaling_ConstCast(BaseObject o) -> Journaling
|
|
Journaling_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Journaling
|
|
"""
|
|
return _datamodel.Journaling_ConstCast(*args)
|
|
|
|
def Journaling_Meta():
|
|
r"""Journaling_Meta() -> MetaObject"""
|
|
return _datamodel.Journaling_Meta()
|
|
|
|
class ArclinkUserIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ArclinkUserIndex 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__(ArclinkUserIndex self) -> ArclinkUserIndex
|
|
__init__(ArclinkUserIndex self, std::string const & name, std::string const & email) -> ArclinkUserIndex
|
|
__init__(ArclinkUserIndex self, ArclinkUserIndex arg2) -> ArclinkUserIndex
|
|
"""
|
|
_datamodel.ArclinkUserIndex_swiginit(self, _datamodel.new_ArclinkUserIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(ArclinkUserIndex self, ArclinkUserIndex arg2) -> bool"""
|
|
return _datamodel.ArclinkUserIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(ArclinkUserIndex self, ArclinkUserIndex arg2) -> bool"""
|
|
return _datamodel.ArclinkUserIndex___ne__(self, arg2)
|
|
name = property(_datamodel.ArclinkUserIndex_name_get, _datamodel.ArclinkUserIndex_name_set, doc=r"""name : std::string""")
|
|
email = property(_datamodel.ArclinkUserIndex_email_get, _datamodel.ArclinkUserIndex_email_set, doc=r"""email : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_ArclinkUserIndex
|
|
|
|
# Register ArclinkUserIndex in _datamodel:
|
|
_datamodel.ArclinkUserIndex_swigregister(ArclinkUserIndex)
|
|
|
|
class ArclinkUser(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ArclinkUser 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 _datamodel.ArclinkUser_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ArclinkUser_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ArclinkUser self) -> char const *"""
|
|
return _datamodel.ArclinkUser_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ArclinkUser self) -> RTTI"""
|
|
return _datamodel.ArclinkUser_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ArclinkUser
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkUser
|
|
"""
|
|
return _datamodel.ArclinkUser_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ArclinkUser
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkUser
|
|
"""
|
|
return _datamodel.ArclinkUser_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ArclinkUser self, GenericArchive ar)"""
|
|
return _datamodel.ArclinkUser_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ArclinkUser_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ArclinkUser self) -> MetaObject"""
|
|
return _datamodel.ArclinkUser_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ArclinkUser self, ArclinkUser other) -> ArclinkUser
|
|
__init__(ArclinkUser self, std::string const & publicID) -> ArclinkUser
|
|
"""
|
|
_datamodel.ArclinkUser_swiginit(self, _datamodel.new_ArclinkUser(*args))
|
|
__swig_destroy__ = _datamodel.delete_ArclinkUser
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> ArclinkUser
|
|
Create(std::string const & publicID) -> ArclinkUser
|
|
"""
|
|
return _datamodel.ArclinkUser_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> ArclinkUser"""
|
|
return _datamodel.ArclinkUser_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ArclinkUser self, ArclinkUser other) -> bool"""
|
|
return _datamodel.ArclinkUser___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ArclinkUser self, ArclinkUser other) -> bool"""
|
|
return _datamodel.ArclinkUser___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ArclinkUser self, ArclinkUser other) -> bool"""
|
|
return _datamodel.ArclinkUser_equal(self, other)
|
|
|
|
def setName(self, name):
|
|
r"""setName(ArclinkUser self, std::string const & name)"""
|
|
return _datamodel.ArclinkUser_setName(self, name)
|
|
|
|
def name(self):
|
|
r"""name(ArclinkUser self) -> std::string const &"""
|
|
return _datamodel.ArclinkUser_name(self)
|
|
|
|
def setEmail(self, email):
|
|
r"""setEmail(ArclinkUser self, std::string const & email)"""
|
|
return _datamodel.ArclinkUser_setEmail(self, email)
|
|
|
|
def email(self):
|
|
r"""email(ArclinkUser self) -> std::string const &"""
|
|
return _datamodel.ArclinkUser_email(self)
|
|
|
|
def setPassword(self, password):
|
|
r"""setPassword(ArclinkUser self, std::string const & password)"""
|
|
return _datamodel.ArclinkUser_setPassword(self, password)
|
|
|
|
def password(self):
|
|
r"""password(ArclinkUser self) -> std::string const &"""
|
|
return _datamodel.ArclinkUser_password(self)
|
|
|
|
def index(self):
|
|
r"""index(ArclinkUser self) -> ArclinkUserIndex"""
|
|
return _datamodel.ArclinkUser_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(ArclinkUser self, ArclinkUser lhs) -> bool"""
|
|
return _datamodel.ArclinkUser_equalIndex(self, lhs)
|
|
|
|
def arclinkLog(self):
|
|
r"""arclinkLog(ArclinkUser self) -> ArclinkLog"""
|
|
return _datamodel.ArclinkUser_arclinkLog(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(ArclinkUser self, Object other) -> bool"""
|
|
return _datamodel.ArclinkUser_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(ArclinkUser self, PublicObject parent) -> bool"""
|
|
return _datamodel.ArclinkUser_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(ArclinkUser self, PublicObject parent) -> bool"""
|
|
return _datamodel.ArclinkUser_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(ArclinkUser self) -> bool"""
|
|
return _datamodel.ArclinkUser_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(ArclinkUser self) -> Object"""
|
|
return _datamodel.ArclinkUser_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(ArclinkUser self, Object child) -> bool"""
|
|
return _datamodel.ArclinkUser_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(ArclinkUser self, Visitor visitor)"""
|
|
return _datamodel.ArclinkUser_accept(self, visitor)
|
|
|
|
# Register ArclinkUser in _datamodel:
|
|
_datamodel.ArclinkUser_swigregister(ArclinkUser)
|
|
|
|
def ArclinkUser_ClassName():
|
|
r"""ArclinkUser_ClassName() -> char const *"""
|
|
return _datamodel.ArclinkUser_ClassName()
|
|
|
|
def ArclinkUser_TypeInfo():
|
|
r"""ArclinkUser_TypeInfo() -> RTTI"""
|
|
return _datamodel.ArclinkUser_TypeInfo()
|
|
|
|
def ArclinkUser_Cast(*args):
|
|
r"""
|
|
ArclinkUser_Cast(BaseObject o) -> ArclinkUser
|
|
ArclinkUser_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkUser
|
|
"""
|
|
return _datamodel.ArclinkUser_Cast(*args)
|
|
|
|
def ArclinkUser_ConstCast(*args):
|
|
r"""
|
|
ArclinkUser_ConstCast(BaseObject o) -> ArclinkUser
|
|
ArclinkUser_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkUser
|
|
"""
|
|
return _datamodel.ArclinkUser_ConstCast(*args)
|
|
|
|
def ArclinkUser_Meta():
|
|
r"""ArclinkUser_Meta() -> MetaObject"""
|
|
return _datamodel.ArclinkUser_Meta()
|
|
|
|
def ArclinkUser_Create(*args):
|
|
r"""
|
|
ArclinkUser_Create() -> ArclinkUser
|
|
ArclinkUser_Create(std::string const & publicID) -> ArclinkUser
|
|
"""
|
|
return _datamodel.ArclinkUser_Create(*args)
|
|
|
|
def ArclinkUser_Find(publicID):
|
|
r"""ArclinkUser_Find(std::string const & publicID) -> ArclinkUser"""
|
|
return _datamodel.ArclinkUser_Find(publicID)
|
|
|
|
class ArclinkStatusLineIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ArclinkStatusLineIndex 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__(ArclinkStatusLineIndex self) -> ArclinkStatusLineIndex
|
|
__init__(ArclinkStatusLineIndex self, std::string const & volumeID, std::string const & type, std::string const & status) -> ArclinkStatusLineIndex
|
|
__init__(ArclinkStatusLineIndex self, ArclinkStatusLineIndex arg2) -> ArclinkStatusLineIndex
|
|
"""
|
|
_datamodel.ArclinkStatusLineIndex_swiginit(self, _datamodel.new_ArclinkStatusLineIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(ArclinkStatusLineIndex self, ArclinkStatusLineIndex arg2) -> bool"""
|
|
return _datamodel.ArclinkStatusLineIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(ArclinkStatusLineIndex self, ArclinkStatusLineIndex arg2) -> bool"""
|
|
return _datamodel.ArclinkStatusLineIndex___ne__(self, arg2)
|
|
volumeID = property(_datamodel.ArclinkStatusLineIndex_volumeID_get, _datamodel.ArclinkStatusLineIndex_volumeID_set, doc=r"""volumeID : std::string""")
|
|
type = property(_datamodel.ArclinkStatusLineIndex_type_get, _datamodel.ArclinkStatusLineIndex_type_set, doc=r"""type : std::string""")
|
|
status = property(_datamodel.ArclinkStatusLineIndex_status_get, _datamodel.ArclinkStatusLineIndex_status_set, doc=r"""status : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_ArclinkStatusLineIndex
|
|
|
|
# Register ArclinkStatusLineIndex in _datamodel:
|
|
_datamodel.ArclinkStatusLineIndex_swigregister(ArclinkStatusLineIndex)
|
|
|
|
class ArclinkStatusLine(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ArclinkStatusLine 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 _datamodel.ArclinkStatusLine_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ArclinkStatusLine_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ArclinkStatusLine self) -> char const *"""
|
|
return _datamodel.ArclinkStatusLine_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ArclinkStatusLine self) -> RTTI"""
|
|
return _datamodel.ArclinkStatusLine_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ArclinkStatusLine
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkStatusLine
|
|
"""
|
|
return _datamodel.ArclinkStatusLine_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ArclinkStatusLine
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkStatusLine
|
|
"""
|
|
return _datamodel.ArclinkStatusLine_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ArclinkStatusLine self, GenericArchive ar)"""
|
|
return _datamodel.ArclinkStatusLine_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ArclinkStatusLine_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ArclinkStatusLine self) -> MetaObject"""
|
|
return _datamodel.ArclinkStatusLine_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ArclinkStatusLine self) -> ArclinkStatusLine
|
|
__init__(ArclinkStatusLine self, ArclinkStatusLine other) -> ArclinkStatusLine
|
|
"""
|
|
_datamodel.ArclinkStatusLine_swiginit(self, _datamodel.new_ArclinkStatusLine(*args))
|
|
__swig_destroy__ = _datamodel.delete_ArclinkStatusLine
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ArclinkStatusLine self, ArclinkStatusLine other) -> bool"""
|
|
return _datamodel.ArclinkStatusLine___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ArclinkStatusLine self, ArclinkStatusLine other) -> bool"""
|
|
return _datamodel.ArclinkStatusLine___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ArclinkStatusLine self, ArclinkStatusLine other) -> bool"""
|
|
return _datamodel.ArclinkStatusLine_equal(self, other)
|
|
|
|
def setType(self, type):
|
|
r"""setType(ArclinkStatusLine self, std::string const & type)"""
|
|
return _datamodel.ArclinkStatusLine_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(ArclinkStatusLine self) -> std::string const &"""
|
|
return _datamodel.ArclinkStatusLine_type(self)
|
|
|
|
def setStatus(self, status):
|
|
r"""setStatus(ArclinkStatusLine self, std::string const & status)"""
|
|
return _datamodel.ArclinkStatusLine_setStatus(self, status)
|
|
|
|
def status(self):
|
|
r"""status(ArclinkStatusLine self) -> std::string const &"""
|
|
return _datamodel.ArclinkStatusLine_status(self)
|
|
|
|
def setSize(self, size):
|
|
r"""setSize(ArclinkStatusLine self, Seiscomp::Core::Optional< int >::Impl const & size)"""
|
|
return _datamodel.ArclinkStatusLine_setSize(self, size)
|
|
|
|
def size(self):
|
|
r"""size(ArclinkStatusLine self) -> int"""
|
|
return _datamodel.ArclinkStatusLine_size(self)
|
|
|
|
def setMessage(self, message):
|
|
r"""setMessage(ArclinkStatusLine self, std::string const & message)"""
|
|
return _datamodel.ArclinkStatusLine_setMessage(self, message)
|
|
|
|
def message(self):
|
|
r"""message(ArclinkStatusLine self) -> std::string const &"""
|
|
return _datamodel.ArclinkStatusLine_message(self)
|
|
|
|
def setVolumeID(self, volumeID):
|
|
r"""setVolumeID(ArclinkStatusLine self, std::string const & volumeID)"""
|
|
return _datamodel.ArclinkStatusLine_setVolumeID(self, volumeID)
|
|
|
|
def volumeID(self):
|
|
r"""volumeID(ArclinkStatusLine self) -> std::string const &"""
|
|
return _datamodel.ArclinkStatusLine_volumeID(self)
|
|
|
|
def index(self):
|
|
r"""index(ArclinkStatusLine self) -> ArclinkStatusLineIndex"""
|
|
return _datamodel.ArclinkStatusLine_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(ArclinkStatusLine self, ArclinkStatusLine lhs) -> bool"""
|
|
return _datamodel.ArclinkStatusLine_equalIndex(self, lhs)
|
|
|
|
def arclinkRequest(self):
|
|
r"""arclinkRequest(ArclinkStatusLine self) -> ArclinkRequest"""
|
|
return _datamodel.ArclinkStatusLine_arclinkRequest(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(ArclinkStatusLine self, Object other) -> bool"""
|
|
return _datamodel.ArclinkStatusLine_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(ArclinkStatusLine self, PublicObject parent) -> bool"""
|
|
return _datamodel.ArclinkStatusLine_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(ArclinkStatusLine self, PublicObject parent) -> bool"""
|
|
return _datamodel.ArclinkStatusLine_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(ArclinkStatusLine self) -> bool"""
|
|
return _datamodel.ArclinkStatusLine_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(ArclinkStatusLine self) -> Object"""
|
|
return _datamodel.ArclinkStatusLine_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(ArclinkStatusLine self, Visitor visitor)"""
|
|
return _datamodel.ArclinkStatusLine_accept(self, visitor)
|
|
|
|
# Register ArclinkStatusLine in _datamodel:
|
|
_datamodel.ArclinkStatusLine_swigregister(ArclinkStatusLine)
|
|
|
|
def ArclinkStatusLine_ClassName():
|
|
r"""ArclinkStatusLine_ClassName() -> char const *"""
|
|
return _datamodel.ArclinkStatusLine_ClassName()
|
|
|
|
def ArclinkStatusLine_TypeInfo():
|
|
r"""ArclinkStatusLine_TypeInfo() -> RTTI"""
|
|
return _datamodel.ArclinkStatusLine_TypeInfo()
|
|
|
|
def ArclinkStatusLine_Cast(*args):
|
|
r"""
|
|
ArclinkStatusLine_Cast(BaseObject o) -> ArclinkStatusLine
|
|
ArclinkStatusLine_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkStatusLine
|
|
"""
|
|
return _datamodel.ArclinkStatusLine_Cast(*args)
|
|
|
|
def ArclinkStatusLine_ConstCast(*args):
|
|
r"""
|
|
ArclinkStatusLine_ConstCast(BaseObject o) -> ArclinkStatusLine
|
|
ArclinkStatusLine_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkStatusLine
|
|
"""
|
|
return _datamodel.ArclinkStatusLine_ConstCast(*args)
|
|
|
|
def ArclinkStatusLine_Meta():
|
|
r"""ArclinkStatusLine_Meta() -> MetaObject"""
|
|
return _datamodel.ArclinkStatusLine_Meta()
|
|
|
|
class ArclinkRequestLineIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ArclinkRequestLineIndex 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__(ArclinkRequestLineIndex self) -> ArclinkRequestLineIndex
|
|
__init__(ArclinkRequestLineIndex self, Time start, Time end, WaveformStreamID streamID) -> ArclinkRequestLineIndex
|
|
__init__(ArclinkRequestLineIndex self, ArclinkRequestLineIndex arg2) -> ArclinkRequestLineIndex
|
|
"""
|
|
_datamodel.ArclinkRequestLineIndex_swiginit(self, _datamodel.new_ArclinkRequestLineIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(ArclinkRequestLineIndex self, ArclinkRequestLineIndex arg2) -> bool"""
|
|
return _datamodel.ArclinkRequestLineIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(ArclinkRequestLineIndex self, ArclinkRequestLineIndex arg2) -> bool"""
|
|
return _datamodel.ArclinkRequestLineIndex___ne__(self, arg2)
|
|
start = property(_datamodel.ArclinkRequestLineIndex_start_get, _datamodel.ArclinkRequestLineIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
|
|
end = property(_datamodel.ArclinkRequestLineIndex_end_get, _datamodel.ArclinkRequestLineIndex_end_set, doc=r"""end : Seiscomp::Core::Time""")
|
|
streamID = property(_datamodel.ArclinkRequestLineIndex_streamID_get, _datamodel.ArclinkRequestLineIndex_streamID_set, doc=r"""streamID : Seiscomp::DataModel::WaveformStreamID""")
|
|
__swig_destroy__ = _datamodel.delete_ArclinkRequestLineIndex
|
|
|
|
# Register ArclinkRequestLineIndex in _datamodel:
|
|
_datamodel.ArclinkRequestLineIndex_swigregister(ArclinkRequestLineIndex)
|
|
|
|
class ArclinkRequestLine(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ArclinkRequestLine 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 _datamodel.ArclinkRequestLine_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ArclinkRequestLine_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ArclinkRequestLine self) -> char const *"""
|
|
return _datamodel.ArclinkRequestLine_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ArclinkRequestLine self) -> RTTI"""
|
|
return _datamodel.ArclinkRequestLine_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ArclinkRequestLine
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkRequestLine
|
|
"""
|
|
return _datamodel.ArclinkRequestLine_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ArclinkRequestLine
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkRequestLine
|
|
"""
|
|
return _datamodel.ArclinkRequestLine_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ArclinkRequestLine self, GenericArchive ar)"""
|
|
return _datamodel.ArclinkRequestLine_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ArclinkRequestLine_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ArclinkRequestLine self) -> MetaObject"""
|
|
return _datamodel.ArclinkRequestLine_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ArclinkRequestLine self) -> ArclinkRequestLine
|
|
__init__(ArclinkRequestLine self, ArclinkRequestLine other) -> ArclinkRequestLine
|
|
"""
|
|
_datamodel.ArclinkRequestLine_swiginit(self, _datamodel.new_ArclinkRequestLine(*args))
|
|
__swig_destroy__ = _datamodel.delete_ArclinkRequestLine
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ArclinkRequestLine self, ArclinkRequestLine other) -> bool"""
|
|
return _datamodel.ArclinkRequestLine___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ArclinkRequestLine self, ArclinkRequestLine other) -> bool"""
|
|
return _datamodel.ArclinkRequestLine___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ArclinkRequestLine self, ArclinkRequestLine other) -> bool"""
|
|
return _datamodel.ArclinkRequestLine_equal(self, other)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(ArclinkRequestLine self, Time start)"""
|
|
return _datamodel.ArclinkRequestLine_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(ArclinkRequestLine self) -> Time"""
|
|
return _datamodel.ArclinkRequestLine_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(ArclinkRequestLine self, Time end)"""
|
|
return _datamodel.ArclinkRequestLine_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(ArclinkRequestLine self) -> Time"""
|
|
return _datamodel.ArclinkRequestLine_end(self)
|
|
|
|
def setStreamID(self, streamID):
|
|
r"""setStreamID(ArclinkRequestLine self, WaveformStreamID streamID)"""
|
|
return _datamodel.ArclinkRequestLine_setStreamID(self, streamID)
|
|
|
|
def streamID(self, *args):
|
|
r"""
|
|
streamID(ArclinkRequestLine self) -> WaveformStreamID
|
|
streamID(ArclinkRequestLine self) -> WaveformStreamID
|
|
"""
|
|
return _datamodel.ArclinkRequestLine_streamID(self, *args)
|
|
|
|
def setRestricted(self, restricted):
|
|
r"""setRestricted(ArclinkRequestLine self, Seiscomp::Core::Optional< bool >::Impl const & restricted)"""
|
|
return _datamodel.ArclinkRequestLine_setRestricted(self, restricted)
|
|
|
|
def restricted(self):
|
|
r"""restricted(ArclinkRequestLine self) -> bool"""
|
|
return _datamodel.ArclinkRequestLine_restricted(self)
|
|
|
|
def setShared(self, shared):
|
|
r"""setShared(ArclinkRequestLine self, Seiscomp::Core::Optional< bool >::Impl const & shared)"""
|
|
return _datamodel.ArclinkRequestLine_setShared(self, shared)
|
|
|
|
def shared(self):
|
|
r"""shared(ArclinkRequestLine self) -> bool"""
|
|
return _datamodel.ArclinkRequestLine_shared(self)
|
|
|
|
def setNetClass(self, netClass):
|
|
r"""setNetClass(ArclinkRequestLine self, std::string const & netClass)"""
|
|
return _datamodel.ArclinkRequestLine_setNetClass(self, netClass)
|
|
|
|
def netClass(self):
|
|
r"""netClass(ArclinkRequestLine self) -> std::string const &"""
|
|
return _datamodel.ArclinkRequestLine_netClass(self)
|
|
|
|
def setConstraints(self, constraints):
|
|
r"""setConstraints(ArclinkRequestLine self, std::string const & constraints)"""
|
|
return _datamodel.ArclinkRequestLine_setConstraints(self, constraints)
|
|
|
|
def constraints(self):
|
|
r"""constraints(ArclinkRequestLine self) -> std::string const &"""
|
|
return _datamodel.ArclinkRequestLine_constraints(self)
|
|
|
|
def setStatus(self, status):
|
|
r"""setStatus(ArclinkRequestLine self, ArclinkStatusLine status)"""
|
|
return _datamodel.ArclinkRequestLine_setStatus(self, status)
|
|
|
|
def status(self, *args):
|
|
r"""
|
|
status(ArclinkRequestLine self) -> ArclinkStatusLine
|
|
status(ArclinkRequestLine self) -> ArclinkStatusLine
|
|
"""
|
|
return _datamodel.ArclinkRequestLine_status(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(ArclinkRequestLine self) -> ArclinkRequestLineIndex"""
|
|
return _datamodel.ArclinkRequestLine_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(ArclinkRequestLine self, ArclinkRequestLine lhs) -> bool"""
|
|
return _datamodel.ArclinkRequestLine_equalIndex(self, lhs)
|
|
|
|
def arclinkRequest(self):
|
|
r"""arclinkRequest(ArclinkRequestLine self) -> ArclinkRequest"""
|
|
return _datamodel.ArclinkRequestLine_arclinkRequest(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(ArclinkRequestLine self, Object other) -> bool"""
|
|
return _datamodel.ArclinkRequestLine_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(ArclinkRequestLine self, PublicObject parent) -> bool"""
|
|
return _datamodel.ArclinkRequestLine_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(ArclinkRequestLine self, PublicObject parent) -> bool"""
|
|
return _datamodel.ArclinkRequestLine_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(ArclinkRequestLine self) -> bool"""
|
|
return _datamodel.ArclinkRequestLine_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(ArclinkRequestLine self) -> Object"""
|
|
return _datamodel.ArclinkRequestLine_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(ArclinkRequestLine self, Visitor visitor)"""
|
|
return _datamodel.ArclinkRequestLine_accept(self, visitor)
|
|
|
|
# Register ArclinkRequestLine in _datamodel:
|
|
_datamodel.ArclinkRequestLine_swigregister(ArclinkRequestLine)
|
|
|
|
def ArclinkRequestLine_ClassName():
|
|
r"""ArclinkRequestLine_ClassName() -> char const *"""
|
|
return _datamodel.ArclinkRequestLine_ClassName()
|
|
|
|
def ArclinkRequestLine_TypeInfo():
|
|
r"""ArclinkRequestLine_TypeInfo() -> RTTI"""
|
|
return _datamodel.ArclinkRequestLine_TypeInfo()
|
|
|
|
def ArclinkRequestLine_Cast(*args):
|
|
r"""
|
|
ArclinkRequestLine_Cast(BaseObject o) -> ArclinkRequestLine
|
|
ArclinkRequestLine_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkRequestLine
|
|
"""
|
|
return _datamodel.ArclinkRequestLine_Cast(*args)
|
|
|
|
def ArclinkRequestLine_ConstCast(*args):
|
|
r"""
|
|
ArclinkRequestLine_ConstCast(BaseObject o) -> ArclinkRequestLine
|
|
ArclinkRequestLine_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkRequestLine
|
|
"""
|
|
return _datamodel.ArclinkRequestLine_ConstCast(*args)
|
|
|
|
def ArclinkRequestLine_Meta():
|
|
r"""ArclinkRequestLine_Meta() -> MetaObject"""
|
|
return _datamodel.ArclinkRequestLine_Meta()
|
|
|
|
class ArclinkRequestIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ArclinkRequestIndex 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__(ArclinkRequestIndex self) -> ArclinkRequestIndex
|
|
__init__(ArclinkRequestIndex self, Time created, std::string const & requestID, std::string const & userID) -> ArclinkRequestIndex
|
|
__init__(ArclinkRequestIndex self, ArclinkRequestIndex arg2) -> ArclinkRequestIndex
|
|
"""
|
|
_datamodel.ArclinkRequestIndex_swiginit(self, _datamodel.new_ArclinkRequestIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(ArclinkRequestIndex self, ArclinkRequestIndex arg2) -> bool"""
|
|
return _datamodel.ArclinkRequestIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(ArclinkRequestIndex self, ArclinkRequestIndex arg2) -> bool"""
|
|
return _datamodel.ArclinkRequestIndex___ne__(self, arg2)
|
|
created = property(_datamodel.ArclinkRequestIndex_created_get, _datamodel.ArclinkRequestIndex_created_set, doc=r"""created : Seiscomp::Core::Time""")
|
|
requestID = property(_datamodel.ArclinkRequestIndex_requestID_get, _datamodel.ArclinkRequestIndex_requestID_set, doc=r"""requestID : std::string""")
|
|
userID = property(_datamodel.ArclinkRequestIndex_userID_get, _datamodel.ArclinkRequestIndex_userID_set, doc=r"""userID : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_ArclinkRequestIndex
|
|
|
|
# Register ArclinkRequestIndex in _datamodel:
|
|
_datamodel.ArclinkRequestIndex_swigregister(ArclinkRequestIndex)
|
|
|
|
class ArclinkRequest(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ArclinkRequest 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 _datamodel.ArclinkRequest_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ArclinkRequest_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ArclinkRequest self) -> char const *"""
|
|
return _datamodel.ArclinkRequest_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ArclinkRequest self) -> RTTI"""
|
|
return _datamodel.ArclinkRequest_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ArclinkRequest
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkRequest
|
|
"""
|
|
return _datamodel.ArclinkRequest_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ArclinkRequest
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkRequest
|
|
"""
|
|
return _datamodel.ArclinkRequest_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ArclinkRequest self, GenericArchive ar)"""
|
|
return _datamodel.ArclinkRequest_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ArclinkRequest_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ArclinkRequest self) -> MetaObject"""
|
|
return _datamodel.ArclinkRequest_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ArclinkRequest self, ArclinkRequest other) -> ArclinkRequest
|
|
__init__(ArclinkRequest self, std::string const & publicID) -> ArclinkRequest
|
|
"""
|
|
_datamodel.ArclinkRequest_swiginit(self, _datamodel.new_ArclinkRequest(*args))
|
|
__swig_destroy__ = _datamodel.delete_ArclinkRequest
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> ArclinkRequest
|
|
Create(std::string const & publicID) -> ArclinkRequest
|
|
"""
|
|
return _datamodel.ArclinkRequest_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> ArclinkRequest"""
|
|
return _datamodel.ArclinkRequest_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ArclinkRequest self, ArclinkRequest other) -> bool"""
|
|
return _datamodel.ArclinkRequest___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ArclinkRequest self, ArclinkRequest other) -> bool"""
|
|
return _datamodel.ArclinkRequest___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ArclinkRequest self, ArclinkRequest other) -> bool"""
|
|
return _datamodel.ArclinkRequest_equal(self, other)
|
|
|
|
def setRequestID(self, requestID):
|
|
r"""setRequestID(ArclinkRequest self, std::string const & requestID)"""
|
|
return _datamodel.ArclinkRequest_setRequestID(self, requestID)
|
|
|
|
def requestID(self):
|
|
r"""requestID(ArclinkRequest self) -> std::string const &"""
|
|
return _datamodel.ArclinkRequest_requestID(self)
|
|
|
|
def setUserID(self, userID):
|
|
r"""setUserID(ArclinkRequest self, std::string const & userID)"""
|
|
return _datamodel.ArclinkRequest_setUserID(self, userID)
|
|
|
|
def userID(self):
|
|
r"""userID(ArclinkRequest self) -> std::string const &"""
|
|
return _datamodel.ArclinkRequest_userID(self)
|
|
|
|
def setUserIP(self, userIP):
|
|
r"""setUserIP(ArclinkRequest self, std::string const & userIP)"""
|
|
return _datamodel.ArclinkRequest_setUserIP(self, userIP)
|
|
|
|
def userIP(self):
|
|
r"""userIP(ArclinkRequest self) -> std::string const &"""
|
|
return _datamodel.ArclinkRequest_userIP(self)
|
|
|
|
def setClientID(self, clientID):
|
|
r"""setClientID(ArclinkRequest self, std::string const & clientID)"""
|
|
return _datamodel.ArclinkRequest_setClientID(self, clientID)
|
|
|
|
def clientID(self):
|
|
r"""clientID(ArclinkRequest self) -> std::string const &"""
|
|
return _datamodel.ArclinkRequest_clientID(self)
|
|
|
|
def setClientIP(self, clientIP):
|
|
r"""setClientIP(ArclinkRequest self, std::string const & clientIP)"""
|
|
return _datamodel.ArclinkRequest_setClientIP(self, clientIP)
|
|
|
|
def clientIP(self):
|
|
r"""clientIP(ArclinkRequest self) -> std::string const &"""
|
|
return _datamodel.ArclinkRequest_clientIP(self)
|
|
|
|
def setType(self, type):
|
|
r"""setType(ArclinkRequest self, std::string const & type)"""
|
|
return _datamodel.ArclinkRequest_setType(self, type)
|
|
|
|
def type(self):
|
|
r"""type(ArclinkRequest self) -> std::string const &"""
|
|
return _datamodel.ArclinkRequest_type(self)
|
|
|
|
def setCreated(self, created):
|
|
r"""setCreated(ArclinkRequest self, Time created)"""
|
|
return _datamodel.ArclinkRequest_setCreated(self, created)
|
|
|
|
def created(self):
|
|
r"""created(ArclinkRequest self) -> Time"""
|
|
return _datamodel.ArclinkRequest_created(self)
|
|
|
|
def setStatus(self, status):
|
|
r"""setStatus(ArclinkRequest self, std::string const & status)"""
|
|
return _datamodel.ArclinkRequest_setStatus(self, status)
|
|
|
|
def status(self):
|
|
r"""status(ArclinkRequest self) -> std::string const &"""
|
|
return _datamodel.ArclinkRequest_status(self)
|
|
|
|
def setMessage(self, message):
|
|
r"""setMessage(ArclinkRequest self, std::string const & message)"""
|
|
return _datamodel.ArclinkRequest_setMessage(self, message)
|
|
|
|
def message(self):
|
|
r"""message(ArclinkRequest self) -> std::string const &"""
|
|
return _datamodel.ArclinkRequest_message(self)
|
|
|
|
def setLabel(self, label):
|
|
r"""setLabel(ArclinkRequest self, std::string const & label)"""
|
|
return _datamodel.ArclinkRequest_setLabel(self, label)
|
|
|
|
def label(self):
|
|
r"""label(ArclinkRequest self) -> std::string const &"""
|
|
return _datamodel.ArclinkRequest_label(self)
|
|
|
|
def setHeader(self, header):
|
|
r"""setHeader(ArclinkRequest self, std::string const & header)"""
|
|
return _datamodel.ArclinkRequest_setHeader(self, header)
|
|
|
|
def header(self):
|
|
r"""header(ArclinkRequest self) -> std::string const &"""
|
|
return _datamodel.ArclinkRequest_header(self)
|
|
|
|
def setSummary(self, summary):
|
|
r"""setSummary(ArclinkRequest self, Seiscomp::Core::Optional< Seiscomp::DataModel::ArclinkRequestSummary >::Impl const & summary)"""
|
|
return _datamodel.ArclinkRequest_setSummary(self, summary)
|
|
|
|
def summary(self, *args):
|
|
r"""
|
|
summary(ArclinkRequest self) -> ArclinkRequestSummary
|
|
summary(ArclinkRequest self) -> ArclinkRequestSummary
|
|
"""
|
|
return _datamodel.ArclinkRequest_summary(self, *args)
|
|
|
|
def index(self):
|
|
r"""index(ArclinkRequest self) -> ArclinkRequestIndex"""
|
|
return _datamodel.ArclinkRequest_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(ArclinkRequest self, ArclinkRequest lhs) -> bool"""
|
|
return _datamodel.ArclinkRequest_equalIndex(self, lhs)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(ArclinkRequest self, ArclinkStatusLine obj) -> bool
|
|
add(ArclinkRequest self, ArclinkRequestLine obj) -> bool
|
|
"""
|
|
return _datamodel.ArclinkRequest_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(ArclinkRequest self, ArclinkStatusLine obj) -> bool
|
|
remove(ArclinkRequest self, ArclinkRequestLine obj) -> bool
|
|
"""
|
|
return _datamodel.ArclinkRequest_remove(self, *args)
|
|
|
|
def removeArclinkStatusLine(self, *args):
|
|
r"""
|
|
removeArclinkStatusLine(ArclinkRequest self, size_t i) -> bool
|
|
removeArclinkStatusLine(ArclinkRequest self, ArclinkStatusLineIndex i) -> bool
|
|
"""
|
|
return _datamodel.ArclinkRequest_removeArclinkStatusLine(self, *args)
|
|
|
|
def removeArclinkRequestLine(self, *args):
|
|
r"""
|
|
removeArclinkRequestLine(ArclinkRequest self, size_t i) -> bool
|
|
removeArclinkRequestLine(ArclinkRequest self, ArclinkRequestLineIndex i) -> bool
|
|
"""
|
|
return _datamodel.ArclinkRequest_removeArclinkRequestLine(self, *args)
|
|
|
|
def arclinkStatusLineCount(self):
|
|
r"""arclinkStatusLineCount(ArclinkRequest self) -> size_t"""
|
|
return _datamodel.ArclinkRequest_arclinkStatusLineCount(self)
|
|
|
|
def arclinkRequestLineCount(self):
|
|
r"""arclinkRequestLineCount(ArclinkRequest self) -> size_t"""
|
|
return _datamodel.ArclinkRequest_arclinkRequestLineCount(self)
|
|
|
|
def arclinkStatusLine(self, *args):
|
|
r"""
|
|
arclinkStatusLine(ArclinkRequest self, size_t i) -> ArclinkStatusLine
|
|
arclinkStatusLine(ArclinkRequest self, ArclinkStatusLineIndex i) -> ArclinkStatusLine
|
|
"""
|
|
return _datamodel.ArclinkRequest_arclinkStatusLine(self, *args)
|
|
|
|
def arclinkRequestLine(self, *args):
|
|
r"""
|
|
arclinkRequestLine(ArclinkRequest self, size_t i) -> ArclinkRequestLine
|
|
arclinkRequestLine(ArclinkRequest self, ArclinkRequestLineIndex i) -> ArclinkRequestLine
|
|
"""
|
|
return _datamodel.ArclinkRequest_arclinkRequestLine(self, *args)
|
|
|
|
def arclinkLog(self):
|
|
r"""arclinkLog(ArclinkRequest self) -> ArclinkLog"""
|
|
return _datamodel.ArclinkRequest_arclinkLog(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(ArclinkRequest self, Object other) -> bool"""
|
|
return _datamodel.ArclinkRequest_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(ArclinkRequest self, PublicObject parent) -> bool"""
|
|
return _datamodel.ArclinkRequest_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(ArclinkRequest self, PublicObject parent) -> bool"""
|
|
return _datamodel.ArclinkRequest_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(ArclinkRequest self) -> bool"""
|
|
return _datamodel.ArclinkRequest_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(ArclinkRequest self) -> Object"""
|
|
return _datamodel.ArclinkRequest_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(ArclinkRequest self, Object child) -> bool"""
|
|
return _datamodel.ArclinkRequest_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(ArclinkRequest self, Visitor visitor)"""
|
|
return _datamodel.ArclinkRequest_accept(self, visitor)
|
|
|
|
# Register ArclinkRequest in _datamodel:
|
|
_datamodel.ArclinkRequest_swigregister(ArclinkRequest)
|
|
|
|
def ArclinkRequest_ClassName():
|
|
r"""ArclinkRequest_ClassName() -> char const *"""
|
|
return _datamodel.ArclinkRequest_ClassName()
|
|
|
|
def ArclinkRequest_TypeInfo():
|
|
r"""ArclinkRequest_TypeInfo() -> RTTI"""
|
|
return _datamodel.ArclinkRequest_TypeInfo()
|
|
|
|
def ArclinkRequest_Cast(*args):
|
|
r"""
|
|
ArclinkRequest_Cast(BaseObject o) -> ArclinkRequest
|
|
ArclinkRequest_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkRequest
|
|
"""
|
|
return _datamodel.ArclinkRequest_Cast(*args)
|
|
|
|
def ArclinkRequest_ConstCast(*args):
|
|
r"""
|
|
ArclinkRequest_ConstCast(BaseObject o) -> ArclinkRequest
|
|
ArclinkRequest_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkRequest
|
|
"""
|
|
return _datamodel.ArclinkRequest_ConstCast(*args)
|
|
|
|
def ArclinkRequest_Meta():
|
|
r"""ArclinkRequest_Meta() -> MetaObject"""
|
|
return _datamodel.ArclinkRequest_Meta()
|
|
|
|
def ArclinkRequest_Create(*args):
|
|
r"""
|
|
ArclinkRequest_Create() -> ArclinkRequest
|
|
ArclinkRequest_Create(std::string const & publicID) -> ArclinkRequest
|
|
"""
|
|
return _datamodel.ArclinkRequest_Create(*args)
|
|
|
|
def ArclinkRequest_Find(publicID):
|
|
r"""ArclinkRequest_Find(std::string const & publicID) -> ArclinkRequest"""
|
|
return _datamodel.ArclinkRequest_Find(publicID)
|
|
|
|
class ArclinkLog(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ArclinkLog 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 _datamodel.ArclinkLog_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ArclinkLog_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ArclinkLog self) -> char const *"""
|
|
return _datamodel.ArclinkLog_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ArclinkLog self) -> RTTI"""
|
|
return _datamodel.ArclinkLog_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ArclinkLog
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkLog
|
|
"""
|
|
return _datamodel.ArclinkLog_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ArclinkLog
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkLog
|
|
"""
|
|
return _datamodel.ArclinkLog_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ArclinkLog self, GenericArchive ar)"""
|
|
return _datamodel.ArclinkLog_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.ArclinkLog_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(ArclinkLog self) -> MetaObject"""
|
|
return _datamodel.ArclinkLog_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ArclinkLog self) -> ArclinkLog
|
|
__init__(ArclinkLog self, ArclinkLog other) -> ArclinkLog
|
|
"""
|
|
_datamodel.ArclinkLog_swiginit(self, _datamodel.new_ArclinkLog(*args))
|
|
__swig_destroy__ = _datamodel.delete_ArclinkLog
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(ArclinkLog self, ArclinkLog other) -> bool"""
|
|
return _datamodel.ArclinkLog___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(ArclinkLog self, ArclinkLog other) -> bool"""
|
|
return _datamodel.ArclinkLog___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(ArclinkLog self, ArclinkLog other) -> bool"""
|
|
return _datamodel.ArclinkLog_equal(self, other)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(ArclinkLog self, ArclinkRequest obj) -> bool
|
|
add(ArclinkLog self, ArclinkUser obj) -> bool
|
|
"""
|
|
return _datamodel.ArclinkLog_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(ArclinkLog self, ArclinkRequest obj) -> bool
|
|
remove(ArclinkLog self, ArclinkUser obj) -> bool
|
|
"""
|
|
return _datamodel.ArclinkLog_remove(self, *args)
|
|
|
|
def removeArclinkRequest(self, *args):
|
|
r"""
|
|
removeArclinkRequest(ArclinkLog self, size_t i) -> bool
|
|
removeArclinkRequest(ArclinkLog self, ArclinkRequestIndex i) -> bool
|
|
"""
|
|
return _datamodel.ArclinkLog_removeArclinkRequest(self, *args)
|
|
|
|
def removeArclinkUser(self, *args):
|
|
r"""
|
|
removeArclinkUser(ArclinkLog self, size_t i) -> bool
|
|
removeArclinkUser(ArclinkLog self, ArclinkUserIndex i) -> bool
|
|
"""
|
|
return _datamodel.ArclinkLog_removeArclinkUser(self, *args)
|
|
|
|
def arclinkRequestCount(self):
|
|
r"""arclinkRequestCount(ArclinkLog self) -> size_t"""
|
|
return _datamodel.ArclinkLog_arclinkRequestCount(self)
|
|
|
|
def arclinkUserCount(self):
|
|
r"""arclinkUserCount(ArclinkLog self) -> size_t"""
|
|
return _datamodel.ArclinkLog_arclinkUserCount(self)
|
|
|
|
def arclinkRequest(self, *args):
|
|
r"""
|
|
arclinkRequest(ArclinkLog self, size_t i) -> ArclinkRequest
|
|
arclinkRequest(ArclinkLog self, ArclinkRequestIndex i) -> ArclinkRequest
|
|
"""
|
|
return _datamodel.ArclinkLog_arclinkRequest(self, *args)
|
|
|
|
def arclinkUser(self, *args):
|
|
r"""
|
|
arclinkUser(ArclinkLog self, size_t i) -> ArclinkUser
|
|
arclinkUser(ArclinkLog self, ArclinkUserIndex i) -> ArclinkUser
|
|
"""
|
|
return _datamodel.ArclinkLog_arclinkUser(self, *args)
|
|
|
|
def findArclinkRequest(self, publicID):
|
|
r"""findArclinkRequest(ArclinkLog self, std::string const & publicID) -> ArclinkRequest"""
|
|
return _datamodel.ArclinkLog_findArclinkRequest(self, publicID)
|
|
|
|
def findArclinkUser(self, publicID):
|
|
r"""findArclinkUser(ArclinkLog self, std::string const & publicID) -> ArclinkUser"""
|
|
return _datamodel.ArclinkLog_findArclinkUser(self, publicID)
|
|
|
|
def assign(self, other):
|
|
r"""assign(ArclinkLog self, Object other) -> bool"""
|
|
return _datamodel.ArclinkLog_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(ArclinkLog self, PublicObject parent) -> bool"""
|
|
return _datamodel.ArclinkLog_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(ArclinkLog self, PublicObject parent) -> bool"""
|
|
return _datamodel.ArclinkLog_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(ArclinkLog self) -> bool"""
|
|
return _datamodel.ArclinkLog_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(ArclinkLog self) -> Object"""
|
|
return _datamodel.ArclinkLog_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(ArclinkLog self, Object child) -> bool"""
|
|
return _datamodel.ArclinkLog_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(ArclinkLog self, Visitor visitor)"""
|
|
return _datamodel.ArclinkLog_accept(self, visitor)
|
|
|
|
# Register ArclinkLog in _datamodel:
|
|
_datamodel.ArclinkLog_swigregister(ArclinkLog)
|
|
|
|
def ArclinkLog_ClassName():
|
|
r"""ArclinkLog_ClassName() -> char const *"""
|
|
return _datamodel.ArclinkLog_ClassName()
|
|
|
|
def ArclinkLog_TypeInfo():
|
|
r"""ArclinkLog_TypeInfo() -> RTTI"""
|
|
return _datamodel.ArclinkLog_TypeInfo()
|
|
|
|
def ArclinkLog_Cast(*args):
|
|
r"""
|
|
ArclinkLog_Cast(BaseObject o) -> ArclinkLog
|
|
ArclinkLog_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkLog
|
|
"""
|
|
return _datamodel.ArclinkLog_Cast(*args)
|
|
|
|
def ArclinkLog_ConstCast(*args):
|
|
r"""
|
|
ArclinkLog_ConstCast(BaseObject o) -> ArclinkLog
|
|
ArclinkLog_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkLog
|
|
"""
|
|
return _datamodel.ArclinkLog_ConstCast(*args)
|
|
|
|
def ArclinkLog_Meta():
|
|
r"""ArclinkLog_Meta() -> MetaObject"""
|
|
return _datamodel.ArclinkLog_Meta()
|
|
|
|
class DataSegmentIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DataSegmentIndex 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__(DataSegmentIndex self) -> DataSegmentIndex
|
|
__init__(DataSegmentIndex self, Time start) -> DataSegmentIndex
|
|
__init__(DataSegmentIndex self, DataSegmentIndex arg2) -> DataSegmentIndex
|
|
"""
|
|
_datamodel.DataSegmentIndex_swiginit(self, _datamodel.new_DataSegmentIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(DataSegmentIndex self, DataSegmentIndex arg2) -> bool"""
|
|
return _datamodel.DataSegmentIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(DataSegmentIndex self, DataSegmentIndex arg2) -> bool"""
|
|
return _datamodel.DataSegmentIndex___ne__(self, arg2)
|
|
start = property(_datamodel.DataSegmentIndex_start_get, _datamodel.DataSegmentIndex_start_set, doc=r"""start : Seiscomp::Core::Time""")
|
|
__swig_destroy__ = _datamodel.delete_DataSegmentIndex
|
|
|
|
# Register DataSegmentIndex in _datamodel:
|
|
_datamodel.DataSegmentIndex_swigregister(DataSegmentIndex)
|
|
|
|
class DataSegment(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DataSegment 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 _datamodel.DataSegment_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.DataSegment_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(DataSegment self) -> char const *"""
|
|
return _datamodel.DataSegment_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(DataSegment self) -> RTTI"""
|
|
return _datamodel.DataSegment_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> DataSegment
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> DataSegment
|
|
"""
|
|
return _datamodel.DataSegment_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> DataSegment
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataSegment
|
|
"""
|
|
return _datamodel.DataSegment_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(DataSegment self, GenericArchive ar)"""
|
|
return _datamodel.DataSegment_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.DataSegment_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(DataSegment self) -> MetaObject"""
|
|
return _datamodel.DataSegment_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(DataSegment self) -> DataSegment
|
|
__init__(DataSegment self, DataSegment other) -> DataSegment
|
|
"""
|
|
_datamodel.DataSegment_swiginit(self, _datamodel.new_DataSegment(*args))
|
|
__swig_destroy__ = _datamodel.delete_DataSegment
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(DataSegment self, DataSegment other) -> bool"""
|
|
return _datamodel.DataSegment___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(DataSegment self, DataSegment other) -> bool"""
|
|
return _datamodel.DataSegment___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(DataSegment self, DataSegment other) -> bool"""
|
|
return _datamodel.DataSegment_equal(self, other)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(DataSegment self, Time start)"""
|
|
return _datamodel.DataSegment_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(DataSegment self) -> Time"""
|
|
return _datamodel.DataSegment_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(DataSegment self, Time end)"""
|
|
return _datamodel.DataSegment_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(DataSegment self) -> Time"""
|
|
return _datamodel.DataSegment_end(self)
|
|
|
|
def setUpdated(self, updated):
|
|
r"""setUpdated(DataSegment self, Time updated)"""
|
|
return _datamodel.DataSegment_setUpdated(self, updated)
|
|
|
|
def updated(self):
|
|
r"""updated(DataSegment self) -> Time"""
|
|
return _datamodel.DataSegment_updated(self)
|
|
|
|
def setSampleRate(self, sampleRate):
|
|
r"""setSampleRate(DataSegment self, double sampleRate)"""
|
|
return _datamodel.DataSegment_setSampleRate(self, sampleRate)
|
|
|
|
def sampleRate(self):
|
|
r"""sampleRate(DataSegment self) -> double"""
|
|
return _datamodel.DataSegment_sampleRate(self)
|
|
|
|
def setQuality(self, quality):
|
|
r"""setQuality(DataSegment self, std::string const & quality)"""
|
|
return _datamodel.DataSegment_setQuality(self, quality)
|
|
|
|
def quality(self):
|
|
r"""quality(DataSegment self) -> std::string const &"""
|
|
return _datamodel.DataSegment_quality(self)
|
|
|
|
def setOutOfOrder(self, outOfOrder):
|
|
r"""setOutOfOrder(DataSegment self, bool outOfOrder)"""
|
|
return _datamodel.DataSegment_setOutOfOrder(self, outOfOrder)
|
|
|
|
def outOfOrder(self):
|
|
r"""outOfOrder(DataSegment self) -> bool"""
|
|
return _datamodel.DataSegment_outOfOrder(self)
|
|
|
|
def index(self):
|
|
r"""index(DataSegment self) -> DataSegmentIndex"""
|
|
return _datamodel.DataSegment_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(DataSegment self, DataSegment lhs) -> bool"""
|
|
return _datamodel.DataSegment_equalIndex(self, lhs)
|
|
|
|
def dataExtent(self):
|
|
r"""dataExtent(DataSegment self) -> DataExtent"""
|
|
return _datamodel.DataSegment_dataExtent(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(DataSegment self, Object other) -> bool"""
|
|
return _datamodel.DataSegment_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(DataSegment self, PublicObject parent) -> bool"""
|
|
return _datamodel.DataSegment_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(DataSegment self, PublicObject parent) -> bool"""
|
|
return _datamodel.DataSegment_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(DataSegment self) -> bool"""
|
|
return _datamodel.DataSegment_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(DataSegment self) -> Object"""
|
|
return _datamodel.DataSegment_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(DataSegment self, Visitor visitor)"""
|
|
return _datamodel.DataSegment_accept(self, visitor)
|
|
|
|
# Register DataSegment in _datamodel:
|
|
_datamodel.DataSegment_swigregister(DataSegment)
|
|
|
|
def DataSegment_ClassName():
|
|
r"""DataSegment_ClassName() -> char const *"""
|
|
return _datamodel.DataSegment_ClassName()
|
|
|
|
def DataSegment_TypeInfo():
|
|
r"""DataSegment_TypeInfo() -> RTTI"""
|
|
return _datamodel.DataSegment_TypeInfo()
|
|
|
|
def DataSegment_Cast(*args):
|
|
r"""
|
|
DataSegment_Cast(BaseObject o) -> DataSegment
|
|
DataSegment_Cast(Seiscomp::Core::BaseObjectPtr o) -> DataSegment
|
|
"""
|
|
return _datamodel.DataSegment_Cast(*args)
|
|
|
|
def DataSegment_ConstCast(*args):
|
|
r"""
|
|
DataSegment_ConstCast(BaseObject o) -> DataSegment
|
|
DataSegment_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataSegment
|
|
"""
|
|
return _datamodel.DataSegment_ConstCast(*args)
|
|
|
|
def DataSegment_Meta():
|
|
r"""DataSegment_Meta() -> MetaObject"""
|
|
return _datamodel.DataSegment_Meta()
|
|
|
|
class DataAttributeExtentIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DataAttributeExtentIndex 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__(DataAttributeExtentIndex self) -> DataAttributeExtentIndex
|
|
__init__(DataAttributeExtentIndex self, double sampleRate, std::string const & quality) -> DataAttributeExtentIndex
|
|
__init__(DataAttributeExtentIndex self, DataAttributeExtentIndex arg2) -> DataAttributeExtentIndex
|
|
"""
|
|
_datamodel.DataAttributeExtentIndex_swiginit(self, _datamodel.new_DataAttributeExtentIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(DataAttributeExtentIndex self, DataAttributeExtentIndex arg2) -> bool"""
|
|
return _datamodel.DataAttributeExtentIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(DataAttributeExtentIndex self, DataAttributeExtentIndex arg2) -> bool"""
|
|
return _datamodel.DataAttributeExtentIndex___ne__(self, arg2)
|
|
sampleRate = property(_datamodel.DataAttributeExtentIndex_sampleRate_get, _datamodel.DataAttributeExtentIndex_sampleRate_set, doc=r"""sampleRate : double""")
|
|
quality = property(_datamodel.DataAttributeExtentIndex_quality_get, _datamodel.DataAttributeExtentIndex_quality_set, doc=r"""quality : std::string""")
|
|
__swig_destroy__ = _datamodel.delete_DataAttributeExtentIndex
|
|
|
|
# Register DataAttributeExtentIndex in _datamodel:
|
|
_datamodel.DataAttributeExtentIndex_swigregister(DataAttributeExtentIndex)
|
|
|
|
class DataAttributeExtent(Object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DataAttributeExtent 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 _datamodel.DataAttributeExtent_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.DataAttributeExtent_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(DataAttributeExtent self) -> char const *"""
|
|
return _datamodel.DataAttributeExtent_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(DataAttributeExtent self) -> RTTI"""
|
|
return _datamodel.DataAttributeExtent_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> DataAttributeExtent
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> DataAttributeExtent
|
|
"""
|
|
return _datamodel.DataAttributeExtent_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> DataAttributeExtent
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataAttributeExtent
|
|
"""
|
|
return _datamodel.DataAttributeExtent_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(DataAttributeExtent self, GenericArchive ar)"""
|
|
return _datamodel.DataAttributeExtent_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.DataAttributeExtent_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(DataAttributeExtent self) -> MetaObject"""
|
|
return _datamodel.DataAttributeExtent_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(DataAttributeExtent self) -> DataAttributeExtent
|
|
__init__(DataAttributeExtent self, DataAttributeExtent other) -> DataAttributeExtent
|
|
"""
|
|
_datamodel.DataAttributeExtent_swiginit(self, _datamodel.new_DataAttributeExtent(*args))
|
|
__swig_destroy__ = _datamodel.delete_DataAttributeExtent
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(DataAttributeExtent self, DataAttributeExtent other) -> bool"""
|
|
return _datamodel.DataAttributeExtent___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(DataAttributeExtent self, DataAttributeExtent other) -> bool"""
|
|
return _datamodel.DataAttributeExtent___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(DataAttributeExtent self, DataAttributeExtent other) -> bool"""
|
|
return _datamodel.DataAttributeExtent_equal(self, other)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(DataAttributeExtent self, Time start)"""
|
|
return _datamodel.DataAttributeExtent_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(DataAttributeExtent self) -> Time"""
|
|
return _datamodel.DataAttributeExtent_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(DataAttributeExtent self, Time end)"""
|
|
return _datamodel.DataAttributeExtent_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(DataAttributeExtent self) -> Time"""
|
|
return _datamodel.DataAttributeExtent_end(self)
|
|
|
|
def setSampleRate(self, sampleRate):
|
|
r"""setSampleRate(DataAttributeExtent self, double sampleRate)"""
|
|
return _datamodel.DataAttributeExtent_setSampleRate(self, sampleRate)
|
|
|
|
def sampleRate(self):
|
|
r"""sampleRate(DataAttributeExtent self) -> double"""
|
|
return _datamodel.DataAttributeExtent_sampleRate(self)
|
|
|
|
def setQuality(self, quality):
|
|
r"""setQuality(DataAttributeExtent self, std::string const & quality)"""
|
|
return _datamodel.DataAttributeExtent_setQuality(self, quality)
|
|
|
|
def quality(self):
|
|
r"""quality(DataAttributeExtent self) -> std::string const &"""
|
|
return _datamodel.DataAttributeExtent_quality(self)
|
|
|
|
def setUpdated(self, updated):
|
|
r"""setUpdated(DataAttributeExtent self, Time updated)"""
|
|
return _datamodel.DataAttributeExtent_setUpdated(self, updated)
|
|
|
|
def updated(self):
|
|
r"""updated(DataAttributeExtent self) -> Time"""
|
|
return _datamodel.DataAttributeExtent_updated(self)
|
|
|
|
def setSegmentCount(self, segmentCount):
|
|
r"""setSegmentCount(DataAttributeExtent self, int segmentCount)"""
|
|
return _datamodel.DataAttributeExtent_setSegmentCount(self, segmentCount)
|
|
|
|
def segmentCount(self):
|
|
r"""segmentCount(DataAttributeExtent self) -> int"""
|
|
return _datamodel.DataAttributeExtent_segmentCount(self)
|
|
|
|
def index(self):
|
|
r"""index(DataAttributeExtent self) -> DataAttributeExtentIndex"""
|
|
return _datamodel.DataAttributeExtent_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(DataAttributeExtent self, DataAttributeExtent lhs) -> bool"""
|
|
return _datamodel.DataAttributeExtent_equalIndex(self, lhs)
|
|
|
|
def dataExtent(self):
|
|
r"""dataExtent(DataAttributeExtent self) -> DataExtent"""
|
|
return _datamodel.DataAttributeExtent_dataExtent(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(DataAttributeExtent self, Object other) -> bool"""
|
|
return _datamodel.DataAttributeExtent_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(DataAttributeExtent self, PublicObject parent) -> bool"""
|
|
return _datamodel.DataAttributeExtent_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(DataAttributeExtent self, PublicObject parent) -> bool"""
|
|
return _datamodel.DataAttributeExtent_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(DataAttributeExtent self) -> bool"""
|
|
return _datamodel.DataAttributeExtent_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(DataAttributeExtent self) -> Object"""
|
|
return _datamodel.DataAttributeExtent_clone(self)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(DataAttributeExtent self, Visitor visitor)"""
|
|
return _datamodel.DataAttributeExtent_accept(self, visitor)
|
|
|
|
# Register DataAttributeExtent in _datamodel:
|
|
_datamodel.DataAttributeExtent_swigregister(DataAttributeExtent)
|
|
|
|
def DataAttributeExtent_ClassName():
|
|
r"""DataAttributeExtent_ClassName() -> char const *"""
|
|
return _datamodel.DataAttributeExtent_ClassName()
|
|
|
|
def DataAttributeExtent_TypeInfo():
|
|
r"""DataAttributeExtent_TypeInfo() -> RTTI"""
|
|
return _datamodel.DataAttributeExtent_TypeInfo()
|
|
|
|
def DataAttributeExtent_Cast(*args):
|
|
r"""
|
|
DataAttributeExtent_Cast(BaseObject o) -> DataAttributeExtent
|
|
DataAttributeExtent_Cast(Seiscomp::Core::BaseObjectPtr o) -> DataAttributeExtent
|
|
"""
|
|
return _datamodel.DataAttributeExtent_Cast(*args)
|
|
|
|
def DataAttributeExtent_ConstCast(*args):
|
|
r"""
|
|
DataAttributeExtent_ConstCast(BaseObject o) -> DataAttributeExtent
|
|
DataAttributeExtent_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataAttributeExtent
|
|
"""
|
|
return _datamodel.DataAttributeExtent_ConstCast(*args)
|
|
|
|
def DataAttributeExtent_Meta():
|
|
r"""DataAttributeExtent_Meta() -> MetaObject"""
|
|
return _datamodel.DataAttributeExtent_Meta()
|
|
|
|
class DataExtentIndex(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DataExtentIndex 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__(DataExtentIndex self) -> DataExtentIndex
|
|
__init__(DataExtentIndex self, WaveformStreamID waveformID) -> DataExtentIndex
|
|
__init__(DataExtentIndex self, DataExtentIndex arg2) -> DataExtentIndex
|
|
"""
|
|
_datamodel.DataExtentIndex_swiginit(self, _datamodel.new_DataExtentIndex(*args))
|
|
|
|
def __eq__(self, arg2):
|
|
r"""__eq__(DataExtentIndex self, DataExtentIndex arg2) -> bool"""
|
|
return _datamodel.DataExtentIndex___eq__(self, arg2)
|
|
|
|
def __ne__(self, arg2):
|
|
r"""__ne__(DataExtentIndex self, DataExtentIndex arg2) -> bool"""
|
|
return _datamodel.DataExtentIndex___ne__(self, arg2)
|
|
waveformID = property(_datamodel.DataExtentIndex_waveformID_get, _datamodel.DataExtentIndex_waveformID_set, doc=r"""waveformID : Seiscomp::DataModel::WaveformStreamID""")
|
|
__swig_destroy__ = _datamodel.delete_DataExtentIndex
|
|
|
|
# Register DataExtentIndex in _datamodel:
|
|
_datamodel.DataExtentIndex_swigregister(DataExtentIndex)
|
|
|
|
class DataExtent(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DataExtent 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 _datamodel.DataExtent_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.DataExtent_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(DataExtent self) -> char const *"""
|
|
return _datamodel.DataExtent_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(DataExtent self) -> RTTI"""
|
|
return _datamodel.DataExtent_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> DataExtent
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> DataExtent
|
|
"""
|
|
return _datamodel.DataExtent_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> DataExtent
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataExtent
|
|
"""
|
|
return _datamodel.DataExtent_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(DataExtent self, GenericArchive ar)"""
|
|
return _datamodel.DataExtent_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.DataExtent_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(DataExtent self) -> MetaObject"""
|
|
return _datamodel.DataExtent_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(DataExtent self, DataExtent other) -> DataExtent
|
|
__init__(DataExtent self, std::string const & publicID) -> DataExtent
|
|
"""
|
|
_datamodel.DataExtent_swiginit(self, _datamodel.new_DataExtent(*args))
|
|
__swig_destroy__ = _datamodel.delete_DataExtent
|
|
|
|
@staticmethod
|
|
def Create(*args):
|
|
r"""
|
|
Create() -> DataExtent
|
|
Create(std::string const & publicID) -> DataExtent
|
|
"""
|
|
return _datamodel.DataExtent_Create(*args)
|
|
|
|
@staticmethod
|
|
def Find(publicID):
|
|
r"""Find(std::string const & publicID) -> DataExtent"""
|
|
return _datamodel.DataExtent_Find(publicID)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(DataExtent self, DataExtent other) -> bool"""
|
|
return _datamodel.DataExtent___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(DataExtent self, DataExtent other) -> bool"""
|
|
return _datamodel.DataExtent___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(DataExtent self, DataExtent other) -> bool"""
|
|
return _datamodel.DataExtent_equal(self, other)
|
|
|
|
def setWaveformID(self, waveformID):
|
|
r"""setWaveformID(DataExtent self, WaveformStreamID waveformID)"""
|
|
return _datamodel.DataExtent_setWaveformID(self, waveformID)
|
|
|
|
def waveformID(self, *args):
|
|
r"""
|
|
waveformID(DataExtent self) -> WaveformStreamID
|
|
waveformID(DataExtent self) -> WaveformStreamID
|
|
"""
|
|
return _datamodel.DataExtent_waveformID(self, *args)
|
|
|
|
def setStart(self, start):
|
|
r"""setStart(DataExtent self, Time start)"""
|
|
return _datamodel.DataExtent_setStart(self, start)
|
|
|
|
def start(self):
|
|
r"""start(DataExtent self) -> Time"""
|
|
return _datamodel.DataExtent_start(self)
|
|
|
|
def setEnd(self, end):
|
|
r"""setEnd(DataExtent self, Time end)"""
|
|
return _datamodel.DataExtent_setEnd(self, end)
|
|
|
|
def end(self):
|
|
r"""end(DataExtent self) -> Time"""
|
|
return _datamodel.DataExtent_end(self)
|
|
|
|
def setUpdated(self, updated):
|
|
r"""setUpdated(DataExtent self, Time updated)"""
|
|
return _datamodel.DataExtent_setUpdated(self, updated)
|
|
|
|
def updated(self):
|
|
r"""updated(DataExtent self) -> Time"""
|
|
return _datamodel.DataExtent_updated(self)
|
|
|
|
def setLastScan(self, lastScan):
|
|
r"""setLastScan(DataExtent self, Time lastScan)"""
|
|
return _datamodel.DataExtent_setLastScan(self, lastScan)
|
|
|
|
def lastScan(self):
|
|
r"""lastScan(DataExtent self) -> Time"""
|
|
return _datamodel.DataExtent_lastScan(self)
|
|
|
|
def setSegmentOverflow(self, segmentOverflow):
|
|
r"""setSegmentOverflow(DataExtent self, bool segmentOverflow)"""
|
|
return _datamodel.DataExtent_setSegmentOverflow(self, segmentOverflow)
|
|
|
|
def segmentOverflow(self):
|
|
r"""segmentOverflow(DataExtent self) -> bool"""
|
|
return _datamodel.DataExtent_segmentOverflow(self)
|
|
|
|
def index(self):
|
|
r"""index(DataExtent self) -> DataExtentIndex"""
|
|
return _datamodel.DataExtent_index(self)
|
|
|
|
def equalIndex(self, lhs):
|
|
r"""equalIndex(DataExtent self, DataExtent lhs) -> bool"""
|
|
return _datamodel.DataExtent_equalIndex(self, lhs)
|
|
|
|
def add(self, *args):
|
|
r"""
|
|
add(DataExtent self, DataSegment obj) -> bool
|
|
add(DataExtent self, DataAttributeExtent obj) -> bool
|
|
"""
|
|
return _datamodel.DataExtent_add(self, *args)
|
|
|
|
def remove(self, *args):
|
|
r"""
|
|
remove(DataExtent self, DataSegment obj) -> bool
|
|
remove(DataExtent self, DataAttributeExtent obj) -> bool
|
|
"""
|
|
return _datamodel.DataExtent_remove(self, *args)
|
|
|
|
def removeDataSegment(self, *args):
|
|
r"""
|
|
removeDataSegment(DataExtent self, size_t i) -> bool
|
|
removeDataSegment(DataExtent self, DataSegmentIndex i) -> bool
|
|
"""
|
|
return _datamodel.DataExtent_removeDataSegment(self, *args)
|
|
|
|
def removeDataAttributeExtent(self, *args):
|
|
r"""
|
|
removeDataAttributeExtent(DataExtent self, size_t i) -> bool
|
|
removeDataAttributeExtent(DataExtent self, DataAttributeExtentIndex i) -> bool
|
|
"""
|
|
return _datamodel.DataExtent_removeDataAttributeExtent(self, *args)
|
|
|
|
def dataSegmentCount(self):
|
|
r"""dataSegmentCount(DataExtent self) -> size_t"""
|
|
return _datamodel.DataExtent_dataSegmentCount(self)
|
|
|
|
def dataAttributeExtentCount(self):
|
|
r"""dataAttributeExtentCount(DataExtent self) -> size_t"""
|
|
return _datamodel.DataExtent_dataAttributeExtentCount(self)
|
|
|
|
def dataSegment(self, *args):
|
|
r"""
|
|
dataSegment(DataExtent self, size_t i) -> DataSegment
|
|
dataSegment(DataExtent self, DataSegmentIndex i) -> DataSegment
|
|
"""
|
|
return _datamodel.DataExtent_dataSegment(self, *args)
|
|
|
|
def dataAttributeExtent(self, *args):
|
|
r"""
|
|
dataAttributeExtent(DataExtent self, size_t i) -> DataAttributeExtent
|
|
dataAttributeExtent(DataExtent self, DataAttributeExtentIndex i) -> DataAttributeExtent
|
|
"""
|
|
return _datamodel.DataExtent_dataAttributeExtent(self, *args)
|
|
|
|
def dataAvailability(self):
|
|
r"""dataAvailability(DataExtent self) -> DataAvailability"""
|
|
return _datamodel.DataExtent_dataAvailability(self)
|
|
|
|
def assign(self, other):
|
|
r"""assign(DataExtent self, Object other) -> bool"""
|
|
return _datamodel.DataExtent_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(DataExtent self, PublicObject parent) -> bool"""
|
|
return _datamodel.DataExtent_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(DataExtent self, PublicObject parent) -> bool"""
|
|
return _datamodel.DataExtent_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(DataExtent self) -> bool"""
|
|
return _datamodel.DataExtent_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(DataExtent self) -> Object"""
|
|
return _datamodel.DataExtent_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(DataExtent self, Object child) -> bool"""
|
|
return _datamodel.DataExtent_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(DataExtent self, Visitor visitor)"""
|
|
return _datamodel.DataExtent_accept(self, visitor)
|
|
|
|
# Register DataExtent in _datamodel:
|
|
_datamodel.DataExtent_swigregister(DataExtent)
|
|
|
|
def DataExtent_ClassName():
|
|
r"""DataExtent_ClassName() -> char const *"""
|
|
return _datamodel.DataExtent_ClassName()
|
|
|
|
def DataExtent_TypeInfo():
|
|
r"""DataExtent_TypeInfo() -> RTTI"""
|
|
return _datamodel.DataExtent_TypeInfo()
|
|
|
|
def DataExtent_Cast(*args):
|
|
r"""
|
|
DataExtent_Cast(BaseObject o) -> DataExtent
|
|
DataExtent_Cast(Seiscomp::Core::BaseObjectPtr o) -> DataExtent
|
|
"""
|
|
return _datamodel.DataExtent_Cast(*args)
|
|
|
|
def DataExtent_ConstCast(*args):
|
|
r"""
|
|
DataExtent_ConstCast(BaseObject o) -> DataExtent
|
|
DataExtent_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataExtent
|
|
"""
|
|
return _datamodel.DataExtent_ConstCast(*args)
|
|
|
|
def DataExtent_Meta():
|
|
r"""DataExtent_Meta() -> MetaObject"""
|
|
return _datamodel.DataExtent_Meta()
|
|
|
|
def DataExtent_Create(*args):
|
|
r"""
|
|
DataExtent_Create() -> DataExtent
|
|
DataExtent_Create(std::string const & publicID) -> DataExtent
|
|
"""
|
|
return _datamodel.DataExtent_Create(*args)
|
|
|
|
def DataExtent_Find(publicID):
|
|
r"""DataExtent_Find(std::string const & publicID) -> DataExtent"""
|
|
return _datamodel.DataExtent_Find(publicID)
|
|
|
|
class DataAvailability(PublicObject):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DataAvailability 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 _datamodel.DataAvailability_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.DataAvailability_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(DataAvailability self) -> char const *"""
|
|
return _datamodel.DataAvailability_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(DataAvailability self) -> RTTI"""
|
|
return _datamodel.DataAvailability_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> DataAvailability
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> DataAvailability
|
|
"""
|
|
return _datamodel.DataAvailability_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> DataAvailability
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataAvailability
|
|
"""
|
|
return _datamodel.DataAvailability_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(DataAvailability self, GenericArchive ar)"""
|
|
return _datamodel.DataAvailability_serialize(self, ar)
|
|
|
|
@staticmethod
|
|
def Meta():
|
|
r"""Meta() -> MetaObject"""
|
|
return _datamodel.DataAvailability_Meta()
|
|
|
|
def meta(self):
|
|
r"""meta(DataAvailability self) -> MetaObject"""
|
|
return _datamodel.DataAvailability_meta(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(DataAvailability self) -> DataAvailability
|
|
__init__(DataAvailability self, DataAvailability other) -> DataAvailability
|
|
"""
|
|
_datamodel.DataAvailability_swiginit(self, _datamodel.new_DataAvailability(*args))
|
|
__swig_destroy__ = _datamodel.delete_DataAvailability
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(DataAvailability self, DataAvailability other) -> bool"""
|
|
return _datamodel.DataAvailability___eq__(self, other)
|
|
|
|
def __ne__(self, other):
|
|
r"""__ne__(DataAvailability self, DataAvailability other) -> bool"""
|
|
return _datamodel.DataAvailability___ne__(self, other)
|
|
|
|
def equal(self, other):
|
|
r"""equal(DataAvailability self, DataAvailability other) -> bool"""
|
|
return _datamodel.DataAvailability_equal(self, other)
|
|
|
|
def add(self, obj):
|
|
r"""add(DataAvailability self, DataExtent obj) -> bool"""
|
|
return _datamodel.DataAvailability_add(self, obj)
|
|
|
|
def remove(self, obj):
|
|
r"""remove(DataAvailability self, DataExtent obj) -> bool"""
|
|
return _datamodel.DataAvailability_remove(self, obj)
|
|
|
|
def removeDataExtent(self, *args):
|
|
r"""
|
|
removeDataExtent(DataAvailability self, size_t i) -> bool
|
|
removeDataExtent(DataAvailability self, DataExtentIndex i) -> bool
|
|
"""
|
|
return _datamodel.DataAvailability_removeDataExtent(self, *args)
|
|
|
|
def dataExtentCount(self):
|
|
r"""dataExtentCount(DataAvailability self) -> size_t"""
|
|
return _datamodel.DataAvailability_dataExtentCount(self)
|
|
|
|
def dataExtent(self, *args):
|
|
r"""
|
|
dataExtent(DataAvailability self, size_t i) -> DataExtent
|
|
dataExtent(DataAvailability self, DataExtentIndex i) -> DataExtent
|
|
"""
|
|
return _datamodel.DataAvailability_dataExtent(self, *args)
|
|
|
|
def findDataExtent(self, publicID):
|
|
r"""findDataExtent(DataAvailability self, std::string const & publicID) -> DataExtent"""
|
|
return _datamodel.DataAvailability_findDataExtent(self, publicID)
|
|
|
|
def assign(self, other):
|
|
r"""assign(DataAvailability self, Object other) -> bool"""
|
|
return _datamodel.DataAvailability_assign(self, other)
|
|
|
|
def attachTo(self, parent):
|
|
r"""attachTo(DataAvailability self, PublicObject parent) -> bool"""
|
|
return _datamodel.DataAvailability_attachTo(self, parent)
|
|
|
|
def detachFrom(self, parent):
|
|
r"""detachFrom(DataAvailability self, PublicObject parent) -> bool"""
|
|
return _datamodel.DataAvailability_detachFrom(self, parent)
|
|
|
|
def detach(self):
|
|
r"""detach(DataAvailability self) -> bool"""
|
|
return _datamodel.DataAvailability_detach(self)
|
|
|
|
def clone(self):
|
|
r"""clone(DataAvailability self) -> Object"""
|
|
return _datamodel.DataAvailability_clone(self)
|
|
|
|
def updateChild(self, child):
|
|
r"""updateChild(DataAvailability self, Object child) -> bool"""
|
|
return _datamodel.DataAvailability_updateChild(self, child)
|
|
|
|
def accept(self, visitor):
|
|
r"""accept(DataAvailability self, Visitor visitor)"""
|
|
return _datamodel.DataAvailability_accept(self, visitor)
|
|
|
|
# Register DataAvailability in _datamodel:
|
|
_datamodel.DataAvailability_swigregister(DataAvailability)
|
|
|
|
def DataAvailability_ClassName():
|
|
r"""DataAvailability_ClassName() -> char const *"""
|
|
return _datamodel.DataAvailability_ClassName()
|
|
|
|
def DataAvailability_TypeInfo():
|
|
r"""DataAvailability_TypeInfo() -> RTTI"""
|
|
return _datamodel.DataAvailability_TypeInfo()
|
|
|
|
def DataAvailability_Cast(*args):
|
|
r"""
|
|
DataAvailability_Cast(BaseObject o) -> DataAvailability
|
|
DataAvailability_Cast(Seiscomp::Core::BaseObjectPtr o) -> DataAvailability
|
|
"""
|
|
return _datamodel.DataAvailability_Cast(*args)
|
|
|
|
def DataAvailability_ConstCast(*args):
|
|
r"""
|
|
DataAvailability_ConstCast(BaseObject o) -> DataAvailability
|
|
DataAvailability_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DataAvailability
|
|
"""
|
|
return _datamodel.DataAvailability_ConstCast(*args)
|
|
|
|
def DataAvailability_Meta():
|
|
r"""DataAvailability_Meta() -> MetaObject"""
|
|
return _datamodel.DataAvailability_Meta()
|
|
|
|
class DatabaseReader(DatabaseArchive):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DatabaseReader 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, dbDriver):
|
|
r"""__init__(DatabaseReader self, DatabaseInterface dbDriver) -> DatabaseReader"""
|
|
_datamodel.DatabaseReader_swiginit(self, _datamodel.new_DatabaseReader(dbDriver))
|
|
__swig_destroy__ = _datamodel.delete_DatabaseReader
|
|
|
|
def loadObject(self, classType, publicID):
|
|
r"""loadObject(DatabaseReader self, RTTI classType, std::string const & publicID) -> PublicObject"""
|
|
return _datamodel.DatabaseReader_loadObject(self, classType, publicID)
|
|
|
|
def loadEventParameters(self):
|
|
r"""loadEventParameters(DatabaseReader self) -> EventParameters"""
|
|
return _datamodel.DatabaseReader_loadEventParameters(self)
|
|
|
|
def loadPicks(self, arg2):
|
|
r"""loadPicks(DatabaseReader self, EventParameters arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadPicks(self, arg2)
|
|
|
|
def loadAmplitudes(self, arg2):
|
|
r"""loadAmplitudes(DatabaseReader self, EventParameters arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadAmplitudes(self, arg2)
|
|
|
|
def loadReadings(self, arg2):
|
|
r"""loadReadings(DatabaseReader self, EventParameters arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadReadings(self, arg2)
|
|
|
|
def loadOrigins(self, arg2):
|
|
r"""loadOrigins(DatabaseReader self, EventParameters arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadOrigins(self, arg2)
|
|
|
|
def loadFocalMechanisms(self, arg2):
|
|
r"""loadFocalMechanisms(DatabaseReader self, EventParameters arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadFocalMechanisms(self, arg2)
|
|
|
|
def loadEvents(self, arg2):
|
|
r"""loadEvents(DatabaseReader self, EventParameters arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadEvents(self, arg2)
|
|
|
|
def loadPickReferences(self, arg2):
|
|
r"""loadPickReferences(DatabaseReader self, Reading arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadPickReferences(self, arg2)
|
|
|
|
def loadAmplitudeReferences(self, arg2):
|
|
r"""loadAmplitudeReferences(DatabaseReader self, Reading arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadAmplitudeReferences(self, arg2)
|
|
|
|
def loadCompositeTimes(self, arg2):
|
|
r"""loadCompositeTimes(DatabaseReader self, Origin arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadCompositeTimes(self, arg2)
|
|
|
|
def loadArrivals(self, arg2):
|
|
r"""loadArrivals(DatabaseReader self, Origin arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadArrivals(self, arg2)
|
|
|
|
def loadStationMagnitudes(self, arg2):
|
|
r"""loadStationMagnitudes(DatabaseReader self, Origin arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadStationMagnitudes(self, arg2)
|
|
|
|
def loadMagnitudes(self, arg2):
|
|
r"""loadMagnitudes(DatabaseReader self, Origin arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadMagnitudes(self, arg2)
|
|
|
|
def loadStationMagnitudeContributions(self, arg2):
|
|
r"""loadStationMagnitudeContributions(DatabaseReader self, Magnitude arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadStationMagnitudeContributions(self, arg2)
|
|
|
|
def loadMomentTensors(self, arg2):
|
|
r"""loadMomentTensors(DatabaseReader self, FocalMechanism arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadMomentTensors(self, arg2)
|
|
|
|
def loadDataUseds(self, arg2):
|
|
r"""loadDataUseds(DatabaseReader self, MomentTensor arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadDataUseds(self, arg2)
|
|
|
|
def loadMomentTensorPhaseSettings(self, arg2):
|
|
r"""loadMomentTensorPhaseSettings(DatabaseReader self, MomentTensor arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadMomentTensorPhaseSettings(self, arg2)
|
|
|
|
def loadMomentTensorStationContributions(self, arg2):
|
|
r"""loadMomentTensorStationContributions(DatabaseReader self, MomentTensor arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadMomentTensorStationContributions(self, arg2)
|
|
|
|
def loadMomentTensorComponentContributions(self, arg2):
|
|
r"""loadMomentTensorComponentContributions(DatabaseReader self, MomentTensorStationContribution arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadMomentTensorComponentContributions(self, arg2)
|
|
|
|
def loadEventDescriptions(self, arg2):
|
|
r"""loadEventDescriptions(DatabaseReader self, Event arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadEventDescriptions(self, arg2)
|
|
|
|
def loadOriginReferences(self, arg2):
|
|
r"""loadOriginReferences(DatabaseReader self, Event arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadOriginReferences(self, arg2)
|
|
|
|
def loadFocalMechanismReferences(self, arg2):
|
|
r"""loadFocalMechanismReferences(DatabaseReader self, Event arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadFocalMechanismReferences(self, arg2)
|
|
|
|
def loadConfig(self):
|
|
r"""loadConfig(DatabaseReader self) -> Config"""
|
|
return _datamodel.DatabaseReader_loadConfig(self)
|
|
|
|
def loadParameterSets(self, arg2):
|
|
r"""loadParameterSets(DatabaseReader self, Config arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadParameterSets(self, arg2)
|
|
|
|
def loadConfigModules(self, arg2):
|
|
r"""loadConfigModules(DatabaseReader self, Config arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadConfigModules(self, arg2)
|
|
|
|
def loadParameters(self, arg2):
|
|
r"""loadParameters(DatabaseReader self, ParameterSet arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadParameters(self, arg2)
|
|
|
|
def loadConfigStations(self, arg2):
|
|
r"""loadConfigStations(DatabaseReader self, ConfigModule arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadConfigStations(self, arg2)
|
|
|
|
def loadSetups(self, arg2):
|
|
r"""loadSetups(DatabaseReader self, ConfigStation arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadSetups(self, arg2)
|
|
|
|
def loadQualityControl(self):
|
|
r"""loadQualityControl(DatabaseReader self) -> QualityControl"""
|
|
return _datamodel.DatabaseReader_loadQualityControl(self)
|
|
|
|
def loadQCLogs(self, arg2):
|
|
r"""loadQCLogs(DatabaseReader self, QualityControl arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadQCLogs(self, arg2)
|
|
|
|
def loadWaveformQualitys(self, arg2):
|
|
r"""loadWaveformQualitys(DatabaseReader self, QualityControl arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadWaveformQualitys(self, arg2)
|
|
|
|
def loadOutages(self, arg2):
|
|
r"""loadOutages(DatabaseReader self, QualityControl arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadOutages(self, arg2)
|
|
|
|
def loadInventory(self):
|
|
r"""loadInventory(DatabaseReader self) -> Inventory"""
|
|
return _datamodel.DatabaseReader_loadInventory(self)
|
|
|
|
def loadStationGroups(self, arg2):
|
|
r"""loadStationGroups(DatabaseReader self, Inventory arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadStationGroups(self, arg2)
|
|
|
|
def loadAuxDevices(self, arg2):
|
|
r"""loadAuxDevices(DatabaseReader self, Inventory arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadAuxDevices(self, arg2)
|
|
|
|
def loadSensors(self, arg2):
|
|
r"""loadSensors(DatabaseReader self, Inventory arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadSensors(self, arg2)
|
|
|
|
def loadDataloggers(self, arg2):
|
|
r"""loadDataloggers(DatabaseReader self, Inventory arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadDataloggers(self, arg2)
|
|
|
|
def loadResponsePAZs(self, arg2):
|
|
r"""loadResponsePAZs(DatabaseReader self, Inventory arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadResponsePAZs(self, arg2)
|
|
|
|
def loadResponseFIRs(self, arg2):
|
|
r"""loadResponseFIRs(DatabaseReader self, Inventory arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadResponseFIRs(self, arg2)
|
|
|
|
def loadResponseIIRs(self, arg2):
|
|
r"""loadResponseIIRs(DatabaseReader self, Inventory arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadResponseIIRs(self, arg2)
|
|
|
|
def loadResponsePolynomials(self, arg2):
|
|
r"""loadResponsePolynomials(DatabaseReader self, Inventory arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadResponsePolynomials(self, arg2)
|
|
|
|
def loadResponseFAPs(self, arg2):
|
|
r"""loadResponseFAPs(DatabaseReader self, Inventory arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadResponseFAPs(self, arg2)
|
|
|
|
def loadNetworks(self, arg2):
|
|
r"""loadNetworks(DatabaseReader self, Inventory arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadNetworks(self, arg2)
|
|
|
|
def loadStationReferences(self, arg2):
|
|
r"""loadStationReferences(DatabaseReader self, StationGroup arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadStationReferences(self, arg2)
|
|
|
|
def loadAuxSources(self, arg2):
|
|
r"""loadAuxSources(DatabaseReader self, AuxDevice arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadAuxSources(self, arg2)
|
|
|
|
def loadSensorCalibrations(self, arg2):
|
|
r"""loadSensorCalibrations(DatabaseReader self, Sensor arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadSensorCalibrations(self, arg2)
|
|
|
|
def loadDataloggerCalibrations(self, arg2):
|
|
r"""loadDataloggerCalibrations(DatabaseReader self, Datalogger arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadDataloggerCalibrations(self, arg2)
|
|
|
|
def loadDecimations(self, arg2):
|
|
r"""loadDecimations(DatabaseReader self, Datalogger arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadDecimations(self, arg2)
|
|
|
|
def loadStations(self, arg2):
|
|
r"""loadStations(DatabaseReader self, Network arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadStations(self, arg2)
|
|
|
|
def loadSensorLocations(self, arg2):
|
|
r"""loadSensorLocations(DatabaseReader self, Station arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadSensorLocations(self, arg2)
|
|
|
|
def loadAuxStreams(self, arg2):
|
|
r"""loadAuxStreams(DatabaseReader self, SensorLocation arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadAuxStreams(self, arg2)
|
|
|
|
def loadStreams(self, arg2):
|
|
r"""loadStreams(DatabaseReader self, SensorLocation arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadStreams(self, arg2)
|
|
|
|
def loadComments(self, *args):
|
|
r"""
|
|
loadComments(DatabaseReader self, Pick arg2) -> int
|
|
loadComments(DatabaseReader self, Amplitude arg2) -> int
|
|
loadComments(DatabaseReader self, Origin arg2) -> int
|
|
loadComments(DatabaseReader self, StationMagnitude arg2) -> int
|
|
loadComments(DatabaseReader self, Magnitude arg2) -> int
|
|
loadComments(DatabaseReader self, FocalMechanism arg2) -> int
|
|
loadComments(DatabaseReader self, MomentTensor arg2) -> int
|
|
loadComments(DatabaseReader self, Event arg2) -> int
|
|
loadComments(DatabaseReader self, ParameterSet arg2) -> int
|
|
loadComments(DatabaseReader self, Parameter arg2) -> int
|
|
loadComments(DatabaseReader self, Network arg2) -> int
|
|
loadComments(DatabaseReader self, Station arg2) -> int
|
|
loadComments(DatabaseReader self, SensorLocation arg2) -> int
|
|
loadComments(DatabaseReader self, Stream arg2) -> int
|
|
"""
|
|
return _datamodel.DatabaseReader_loadComments(self, *args)
|
|
|
|
def loadRouting(self):
|
|
r"""loadRouting(DatabaseReader self) -> Routing"""
|
|
return _datamodel.DatabaseReader_loadRouting(self)
|
|
|
|
def loadRoutes(self, arg2):
|
|
r"""loadRoutes(DatabaseReader self, Routing arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadRoutes(self, arg2)
|
|
|
|
def loadAccesss(self, arg2):
|
|
r"""loadAccesss(DatabaseReader self, Routing arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadAccesss(self, arg2)
|
|
|
|
def loadRouteArclinks(self, arg2):
|
|
r"""loadRouteArclinks(DatabaseReader self, Route arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadRouteArclinks(self, arg2)
|
|
|
|
def loadRouteSeedlinks(self, arg2):
|
|
r"""loadRouteSeedlinks(DatabaseReader self, Route arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadRouteSeedlinks(self, arg2)
|
|
|
|
def loadJournaling(self):
|
|
r"""loadJournaling(DatabaseReader self) -> Journaling"""
|
|
return _datamodel.DatabaseReader_loadJournaling(self)
|
|
|
|
def loadJournalEntrys(self, arg2):
|
|
r"""loadJournalEntrys(DatabaseReader self, Journaling arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadJournalEntrys(self, arg2)
|
|
|
|
def loadArclinkLog(self):
|
|
r"""loadArclinkLog(DatabaseReader self) -> ArclinkLog"""
|
|
return _datamodel.DatabaseReader_loadArclinkLog(self)
|
|
|
|
def loadArclinkRequests(self, arg2):
|
|
r"""loadArclinkRequests(DatabaseReader self, ArclinkLog arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadArclinkRequests(self, arg2)
|
|
|
|
def loadArclinkUsers(self, arg2):
|
|
r"""loadArclinkUsers(DatabaseReader self, ArclinkLog arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadArclinkUsers(self, arg2)
|
|
|
|
def loadArclinkStatusLines(self, arg2):
|
|
r"""loadArclinkStatusLines(DatabaseReader self, ArclinkRequest arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadArclinkStatusLines(self, arg2)
|
|
|
|
def loadArclinkRequestLines(self, arg2):
|
|
r"""loadArclinkRequestLines(DatabaseReader self, ArclinkRequest arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadArclinkRequestLines(self, arg2)
|
|
|
|
def loadDataAvailability(self):
|
|
r"""loadDataAvailability(DatabaseReader self) -> DataAvailability"""
|
|
return _datamodel.DatabaseReader_loadDataAvailability(self)
|
|
|
|
def loadDataExtents(self, arg2):
|
|
r"""loadDataExtents(DatabaseReader self, DataAvailability arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadDataExtents(self, arg2)
|
|
|
|
def load(self, *args):
|
|
r"""
|
|
load(DatabaseReader self, EventParameters arg2) -> int
|
|
load(DatabaseReader self, Pick arg2) -> int
|
|
load(DatabaseReader self, Amplitude arg2) -> int
|
|
load(DatabaseReader self, Reading arg2) -> int
|
|
load(DatabaseReader self, Origin arg2) -> int
|
|
load(DatabaseReader self, StationMagnitude arg2) -> int
|
|
load(DatabaseReader self, Magnitude arg2) -> int
|
|
load(DatabaseReader self, FocalMechanism arg2) -> int
|
|
load(DatabaseReader self, MomentTensor arg2) -> int
|
|
load(DatabaseReader self, MomentTensorStationContribution arg2) -> int
|
|
load(DatabaseReader self, Event arg2) -> int
|
|
load(DatabaseReader self, Config arg2) -> int
|
|
load(DatabaseReader self, ParameterSet arg2) -> int
|
|
load(DatabaseReader self, Parameter arg2) -> int
|
|
load(DatabaseReader self, ConfigModule arg2) -> int
|
|
load(DatabaseReader self, ConfigStation arg2) -> int
|
|
load(DatabaseReader self, QualityControl arg2) -> int
|
|
load(DatabaseReader self, Inventory arg2) -> int
|
|
load(DatabaseReader self, StationGroup arg2) -> int
|
|
load(DatabaseReader self, AuxDevice arg2) -> int
|
|
load(DatabaseReader self, Sensor arg2) -> int
|
|
load(DatabaseReader self, Datalogger arg2) -> int
|
|
load(DatabaseReader self, Network arg2) -> int
|
|
load(DatabaseReader self, Station arg2) -> int
|
|
load(DatabaseReader self, SensorLocation arg2) -> int
|
|
load(DatabaseReader self, Stream arg2) -> int
|
|
load(DatabaseReader self, Routing arg2) -> int
|
|
load(DatabaseReader self, Route arg2) -> int
|
|
load(DatabaseReader self, Journaling arg2) -> int
|
|
load(DatabaseReader self, ArclinkLog arg2) -> int
|
|
load(DatabaseReader self, ArclinkRequest arg2) -> int
|
|
load(DatabaseReader self, DataAvailability arg2) -> int
|
|
load(DatabaseReader self, DataExtent arg2) -> int
|
|
"""
|
|
return _datamodel.DatabaseReader_load(self, *args)
|
|
|
|
def loadDataSegments(self, arg2):
|
|
r"""loadDataSegments(DatabaseReader self, DataExtent arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadDataSegments(self, arg2)
|
|
|
|
def loadDataAttributeExtents(self, arg2):
|
|
r"""loadDataAttributeExtents(DatabaseReader self, DataExtent arg2) -> int"""
|
|
return _datamodel.DatabaseReader_loadDataAttributeExtents(self, arg2)
|
|
|
|
# Register DatabaseReader in _datamodel:
|
|
_datamodel.DatabaseReader_swigregister(DatabaseReader)
|
|
|
|
class DatabaseQuery(DatabaseReader):
|
|
r"""Proxy of C++ Seiscomp::DataModel::DatabaseQuery 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, dbDriver):
|
|
r"""__init__(DatabaseQuery self, DatabaseInterface dbDriver) -> DatabaseQuery"""
|
|
_datamodel.DatabaseQuery_swiginit(self, _datamodel.new_DatabaseQuery(dbDriver))
|
|
__swig_destroy__ = _datamodel.delete_DatabaseQuery
|
|
|
|
def getStation(self, network_code, station_code, time):
|
|
r"""getStation(DatabaseQuery self, std::string const & network_code, std::string const & station_code, Time time) -> Station"""
|
|
return _datamodel.DatabaseQuery_getStation(self, network_code, station_code, time)
|
|
|
|
def getEvent(self, originID):
|
|
r"""getEvent(DatabaseQuery self, std::string const & originID) -> Event"""
|
|
return _datamodel.DatabaseQuery_getEvent(self, originID)
|
|
|
|
def getEventByPreferredMagnitudeID(self, magnitudeID):
|
|
r"""getEventByPreferredMagnitudeID(DatabaseQuery self, std::string const & magnitudeID) -> Event"""
|
|
return _datamodel.DatabaseQuery_getEventByPreferredMagnitudeID(self, magnitudeID)
|
|
|
|
def getEventForFocalMechanism(self, focalMechanismID):
|
|
r"""getEventForFocalMechanism(DatabaseQuery self, std::string const & focalMechanismID) -> Event"""
|
|
return _datamodel.DatabaseQuery_getEventForFocalMechanism(self, focalMechanismID)
|
|
|
|
def getEventByPublicID(self, eventID):
|
|
r"""getEventByPublicID(DatabaseQuery self, std::string const & eventID) -> Event"""
|
|
return _datamodel.DatabaseQuery_getEventByPublicID(self, eventID)
|
|
|
|
def getAmplitude(self, pickID, type):
|
|
r"""getAmplitude(DatabaseQuery self, std::string const & pickID, std::string const & type) -> Amplitude"""
|
|
return _datamodel.DatabaseQuery_getAmplitude(self, pickID, type)
|
|
|
|
def getAmplitudes(self, startTime, endTime):
|
|
r"""getAmplitudes(DatabaseQuery self, Time startTime, Time endTime) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getAmplitudes(self, startTime, endTime)
|
|
|
|
def getAmplitudesForPick(self, pickID):
|
|
r"""getAmplitudesForPick(DatabaseQuery self, std::string const & pickID) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getAmplitudesForPick(self, pickID)
|
|
|
|
def getAmplitudesForOrigin(self, originID):
|
|
r"""getAmplitudesForOrigin(DatabaseQuery self, std::string const & originID) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getAmplitudesForOrigin(self, originID)
|
|
|
|
def getOriginsForAmplitude(self, amplitudeID):
|
|
r"""getOriginsForAmplitude(DatabaseQuery self, std::string const & amplitudeID) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getOriginsForAmplitude(self, amplitudeID)
|
|
|
|
def getOriginByMagnitude(self, magnitudeID):
|
|
r"""getOriginByMagnitude(DatabaseQuery self, std::string const & magnitudeID) -> Origin"""
|
|
return _datamodel.DatabaseQuery_getOriginByMagnitude(self, magnitudeID)
|
|
|
|
def getArrivalsForAmplitude(self, amplitudeID):
|
|
r"""getArrivalsForAmplitude(DatabaseQuery self, std::string const & amplitudeID) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getArrivalsForAmplitude(self, amplitudeID)
|
|
|
|
def getPicks(self, *args):
|
|
r"""
|
|
getPicks(DatabaseQuery self, std::string const & originID) -> DatabaseIterator
|
|
getPicks(DatabaseQuery self, Time startTime, Time endTime) -> DatabaseIterator
|
|
getPicks(DatabaseQuery self, Time startTime, Time endTime, WaveformStreamID waveformID) -> DatabaseIterator
|
|
"""
|
|
return _datamodel.DatabaseQuery_getPicks(self, *args)
|
|
|
|
def getWaveformQuality(self, *args):
|
|
r"""
|
|
getWaveformQuality(DatabaseQuery self, std::string const & type) -> DatabaseIterator
|
|
getWaveformQuality(DatabaseQuery self, WaveformStreamID waveformID, std::string const & parameter, Time startTime, Time endTime) -> DatabaseIterator
|
|
getWaveformQuality(DatabaseQuery self, Time startTime, Time endTime) -> DatabaseIterator
|
|
getWaveformQuality(DatabaseQuery self, WaveformStreamID waveformID, std::string const & parameter, std::string const & type, Time startTime, Time endTime) -> DatabaseIterator
|
|
"""
|
|
return _datamodel.DatabaseQuery_getWaveformQuality(self, *args)
|
|
|
|
def getWaveformQualityDescending(self, waveformID, parameter, type):
|
|
r"""getWaveformQualityDescending(DatabaseQuery self, WaveformStreamID waveformID, std::string const & parameter, std::string const & type) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getWaveformQualityDescending(self, waveformID, parameter, type)
|
|
|
|
def getOutage(self, waveformID, startTime, endTime):
|
|
r"""getOutage(DatabaseQuery self, WaveformStreamID waveformID, Time startTime, Time endTime) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getOutage(self, waveformID, startTime, endTime)
|
|
|
|
def getQCLog(self, waveformID, startTime, endTime):
|
|
r"""getQCLog(DatabaseQuery self, WaveformStreamID waveformID, Time startTime, Time endTime) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getQCLog(self, waveformID, startTime, endTime)
|
|
|
|
def getPreferredOrigins(self, startTime, endTime, referenceOriginID):
|
|
r"""getPreferredOrigins(DatabaseQuery self, Time startTime, Time endTime, std::string const & referenceOriginID) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getPreferredOrigins(self, startTime, endTime, referenceOriginID)
|
|
|
|
def getPreferredMagnitudes(self, startTime, endTime, referenceMagnitudeID):
|
|
r"""getPreferredMagnitudes(DatabaseQuery self, Time startTime, Time endTime, std::string const & referenceMagnitudeID) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getPreferredMagnitudes(self, startTime, endTime, referenceMagnitudeID)
|
|
|
|
def getEvents(self, startTime, endTime):
|
|
r"""getEvents(DatabaseQuery self, Time startTime, Time endTime) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getEvents(self, startTime, endTime)
|
|
|
|
def getOrigins(self, eventID):
|
|
r"""getOrigins(DatabaseQuery self, std::string const & eventID) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getOrigins(self, eventID)
|
|
|
|
def getOriginsDescending(self, eventID):
|
|
r"""getOriginsDescending(DatabaseQuery self, std::string const & eventID) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getOriginsDescending(self, eventID)
|
|
|
|
def getFocalMechanismsDescending(self, eventID):
|
|
r"""getFocalMechanismsDescending(DatabaseQuery self, std::string const & eventID) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getFocalMechanismsDescending(self, eventID)
|
|
|
|
def getEventPickIDs(self, publicID):
|
|
r"""getEventPickIDs(DatabaseQuery self, std::string const & publicID) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getEventPickIDs(self, publicID)
|
|
|
|
def getEventPickIDsByWeight(self, publicID, weight):
|
|
r"""getEventPickIDsByWeight(DatabaseQuery self, std::string const & publicID, double weight) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getEventPickIDsByWeight(self, publicID, weight)
|
|
|
|
def getEventPicks(self, eventID):
|
|
r"""getEventPicks(DatabaseQuery self, std::string const & eventID) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getEventPicks(self, eventID)
|
|
|
|
def getEventPicksByWeight(self, publicID, weight):
|
|
r"""getEventPicksByWeight(DatabaseQuery self, std::string const & publicID, double weight) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getEventPicksByWeight(self, publicID, weight)
|
|
|
|
def getConfigModule(self, name, enabled):
|
|
r"""getConfigModule(DatabaseQuery self, std::string const & name, bool enabled) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getConfigModule(self, name, enabled)
|
|
|
|
def getEquivalentPick(self, stationCode, networkCode, locationCode, channelCode, startTime, endTime):
|
|
r"""getEquivalentPick(DatabaseQuery self, std::string const & stationCode, std::string const & networkCode, std::string const & locationCode, std::string const & channelCode, Time startTime, Time endTime) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getEquivalentPick(self, stationCode, networkCode, locationCode, channelCode, startTime, endTime)
|
|
|
|
def getJournal(self, objectID):
|
|
r"""getJournal(DatabaseQuery self, std::string const & objectID) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getJournal(self, objectID)
|
|
|
|
def getJournalAction(self, objectID, action):
|
|
r"""getJournalAction(DatabaseQuery self, std::string const & objectID, std::string const & action) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getJournalAction(self, objectID, action)
|
|
|
|
def getArclinkRequestByStreamCode(self, startTime, endTime, networkCode, stationCode, locationCode, channelCode, type):
|
|
r"""getArclinkRequestByStreamCode(DatabaseQuery self, Time startTime, Time endTime, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode, std::string const & type) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getArclinkRequestByStreamCode(self, startTime, endTime, networkCode, stationCode, locationCode, channelCode, type)
|
|
|
|
def getArclinkRequestByRequestID(self, requestID):
|
|
r"""getArclinkRequestByRequestID(DatabaseQuery self, std::string const & requestID) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getArclinkRequestByRequestID(self, requestID)
|
|
|
|
def getArclinkRequestByUserID(self, userID, startTime, endTime, type):
|
|
r"""getArclinkRequestByUserID(DatabaseQuery self, std::string const & userID, Time startTime, Time endTime, std::string const & type) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getArclinkRequestByUserID(self, userID, startTime, endTime, type)
|
|
|
|
def getArclinkRequestByTime(self, startTime, endTime, type):
|
|
r"""getArclinkRequestByTime(DatabaseQuery self, Time startTime, Time endTime, std::string const & type) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getArclinkRequestByTime(self, startTime, endTime, type)
|
|
|
|
def getArclinkRequest(self, userID, startTime, endTime, networkCode, stationCode, locationCode, channelCode, type, netClass):
|
|
r"""getArclinkRequest(DatabaseQuery self, std::string const & userID, Time startTime, Time endTime, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode, std::string const & type, std::string const & netClass) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getArclinkRequest(self, userID, startTime, endTime, networkCode, stationCode, locationCode, channelCode, type, netClass)
|
|
|
|
def getArclinkRequestRestricted(self, userID, startTime, endTime, networkCode, stationCode, locationCode, channelCode, type, netClass, restricted):
|
|
r"""getArclinkRequestRestricted(DatabaseQuery self, std::string const & userID, Time startTime, Time endTime, std::string const & networkCode, std::string const & stationCode, std::string const & locationCode, std::string const & channelCode, std::string const & type, std::string const & netClass, bool restricted) -> DatabaseIterator"""
|
|
return _datamodel.DatabaseQuery_getArclinkRequestRestricted(self, userID, startTime, endTime, networkCode, stationCode, locationCode, channelCode, type, netClass, restricted)
|
|
|
|
# Register DatabaseQuery in _datamodel:
|
|
_datamodel.DatabaseQuery_swigregister(DatabaseQuery)
|
|
|
|
class ConfigSyncMessage(seiscomp.core.Message):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ConfigSyncMessage 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 _datamodel.ConfigSyncMessage_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ConfigSyncMessage_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ConfigSyncMessage self) -> char const *"""
|
|
return _datamodel.ConfigSyncMessage_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ConfigSyncMessage self) -> RTTI"""
|
|
return _datamodel.ConfigSyncMessage_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ConfigSyncMessage
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfigSyncMessage
|
|
"""
|
|
return _datamodel.ConfigSyncMessage_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ConfigSyncMessage
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfigSyncMessage
|
|
"""
|
|
return _datamodel.ConfigSyncMessage_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ConfigSyncMessage self, GenericArchive ar)"""
|
|
return _datamodel.ConfigSyncMessage_serialize(self, ar)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ConfigSyncMessage self) -> ConfigSyncMessage
|
|
__init__(ConfigSyncMessage self, bool finished) -> ConfigSyncMessage
|
|
"""
|
|
_datamodel.ConfigSyncMessage_swiginit(self, _datamodel.new_ConfigSyncMessage(*args))
|
|
|
|
def empty(self):
|
|
r"""empty(ConfigSyncMessage self) -> bool"""
|
|
return _datamodel.ConfigSyncMessage_empty(self)
|
|
|
|
def setCreationInfo(self, creationInfo):
|
|
r"""setCreationInfo(ConfigSyncMessage self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
|
|
return _datamodel.ConfigSyncMessage_setCreationInfo(self, creationInfo)
|
|
|
|
def creationInfo(self, *args):
|
|
r"""
|
|
creationInfo(ConfigSyncMessage self) -> CreationInfo
|
|
creationInfo(ConfigSyncMessage self) -> CreationInfo
|
|
"""
|
|
return _datamodel.ConfigSyncMessage_creationInfo(self, *args)
|
|
isFinished = property(_datamodel.ConfigSyncMessage_isFinished_get, _datamodel.ConfigSyncMessage_isFinished_set, doc=r"""isFinished : bool""")
|
|
__swig_destroy__ = _datamodel.delete_ConfigSyncMessage
|
|
|
|
# Register ConfigSyncMessage in _datamodel:
|
|
_datamodel.ConfigSyncMessage_swigregister(ConfigSyncMessage)
|
|
|
|
def ConfigSyncMessage_ClassName():
|
|
r"""ConfigSyncMessage_ClassName() -> char const *"""
|
|
return _datamodel.ConfigSyncMessage_ClassName()
|
|
|
|
def ConfigSyncMessage_TypeInfo():
|
|
r"""ConfigSyncMessage_TypeInfo() -> RTTI"""
|
|
return _datamodel.ConfigSyncMessage_TypeInfo()
|
|
|
|
def ConfigSyncMessage_Cast(*args):
|
|
r"""
|
|
ConfigSyncMessage_Cast(BaseObject o) -> ConfigSyncMessage
|
|
ConfigSyncMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> ConfigSyncMessage
|
|
"""
|
|
return _datamodel.ConfigSyncMessage_Cast(*args)
|
|
|
|
def ConfigSyncMessage_ConstCast(*args):
|
|
r"""
|
|
ConfigSyncMessage_ConstCast(BaseObject o) -> ConfigSyncMessage
|
|
ConfigSyncMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ConfigSyncMessage
|
|
"""
|
|
return _datamodel.ConfigSyncMessage_ConstCast(*args)
|
|
|
|
class InventorySyncMessage(seiscomp.core.Message):
|
|
r"""Proxy of C++ Seiscomp::DataModel::InventorySyncMessage 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 _datamodel.InventorySyncMessage_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.InventorySyncMessage_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(InventorySyncMessage self) -> char const *"""
|
|
return _datamodel.InventorySyncMessage_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(InventorySyncMessage self) -> RTTI"""
|
|
return _datamodel.InventorySyncMessage_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> InventorySyncMessage
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> InventorySyncMessage
|
|
"""
|
|
return _datamodel.InventorySyncMessage_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> InventorySyncMessage
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> InventorySyncMessage
|
|
"""
|
|
return _datamodel.InventorySyncMessage_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(InventorySyncMessage self, GenericArchive ar)"""
|
|
return _datamodel.InventorySyncMessage_serialize(self, ar)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(InventorySyncMessage self) -> InventorySyncMessage
|
|
__init__(InventorySyncMessage self, bool finished) -> InventorySyncMessage
|
|
"""
|
|
_datamodel.InventorySyncMessage_swiginit(self, _datamodel.new_InventorySyncMessage(*args))
|
|
|
|
def setCreationInfo(self, creationInfo):
|
|
r"""setCreationInfo(InventorySyncMessage self, Seiscomp::Core::Optional< Seiscomp::DataModel::CreationInfo >::Impl const & creationInfo)"""
|
|
return _datamodel.InventorySyncMessage_setCreationInfo(self, creationInfo)
|
|
|
|
def creationInfo(self, *args):
|
|
r"""
|
|
creationInfo(InventorySyncMessage self) -> CreationInfo
|
|
creationInfo(InventorySyncMessage self) -> CreationInfo
|
|
"""
|
|
return _datamodel.InventorySyncMessage_creationInfo(self, *args)
|
|
|
|
def empty(self):
|
|
r"""empty(InventorySyncMessage self) -> bool"""
|
|
return _datamodel.InventorySyncMessage_empty(self)
|
|
isFinished = property(_datamodel.InventorySyncMessage_isFinished_get, _datamodel.InventorySyncMessage_isFinished_set, doc=r"""isFinished : bool""")
|
|
__swig_destroy__ = _datamodel.delete_InventorySyncMessage
|
|
|
|
# Register InventorySyncMessage in _datamodel:
|
|
_datamodel.InventorySyncMessage_swigregister(InventorySyncMessage)
|
|
|
|
def InventorySyncMessage_ClassName():
|
|
r"""InventorySyncMessage_ClassName() -> char const *"""
|
|
return _datamodel.InventorySyncMessage_ClassName()
|
|
|
|
def InventorySyncMessage_TypeInfo():
|
|
r"""InventorySyncMessage_TypeInfo() -> RTTI"""
|
|
return _datamodel.InventorySyncMessage_TypeInfo()
|
|
|
|
def InventorySyncMessage_Cast(*args):
|
|
r"""
|
|
InventorySyncMessage_Cast(BaseObject o) -> InventorySyncMessage
|
|
InventorySyncMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> InventorySyncMessage
|
|
"""
|
|
return _datamodel.InventorySyncMessage_Cast(*args)
|
|
|
|
def InventorySyncMessage_ConstCast(*args):
|
|
r"""
|
|
InventorySyncMessage_ConstCast(BaseObject o) -> InventorySyncMessage
|
|
InventorySyncMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> InventorySyncMessage
|
|
"""
|
|
return _datamodel.InventorySyncMessage_ConstCast(*args)
|
|
|
|
class ArtificialOriginMessage(seiscomp.core.Message):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ArtificialOriginMessage 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 _datamodel.ArtificialOriginMessage_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ArtificialOriginMessage_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ArtificialOriginMessage self) -> char const *"""
|
|
return _datamodel.ArtificialOriginMessage_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ArtificialOriginMessage self) -> RTTI"""
|
|
return _datamodel.ArtificialOriginMessage_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ArtificialOriginMessage
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ArtificialOriginMessage
|
|
"""
|
|
return _datamodel.ArtificialOriginMessage_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ArtificialOriginMessage
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArtificialOriginMessage
|
|
"""
|
|
return _datamodel.ArtificialOriginMessage_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ArtificialOriginMessage self, GenericArchive ar)"""
|
|
return _datamodel.ArtificialOriginMessage_serialize(self, ar)
|
|
|
|
def __init__(self, origin):
|
|
r"""__init__(ArtificialOriginMessage self, Origin origin) -> ArtificialOriginMessage"""
|
|
_datamodel.ArtificialOriginMessage_swiginit(self, _datamodel.new_ArtificialOriginMessage(origin))
|
|
|
|
def origin(self):
|
|
r"""origin(ArtificialOriginMessage self) -> Origin"""
|
|
return _datamodel.ArtificialOriginMessage_origin(self)
|
|
|
|
def setOrigin(self, origin):
|
|
r"""setOrigin(ArtificialOriginMessage self, Origin origin)"""
|
|
return _datamodel.ArtificialOriginMessage_setOrigin(self, origin)
|
|
|
|
def empty(self):
|
|
r"""empty(ArtificialOriginMessage self) -> bool"""
|
|
return _datamodel.ArtificialOriginMessage_empty(self)
|
|
__swig_destroy__ = _datamodel.delete_ArtificialOriginMessage
|
|
|
|
# Register ArtificialOriginMessage in _datamodel:
|
|
_datamodel.ArtificialOriginMessage_swigregister(ArtificialOriginMessage)
|
|
|
|
def ArtificialOriginMessage_ClassName():
|
|
r"""ArtificialOriginMessage_ClassName() -> char const *"""
|
|
return _datamodel.ArtificialOriginMessage_ClassName()
|
|
|
|
def ArtificialOriginMessage_TypeInfo():
|
|
r"""ArtificialOriginMessage_TypeInfo() -> RTTI"""
|
|
return _datamodel.ArtificialOriginMessage_TypeInfo()
|
|
|
|
def ArtificialOriginMessage_Cast(*args):
|
|
r"""
|
|
ArtificialOriginMessage_Cast(BaseObject o) -> ArtificialOriginMessage
|
|
ArtificialOriginMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArtificialOriginMessage
|
|
"""
|
|
return _datamodel.ArtificialOriginMessage_Cast(*args)
|
|
|
|
def ArtificialOriginMessage_ConstCast(*args):
|
|
r"""
|
|
ArtificialOriginMessage_ConstCast(BaseObject o) -> ArtificialOriginMessage
|
|
ArtificialOriginMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArtificialOriginMessage
|
|
"""
|
|
return _datamodel.ArtificialOriginMessage_ConstCast(*args)
|
|
|
|
class ArtificialEventParametersMessage(seiscomp.core.Message):
|
|
r"""Proxy of C++ Seiscomp::DataModel::ArtificialEventParametersMessage 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 _datamodel.ArtificialEventParametersMessage_ClassName()
|
|
|
|
@staticmethod
|
|
def TypeInfo():
|
|
r"""TypeInfo() -> RTTI"""
|
|
return _datamodel.ArtificialEventParametersMessage_TypeInfo()
|
|
|
|
def className(self):
|
|
r"""className(ArtificialEventParametersMessage self) -> char const *"""
|
|
return _datamodel.ArtificialEventParametersMessage_className(self)
|
|
|
|
def typeInfo(self):
|
|
r"""typeInfo(ArtificialEventParametersMessage self) -> RTTI"""
|
|
return _datamodel.ArtificialEventParametersMessage_typeInfo(self)
|
|
|
|
@staticmethod
|
|
def Cast(*args):
|
|
r"""
|
|
Cast(BaseObject o) -> ArtificialEventParametersMessage
|
|
Cast(Seiscomp::Core::BaseObjectPtr o) -> ArtificialEventParametersMessage
|
|
"""
|
|
return _datamodel.ArtificialEventParametersMessage_Cast(*args)
|
|
|
|
@staticmethod
|
|
def ConstCast(*args):
|
|
r"""
|
|
ConstCast(BaseObject o) -> ArtificialEventParametersMessage
|
|
ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArtificialEventParametersMessage
|
|
"""
|
|
return _datamodel.ArtificialEventParametersMessage_ConstCast(*args)
|
|
|
|
def serialize(self, ar):
|
|
r"""serialize(ArtificialEventParametersMessage self, GenericArchive ar)"""
|
|
return _datamodel.ArtificialEventParametersMessage_serialize(self, ar)
|
|
|
|
def __init__(self, eventParameters):
|
|
r"""__init__(ArtificialEventParametersMessage self, EventParameters eventParameters) -> ArtificialEventParametersMessage"""
|
|
_datamodel.ArtificialEventParametersMessage_swiginit(self, _datamodel.new_ArtificialEventParametersMessage(eventParameters))
|
|
|
|
def eventParameters(self):
|
|
r"""eventParameters(ArtificialEventParametersMessage self) -> EventParameters"""
|
|
return _datamodel.ArtificialEventParametersMessage_eventParameters(self)
|
|
|
|
def setEventParameters(self, eventParameters):
|
|
r"""setEventParameters(ArtificialEventParametersMessage self, EventParameters eventParameters)"""
|
|
return _datamodel.ArtificialEventParametersMessage_setEventParameters(self, eventParameters)
|
|
|
|
def empty(self):
|
|
r"""empty(ArtificialEventParametersMessage self) -> bool"""
|
|
return _datamodel.ArtificialEventParametersMessage_empty(self)
|
|
__swig_destroy__ = _datamodel.delete_ArtificialEventParametersMessage
|
|
|
|
# Register ArtificialEventParametersMessage in _datamodel:
|
|
_datamodel.ArtificialEventParametersMessage_swigregister(ArtificialEventParametersMessage)
|
|
|
|
def ArtificialEventParametersMessage_ClassName():
|
|
r"""ArtificialEventParametersMessage_ClassName() -> char const *"""
|
|
return _datamodel.ArtificialEventParametersMessage_ClassName()
|
|
|
|
def ArtificialEventParametersMessage_TypeInfo():
|
|
r"""ArtificialEventParametersMessage_TypeInfo() -> RTTI"""
|
|
return _datamodel.ArtificialEventParametersMessage_TypeInfo()
|
|
|
|
def ArtificialEventParametersMessage_Cast(*args):
|
|
r"""
|
|
ArtificialEventParametersMessage_Cast(BaseObject o) -> ArtificialEventParametersMessage
|
|
ArtificialEventParametersMessage_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArtificialEventParametersMessage
|
|
"""
|
|
return _datamodel.ArtificialEventParametersMessage_Cast(*args)
|
|
|
|
def ArtificialEventParametersMessage_ConstCast(*args):
|
|
r"""
|
|
ArtificialEventParametersMessage_ConstCast(BaseObject o) -> ArtificialEventParametersMessage
|
|
ArtificialEventParametersMessage_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArtificialEventParametersMessage
|
|
"""
|
|
return _datamodel.ArtificialEventParametersMessage_ConstCast(*args)
|
|
|
|
SEISCOMP_DATAMODEL_XMLNS_ROOT = _datamodel.SEISCOMP_DATAMODEL_XMLNS_ROOT
|
|
|
|
SEISCOMP_DATAMODEL_XMLNS = _datamodel.SEISCOMP_DATAMODEL_XMLNS
|
|
|
|
class Version(object):
|
|
r"""Proxy of C++ Seiscomp::DataModel::Version class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
Major = _datamodel.Version_Major
|
|
|
|
Minor = _datamodel.Version_Minor
|
|
|
|
|
|
def __init__(self):
|
|
r"""__init__(Version self) -> Version"""
|
|
_datamodel.Version_swiginit(self, _datamodel.new_Version())
|
|
__swig_destroy__ = _datamodel.delete_Version
|
|
|
|
# Register Version in _datamodel:
|
|
_datamodel.Version_swigregister(Version)
|
|
|
|
|
|
def QML_NS():
|
|
r"""QML_NS() -> char const *"""
|
|
return _datamodel.QML_NS()
|
|
|
|
def QML_NS_RT():
|
|
r"""QML_NS_RT() -> char const *"""
|
|
return _datamodel.QML_NS_RT()
|
|
|
|
def QML_NS_BED():
|
|
r"""QML_NS_BED() -> char const *"""
|
|
return _datamodel.QML_NS_BED()
|
|
|
|
def QML_NS_BED_RT():
|
|
r"""QML_NS_BED_RT() -> char const *"""
|
|
return _datamodel.QML_NS_BED_RT()
|
|
|
|
def QML_SMIPrefix():
|
|
r"""QML_SMIPrefix() -> std::string const &"""
|
|
return _datamodel.QML_SMIPrefix()
|
|
class QMLTypeMapper(object):
|
|
r"""Proxy of C++ Seiscomp::QML::TypeMapper class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def EventTypeFromString(str):
|
|
r"""EventTypeFromString(std::string const & str) -> Seiscomp::DataModel::EventType"""
|
|
return _datamodel.QMLTypeMapper_EventTypeFromString(str)
|
|
|
|
@staticmethod
|
|
def EventTypeToString(type):
|
|
r"""EventTypeToString(Seiscomp::DataModel::EventType type) -> std::string"""
|
|
return _datamodel.QMLTypeMapper_EventTypeToString(type)
|
|
|
|
@staticmethod
|
|
def EventTypeCertaintyToString(type):
|
|
r"""EventTypeCertaintyToString(Seiscomp::DataModel::EventTypeCertainty type) -> std::string"""
|
|
return _datamodel.QMLTypeMapper_EventTypeCertaintyToString(type)
|
|
|
|
def __init__(self):
|
|
r"""__init__(QMLTypeMapper self) -> QMLTypeMapper"""
|
|
_datamodel.QMLTypeMapper_swiginit(self, _datamodel.new_QMLTypeMapper())
|
|
__swig_destroy__ = _datamodel.delete_QMLTypeMapper
|
|
|
|
# Register QMLTypeMapper in _datamodel:
|
|
_datamodel.QMLTypeMapper_swigregister(QMLTypeMapper)
|
|
cvar = _datamodel.cvar
|
|
QML_SMIPrefixEnvVar = cvar.QML_SMIPrefixEnvVar
|
|
|
|
def QMLTypeMapper_EventTypeFromString(str):
|
|
r"""QMLTypeMapper_EventTypeFromString(std::string const & str) -> Seiscomp::DataModel::EventType"""
|
|
return _datamodel.QMLTypeMapper_EventTypeFromString(str)
|
|
|
|
def QMLTypeMapper_EventTypeToString(type):
|
|
r"""QMLTypeMapper_EventTypeToString(Seiscomp::DataModel::EventType type) -> std::string"""
|
|
return _datamodel.QMLTypeMapper_EventTypeToString(type)
|
|
|
|
def QMLTypeMapper_EventTypeCertaintyToString(type):
|
|
r"""QMLTypeMapper_EventTypeCertaintyToString(Seiscomp::DataModel::EventTypeCertainty type) -> std::string"""
|
|
return _datamodel.QMLTypeMapper_EventTypeCertaintyToString(type)
|
|
|
|
|
|
|