# 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 _core else: import _core try: import builtins as __builtin__ except ImportError: import __builtin__ def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() except __builtin__.Exception: strthis = "" return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) def _swig_setattr_nondynamic_instance_variable(set): def set_instance_attr(self, name, value): if name == "thisown": self.this.own(value) elif name == "this": set(self, name, value) elif hasattr(self, name) and isinstance(getattr(type(self), name), property): set(self, name, value) else: raise AttributeError("You cannot add instance attributes to %s" % self) return set_instance_attr def _swig_setattr_nondynamic_class_variable(set): def set_class_attr(cls, name, value): if hasattr(cls, name) and not isinstance(getattr(cls, name), property): set(cls, name, value) else: raise AttributeError("You cannot add class attributes to %s" % cls) return set_class_attr def _swig_add_metaclass(metaclass): """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass""" def wrapper(cls): return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy()) return wrapper class _SwigNonDynamicMeta(type): """Meta class to enforce nondynamic attributes (no new attributes) for a class""" __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__) class RTTI(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, classname, parent=None): _core.RTTI_swiginit(self, _core.new_RTTI(classname, parent)) def __eq__(self, other): return _core.RTTI___eq__(self, other) def __ne__(self, other): return _core.RTTI___ne__(self, other) def parent(self): return _core.RTTI_parent(self) def className(self): return _core.RTTI_className(self) def before(self, other): return _core.RTTI_before(self, other) def isTypeOf(self, other): return _core.RTTI_isTypeOf(self, other) __swig_destroy__ = _core.delete_RTTI # Register RTTI in _core: _core.RTTI_swigregister(RTTI) class PropertyNotFoundException(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, *args): _core.PropertyNotFoundException_swiginit(self, _core.new_PropertyNotFoundException(*args)) __swig_destroy__ = _core.delete_PropertyNotFoundException # Register PropertyNotFoundException in _core: _core.PropertyNotFoundException_swigregister(PropertyNotFoundException) class MetaEnum(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__ = _core.delete_MetaEnum def keyCount(self): return _core.MetaEnum_keyCount(self) def key(self, index): return _core.MetaEnum_key(self, index) def valueToKey(self, value): return _core.MetaEnum_valueToKey(self, value) def keyToValue(self, key): return _core.MetaEnum_keyToValue(self, key) # Register MetaEnum in _core: _core.MetaEnum_swigregister(MetaEnum) class MetaProperty(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, *args): _core.MetaProperty_swiginit(self, _core.new_MetaProperty(*args)) __swig_destroy__ = _core.delete_MetaProperty def setInfo(self, name, type, isArray, isClass, isIndex, isReference, isOptional, isEnum, enumeration=None): return _core.MetaProperty_setInfo(self, name, type, isArray, isClass, isIndex, isReference, isOptional, isEnum, enumeration) def name(self): return _core.MetaProperty_name(self) def type(self): return _core.MetaProperty_type(self) def enumerator(self): return _core.MetaProperty_enumerator(self) def isArray(self): return _core.MetaProperty_isArray(self) def isClass(self): return _core.MetaProperty_isClass(self) def isIndex(self): return _core.MetaProperty_isIndex(self) def isReference(self): return _core.MetaProperty_isReference(self) def isEnum(self): return _core.MetaProperty_isEnum(self) def isOptional(self): return _core.MetaProperty_isOptional(self) def createClass(self): return _core.MetaProperty_createClass(self) def arrayElementCount(self, object): return _core.MetaProperty_arrayElementCount(self, object) def arrayObject(self, object, i): return _core.MetaProperty_arrayObject(self, object, i) def arrayAddObject(self, object, child): return _core.MetaProperty_arrayAddObject(self, object, child) def arrayRemoveObject(self, *args): return _core.MetaProperty_arrayRemoveObject(self, *args) def write(self, object, value): return _core.MetaProperty_write(self, object, value) def writeString(self, object, value): return _core.MetaProperty_writeString(self, object, value) def read(self, object): return _core.MetaProperty_read(self, object) def readString(self, object): return _core.MetaProperty_readString(self, object) # Register MetaProperty in _core: _core.MetaProperty_swigregister(MetaProperty) class MetaObject(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, rtti, base=None): _core.MetaObject_swiginit(self, _core.new_MetaObject(rtti, base)) __swig_destroy__ = _core.delete_MetaObject def rtti(self): return _core.MetaObject_rtti(self) def base(self): return _core.MetaObject_base(self) def propertyCount(self): return _core.MetaObject_propertyCount(self) def property(self, *args): return _core.MetaObject_property(self, *args) @staticmethod def Find(className): return _core.MetaObject_Find(className) # Register MetaObject in _core: _core.MetaObject_swigregister(MetaObject) def MetaObject_Find(className): return _core.MetaObject_Find(className) class TimeSpan(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, *args): _core.TimeSpan_swiginit(self, _core.new_TimeSpan(*args)) def __eq__(self, arg2): return _core.TimeSpan___eq__(self, arg2) def __ne__(self, arg2): return _core.TimeSpan___ne__(self, arg2) def __lt__(self, arg2): return _core.TimeSpan___lt__(self, arg2) def __le__(self, arg2): return _core.TimeSpan___le__(self, arg2) def __gt__(self, arg2): return _core.TimeSpan___gt__(self, arg2) def __ge__(self, arg2): return _core.TimeSpan___ge__(self, arg2) def __add__(self, arg2): return _core.TimeSpan___add__(self, arg2) def __sub__(self, arg2): return _core.TimeSpan___sub__(self, arg2) def __iadd__(self, arg2): return _core.TimeSpan___iadd__(self, arg2) def __isub__(self, arg2): return _core.TimeSpan___isub__(self, arg2) def abs(self): return _core.TimeSpan_abs(self) def seconds(self): return _core.TimeSpan_seconds(self) def microseconds(self): return _core.TimeSpan_microseconds(self) def length(self): return _core.TimeSpan_length(self) def set(self, seconds): return _core.TimeSpan_set(self, seconds) def setUSecs(self, arg2): return _core.TimeSpan_setUSecs(self, arg2) def elapsedTime(self, days, hours=None, minutes=None, seconds=None): return _core.TimeSpan_elapsedTime(self, days, hours, minutes, seconds) def toDouble(self): return _core.TimeSpan_toDouble(self) def __float__(self): return self.length() __swig_destroy__ = _core.delete_TimeSpan # Register TimeSpan in _core: _core.TimeSpan_swigregister(TimeSpan) cvar = _core.cvar TimeSpan.MinTime = _core.cvar.TimeSpan_MinTime TimeSpan.MaxTime = _core.cvar.TimeSpan_MaxTime class Time(TimeSpan): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, *args): _core.Time_swiginit(self, _core.new_Time(*args)) def __nonzero__(self): return _core.Time___nonzero__(self) __bool__ = __nonzero__ def __add__(self, arg2): return _core.Time___add__(self, arg2) def __sub__(self, *args): return _core.Time___sub__(self, *args) def __iadd__(self, arg2): return _core.Time___iadd__(self, arg2) def __isub__(self, arg2): return _core.Time___isub__(self, arg2) def set(self, year, month, day, hour, min, sec, usec): return _core.Time_set(self, year, month, day, hour, min, sec, usec) def set2(self, year, yday, hour, min, sec, usec): return _core.Time_set2(self, year, yday, hour, min, sec, usec) def get(self): return _core.Time_get(self) def get2(self): return _core.Time_get2(self) @staticmethod def LocalTime(): return _core.Time_LocalTime() @staticmethod def LocalTimeZone(): return _core.Time_LocalTimeZone() @staticmethod def UTC(): return _core.Time_UTC() @staticmethod def GMT(): return _core.Time_GMT() @staticmethod def FromYearDay(year, year_day): return _core.Time_FromYearDay(year, year_day) def localTimeZoneOffset(self): return _core.Time_localTimeZoneOffset(self) def localtime(self): return _core.Time_localtime(self) def utc(self): return _core.Time_utc(self) def gmt(self): return _core.Time_gmt(self) def toLocalTime(self): return _core.Time_toLocalTime(self) def toUTC(self): return _core.Time_toUTC(self) def toGMT(self): return _core.Time_toGMT(self) def valid(self): return _core.Time_valid(self) def toString(self, fmt): return _core.Time_toString(self, fmt) def iso(self): return _core.Time_iso(self) def fromString(self, str, fmt): return _core.Time_fromString(self, str, fmt) @staticmethod def FromString(str, fmt): return _core.Time_FromString(str, fmt) def __str__(self): return self.toString("%Y-%m-%d %H:%M:%S.%f000000")[:23] __swig_destroy__ = _core.delete_Time # Register Time in _core: _core.Time_swigregister(Time) Time.Null = _core.cvar.Time_Null def Time_LocalTime(): return _core.Time_LocalTime() def Time_LocalTimeZone(): return _core.Time_LocalTimeZone() def Time_UTC(): return _core.Time_UTC() def Time_GMT(): return _core.Time_GMT() def Time_FromYearDay(year, year_day): return _core.Time_FromYearDay(year, year_day) def Time_FromString(str, fmt): return _core.Time_FromString(str, fmt) class ValueError(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self): _core.ValueError_swiginit(self, _core.new_ValueError()) __swig_destroy__ = _core.delete_ValueError def what(self): return _core.ValueError_what(self) # Register ValueError in _core: _core.ValueError_swigregister(ValueError) Unset = cvar.Unset class Enumeration(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__ = _core.delete_Enumeration def toString(self): return _core.Enumeration_toString(self) def fromString(self, str): return _core.Enumeration_fromString(self, str) def toInt(self): return _core.Enumeration_toInt(self) def fromInt(self, value): return _core.Enumeration_fromInt(self, value) # Register Enumeration in _core: _core.Enumeration_swigregister(Enumeration) class GeneralException(Exception): 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): _core.GeneralException_swiginit(self, _core.new_GeneralException(*args)) __swig_destroy__ = _core.delete_GeneralException def what(self): return _core.GeneralException_what(self) def __str__(self): return self.what() # Register GeneralException in _core: _core.GeneralException_swigregister(GeneralException) class MemoryException(GeneralException): 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): _core.MemoryException_swiginit(self, _core.new_MemoryException(*args)) __swig_destroy__ = _core.delete_MemoryException # Register MemoryException in _core: _core.MemoryException_swigregister(MemoryException) class StreamException(GeneralException): 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): _core.StreamException_swiginit(self, _core.new_StreamException(*args)) __swig_destroy__ = _core.delete_StreamException # Register StreamException in _core: _core.StreamException_swigregister(StreamException) class EndOfStreamException(StreamException): 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): _core.EndOfStreamException_swiginit(self, _core.new_EndOfStreamException(*args)) __swig_destroy__ = _core.delete_EndOfStreamException # Register EndOfStreamException in _core: _core.EndOfStreamException_swigregister(EndOfStreamException) class TypeConversionException(GeneralException): 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): _core.TypeConversionException_swiginit(self, _core.new_TypeConversionException(*args)) __swig_destroy__ = _core.delete_TypeConversionException # Register TypeConversionException in _core: _core.TypeConversionException_swigregister(TypeConversionException) class OverflowException(GeneralException): 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): _core.OverflowException_swiginit(self, _core.new_OverflowException(*args)) __swig_destroy__ = _core.delete_OverflowException # Register OverflowException in _core: _core.OverflowException_swigregister(OverflowException) class UnderflowException(GeneralException): 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): _core.UnderflowException_swiginit(self, _core.new_UnderflowException(*args)) __swig_destroy__ = _core.delete_UnderflowException # Register UnderflowException in _core: _core.UnderflowException_swigregister(UnderflowException) class ValueException(GeneralException): 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): _core.ValueException_swiginit(self, _core.new_ValueException(*args)) __swig_destroy__ = _core.delete_ValueException # Register ValueException in _core: _core.ValueException_swigregister(ValueException) class TypeException(GeneralException): 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): _core.TypeException_swiginit(self, _core.new_TypeException(*args)) __swig_destroy__ = _core.delete_TypeException # Register TypeException in _core: _core.TypeException_swigregister(TypeException) class ClassNotFound(GeneralException): 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): _core.ClassNotFound_swiginit(self, _core.new_ClassNotFound(*args)) __swig_destroy__ = _core.delete_ClassNotFound # Register ClassNotFound in _core: _core.ClassNotFound_swigregister(ClassNotFound) class DuplicateClassname(GeneralException): 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): _core.DuplicateClassname_swiginit(self, _core.new_DuplicateClassname(*args)) __swig_destroy__ = _core.delete_DuplicateClassname # Register DuplicateClassname in _core: _core.DuplicateClassname_swigregister(DuplicateClassname) class BaseObject(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.BaseObject_ClassName() @staticmethod def TypeInfo(): return _core.BaseObject_TypeInfo() def className(self): return _core.BaseObject_className(self) def typeInfo(self): return _core.BaseObject_typeInfo(self) @staticmethod def Cast(*args): return _core.BaseObject_Cast(*args) @staticmethod def ConstCast(*args): return _core.BaseObject_ConstCast(*args) def serialize(self, arg2): return _core.BaseObject_serialize(self, arg2) @staticmethod def Meta(): return _core.BaseObject_Meta() def meta(self): return _core.BaseObject_meta(self) __swig_destroy__ = _core.delete_BaseObject def clone(self): return _core.BaseObject_clone(self) def incrementReferenceCount(self): return _core.BaseObject_incrementReferenceCount(self) def decrementReferenceCount(self): return _core.BaseObject_decrementReferenceCount(self) def referenceCount(self): return _core.BaseObject_referenceCount(self) @staticmethod def ObjectCount(): return _core.BaseObject_ObjectCount() # Register BaseObject in _core: _core.BaseObject_swigregister(BaseObject) def BaseObject_ClassName(): return _core.BaseObject_ClassName() def BaseObject_TypeInfo(): return _core.BaseObject_TypeInfo() def BaseObject_Cast(*args): return _core.BaseObject_Cast(*args) def BaseObject_ConstCast(*args): return _core.BaseObject_ConstCast(*args) def BaseObject_Meta(): return _core.BaseObject_Meta() def BaseObject_ObjectCount(): return _core.BaseObject_ObjectCount() class OperationInterrupted(GeneralException): 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): _core.OperationInterrupted_swiginit(self, _core.new_OperationInterrupted(*args)) __swig_destroy__ = _core.delete_OperationInterrupted # Register OperationInterrupted in _core: _core.OperationInterrupted_swigregister(OperationInterrupted) SC_API_VERSION = _core.SC_API_VERSION class Version(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, *args): _core.Version_swiginit(self, _core.new_Version(*args)) def majorTag(self): return _core.Version_majorTag(self) def minorTag(self): return _core.Version_minorTag(self) def patchTag(self): return _core.Version_patchTag(self) def toString(self): return _core.Version_toString(self) def fromString(self, str): return _core.Version_fromString(self, str) @staticmethod def pack(major, minor, patch=0): return _core.Version_pack(major, minor, patch) def __eq__(self, other): return _core.Version___eq__(self, other) def __ne__(self, other): return _core.Version___ne__(self, other) def __lt__(self, other): return _core.Version___lt__(self, other) def __gt__(self, other): return _core.Version___gt__(self, other) def __le__(self, other): return _core.Version___le__(self, other) def __ge__(self, other): return _core.Version___ge__(self, other) packed = property(_core.Version_packed_get, _core.Version_packed_set) __swig_destroy__ = _core.delete_Version # Register Version in _core: _core.Version_swigregister(Version) def Version_pack(major, minor, patch=0): return _core.Version_pack(major, minor, patch) class FrameworkVersion(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self): _core.FrameworkVersion_swiginit(self, _core.new_FrameworkVersion()) def toString(self): return _core.FrameworkVersion_toString(self) def systemInfo(self): return _core.FrameworkVersion_systemInfo(self) def version(self): return _core.FrameworkVersion_version(self) def api(self): return _core.FrameworkVersion_api(self) __swig_destroy__ = _core.delete_FrameworkVersion # Register FrameworkVersion in _core: _core.FrameworkVersion_swigregister(FrameworkVersion) class GenericArchive(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 NONE = _core.GenericArchive_NONE STATIC_TYPE = _core.GenericArchive_STATIC_TYPE IGNORE_CHILDS = _core.GenericArchive_IGNORE_CHILDS XML_ELEMENT = _core.GenericArchive_XML_ELEMENT XML_CDATA = _core.GenericArchive_XML_CDATA XML_MANDATORY = _core.GenericArchive_XML_MANDATORY DB_TABLE = _core.GenericArchive_DB_TABLE SPLIT_TIME = _core.GenericArchive_SPLIT_TIME INDEX_ATTRIBUTE = _core.GenericArchive_INDEX_ATTRIBUTE __swig_destroy__ = _core.delete_GenericArchive @staticmethod def PackVersion(major, minor): return _core.GenericArchive_PackVersion(major, minor) def open(self, dataSource): return _core.GenericArchive_open(self, dataSource) def create(self, dataSource): return _core.GenericArchive_create(self, dataSource) def close(self): return _core.GenericArchive_close(self) def setStrictMode(self, strict): return _core.GenericArchive_setStrictMode(self, strict) def isStrictMode(self): return _core.GenericArchive_isStrictMode(self) def isReading(self): return _core.GenericArchive_isReading(self) def success(self): return _core.GenericArchive_success(self) def hint(self): return _core.GenericArchive_hint(self) def setHint(self, arg2): return _core.GenericArchive_setHint(self, arg2) def setValidity(self, arg2): return _core.GenericArchive_setValidity(self, arg2) def setVersion(self, v): return _core.GenericArchive_setVersion(self, v) def version(self): return _core.GenericArchive_version(self) def versionMajor(self): return _core.GenericArchive_versionMajor(self) def versionMinor(self): return _core.GenericArchive_versionMinor(self) def propertyCount(self): return _core.GenericArchive_propertyCount(self) def setProperty(self, name, v): return _core.GenericArchive_setProperty(self, name, v) def property(self, name): return _core.GenericArchive_property(self, name) def propertyInt(self, name): return _core.GenericArchive_propertyInt(self, name) def propertyDouble(self, name): return _core.GenericArchive_propertyDouble(self, name) def propertyString(self, name): return _core.GenericArchive_propertyString(self, name) def clearProperties(self): return _core.GenericArchive_clearProperties(self) def read(self, *args): return _core.GenericArchive_read(self, *args) def write(self, *args): return _core.GenericArchive_write(self, *args) def readObject(self): return _core.GenericArchive_readObject(self) def writeObject(self, obj): return _core.GenericArchive_writeObject(self, obj) # Register GenericArchive in _core: _core.GenericArchive_swigregister(GenericArchive) def GenericArchive_PackVersion(major, minor): return _core.GenericArchive_PackVersion(major, minor) class Array(BaseObject): 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(): return _core.Array_ClassName() @staticmethod def TypeInfo(): return _core.Array_TypeInfo() def className(self): return _core.Array_className(self) def typeInfo(self): return _core.Array_typeInfo(self) @staticmethod def Cast(*args): return _core.Array_Cast(*args) @staticmethod def ConstCast(*args): return _core.Array_ConstCast(*args) CHAR = _core.Array_CHAR INT = _core.Array_INT FLOAT = _core.Array_FLOAT DOUBLE = _core.Array_DOUBLE DATETIME = _core.Array_DATETIME STRING = _core.Array_STRING COMPLEX_FLOAT = _core.Array_COMPLEX_FLOAT COMPLEX_DOUBLE = _core.Array_COMPLEX_DOUBLE DT_QUANTITY = _core.Array_DT_QUANTITY __swig_destroy__ = _core.delete_Array def dataType(self): return _core.Array_dataType(self) def clone(self): return _core.Array_clone(self) def copy(self, dt): return _core.Array_copy(self, dt) def data(self): return _core.Array_data(self) def size(self): return _core.Array_size(self) def resize(self, size): return _core.Array_resize(self, size) def clear(self): return _core.Array_clear(self) def elementSize(self): return _core.Array_elementSize(self) def append(self, arg2): return _core.Array_append(self, arg2) def slice(self, m, n): return _core.Array_slice(self, m, n) def str(self): return _core.Array_str(self) def numpy(self): return _core.Array_numpy(self) def setNumpy(self, obj): return _core.Array_setNumpy(self, obj) def bytes(self): return _core.Array_bytes(self) def str(self): """ For backwards compatibility """ return self.bytes() def __str__(self): """ For backwards compatibility """ return self.bytes() def __bytes__(self): return self.bytes() def numeric(self): import sys sys.stderr.write("Use of Array.numeric() is deprecated - use numpy() instead\n") return self.numpy() # Register Array in _core: _core.Array_swigregister(Array) def Array_ClassName(): return _core.Array_ClassName() def Array_TypeInfo(): return _core.Array_TypeInfo() def Array_Cast(*args): return _core.Array_Cast(*args) def Array_ConstCast(*args): return _core.Array_ConstCast(*args) class BitSet(BaseObject): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.BitSet_ClassName() @staticmethod def TypeInfo(): return _core.BitSet_TypeInfo() def className(self): return _core.BitSet_className(self) def typeInfo(self): return _core.BitSet_typeInfo(self) @staticmethod def Cast(*args): return _core.BitSet_Cast(*args) @staticmethod def ConstCast(*args): return _core.BitSet_ConstCast(*args) def __init__(self, *args): _core.BitSet_swiginit(self, _core.new_BitSet(*args)) def __iand__(self, b): return _core.BitSet___iand__(self, b) def __ior__(self, b): return _core.BitSet___ior__(self, b) def __ixor__(self, b): return _core.BitSet___ixor__(self, b) def __isub__(self, b): return _core.BitSet___isub__(self, b) def __ilshift__(self, n): return _core.BitSet___ilshift__(self, n) def __irshift__(self, n): return _core.BitSet___irshift__(self, n) def __lshift__(self, n): return _core.BitSet___lshift__(self, n) def __rshift__(self, n): return _core.BitSet___rshift__(self, n) def __invert__(self): return _core.BitSet___invert__(self) def resize(self, num_bits, value=False): return _core.BitSet_resize(self, num_bits, value) def clear(self): return _core.BitSet_clear(self) def append(self, bit): return _core.BitSet_append(self, bit) def set(self, *args): return _core.BitSet_set(self, *args) def reset(self, *args): return _core.BitSet_reset(self, *args) def flip(self, *args): return _core.BitSet_flip(self, *args) def test(self, n): return _core.BitSet_test(self, n) def any(self): return _core.BitSet_any(self) def none(self): return _core.BitSet_none(self) def numberOfBitsSet(self): return _core.BitSet_numberOfBitsSet(self) def toUlong(self): return _core.BitSet_toUlong(self) def size(self): return _core.BitSet_size(self) def numberOfBlocks(self): return _core.BitSet_numberOfBlocks(self) def maximumSize(self): return _core.BitSet_maximumSize(self) def empty(self): return _core.BitSet_empty(self) def findFirst(self): return _core.BitSet_findFirst(self) def findNext(self, pos): return _core.BitSet_findNext(self, pos) def impl(self, *args): return _core.BitSet_impl(self, *args) __swig_destroy__ = _core.delete_BitSet # Register BitSet in _core: _core.BitSet_swigregister(BitSet) def BitSet_ClassName(): return _core.BitSet_ClassName() def BitSet_TypeInfo(): return _core.BitSet_TypeInfo() def BitSet_Cast(*args): return _core.BitSet_Cast(*args) def BitSet_ConstCast(*args): return _core.BitSet_ConstCast(*args) class Record(BaseObject): 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(): return _core.Record_ClassName() @staticmethod def TypeInfo(): return _core.Record_TypeInfo() def className(self): return _core.Record_className(self) def typeInfo(self): return _core.Record_typeInfo(self) @staticmethod def Cast(*args): return _core.Record_Cast(*args) @staticmethod def ConstCast(*args): return _core.Record_ConstCast(*args) def serialize(self, ar): return _core.Record_serialize(self, ar) META_ONLY = _core.Record_META_ONLY DATA_ONLY = _core.Record_DATA_ONLY SAVE_RAW = _core.Record_SAVE_RAW H_QUANTITY = _core.Record_H_QUANTITY NOT_SIGNED = _core.Record_NOT_SIGNED SIGNATURE_VALIDATED = _core.Record_SIGNATURE_VALIDATED SIGNATURE_VALIDATION_FAILED = _core.Record_SIGNATURE_VALIDATION_FAILED A_QUANTITY = _core.Record_A_QUANTITY __swig_destroy__ = _core.delete_Record def networkCode(self): return _core.Record_networkCode(self) def setNetworkCode(self, net): return _core.Record_setNetworkCode(self, net) def stationCode(self): return _core.Record_stationCode(self) def setStationCode(self, sta): return _core.Record_setStationCode(self, sta) def locationCode(self): return _core.Record_locationCode(self) def setLocationCode(self, loc): return _core.Record_setLocationCode(self, loc) def channelCode(self): return _core.Record_channelCode(self) def setChannelCode(self, cha): return _core.Record_setChannelCode(self, cha) def startTime(self): return _core.Record_startTime(self) def setStartTime(self, time): return _core.Record_setStartTime(self, time) def endTime(self): return _core.Record_endTime(self) def timeWindow(self): return _core.Record_timeWindow(self) def sampleCount(self): return _core.Record_sampleCount(self) def samplingFrequency(self): return _core.Record_samplingFrequency(self) def timingQuality(self): return _core.Record_timingQuality(self) def setTimingQuality(self, tqual): return _core.Record_setTimingQuality(self, tqual) def streamID(self): return _core.Record_streamID(self) def dataType(self): return _core.Record_dataType(self) def setDataType(self, dt): return _core.Record_setDataType(self, dt) def setHint(self, h): return _core.Record_setHint(self, h) def setAuthentication(self, auth): return _core.Record_setAuthentication(self, auth) def authentication(self): return _core.Record_authentication(self) def setAuthority(self, authority): return _core.Record_setAuthority(self, authority) def authority(self): return _core.Record_authority(self) def data(self): return _core.Record_data(self) def raw(self): return _core.Record_raw(self) def copy(self): return _core.Record_copy(self) def clipMask(self): return _core.Record_clipMask(self) def saveSpace(self): return _core.Record_saveSpace(self) def read(self, _in): return _core.Record_read(self, _in) def write(self, out): return _core.Record_write(self, out) # Register Record in _core: _core.Record_swigregister(Record) def Record_ClassName(): return _core.Record_ClassName() def Record_TypeInfo(): return _core.Record_TypeInfo() def Record_Cast(*args): return _core.Record_Cast(*args) def Record_ConstCast(*args): return _core.Record_ConstCast(*args) ZSS = _core.ZSS ZDS = _core.ZDS ZDD = _core.ZDD RSS = _core.RSS RDS = _core.RDS RDD = _core.RDD TSS = _core.TSS TDS = _core.TDS ZEP = _core.ZEP REP = _core.REP EGreensFunctionComponentQuantity = _core.EGreensFunctionComponentQuantity class EGreensFunctionComponentNames(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self): _core.EGreensFunctionComponentNames_swiginit(self, _core.new_EGreensFunctionComponentNames()) @staticmethod def name(i): return _core.EGreensFunctionComponentNames_name(i) __swig_destroy__ = _core.delete_EGreensFunctionComponentNames # Register EGreensFunctionComponentNames in _core: _core.EGreensFunctionComponentNames_swigregister(EGreensFunctionComponentNames) def EGreensFunctionComponentNames_name(i): return _core.EGreensFunctionComponentNames_name(i) class GreensFunction(BaseObject): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.GreensFunction_ClassName() @staticmethod def TypeInfo(): return _core.GreensFunction_TypeInfo() def className(self): return _core.GreensFunction_className(self) def typeInfo(self): return _core.GreensFunction_typeInfo(self) @staticmethod def Cast(*args): return _core.GreensFunction_Cast(*args) @staticmethod def ConstCast(*args): return _core.GreensFunction_ConstCast(*args) def serialize(self, ar): return _core.GreensFunction_serialize(self, ar) def __init__(self, *args): _core.GreensFunction_swiginit(self, _core.new_GreensFunction(*args)) __swig_destroy__ = _core.delete_GreensFunction def setId(self, id): return _core.GreensFunction_setId(self, id) def id(self): return _core.GreensFunction_id(self) def setModel(self, model): return _core.GreensFunction_setModel(self, model) def model(self): return _core.GreensFunction_model(self) def setDistance(self, arg2): return _core.GreensFunction_setDistance(self, arg2) def distance(self): return _core.GreensFunction_distance(self) def setDepth(self, arg2): return _core.GreensFunction_setDepth(self, arg2) def depth(self): return _core.GreensFunction_depth(self) def setSamplingFrequency(self, arg2): return _core.GreensFunction_setSamplingFrequency(self, arg2) def samplingFrequency(self): return _core.GreensFunction_samplingFrequency(self) def setTimeOffset(self, arg2): return _core.GreensFunction_setTimeOffset(self, arg2) def timeOffset(self): return _core.GreensFunction_timeOffset(self) def length(self, arg2): return _core.GreensFunction_length(self, arg2) def data(self, arg2): return _core.GreensFunction_data(self, arg2) def setData(self, *args): return _core.GreensFunction_setData(self, *args) # Register GreensFunction in _core: _core.GreensFunction_swigregister(GreensFunction) def GreensFunction_ClassName(): return _core.GreensFunction_ClassName() def GreensFunction_TypeInfo(): return _core.GreensFunction_TypeInfo() def GreensFunction_Cast(*args): return _core.GreensFunction_Cast(*args) def GreensFunction_ConstCast(*args): return _core.GreensFunction_ConstCast(*args) class GenericRecord(Record): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.GenericRecord_ClassName() @staticmethod def TypeInfo(): return _core.GenericRecord_TypeInfo() def className(self): return _core.GenericRecord_className(self) def typeInfo(self): return _core.GenericRecord_typeInfo(self) @staticmethod def Cast(*args): return _core.GenericRecord_Cast(*args) @staticmethod def ConstCast(*args): return _core.GenericRecord_ConstCast(*args) def serialize(self, ar): return _core.GenericRecord_serialize(self, ar) def __init__(self, *args): _core.GenericRecord_swiginit(self, _core.new_GenericRecord(*args)) __swig_destroy__ = _core.delete_GenericRecord def setSamplingFrequency(self, freq): return _core.GenericRecord_setSamplingFrequency(self, freq) def data(self, *args): return _core.GenericRecord_data(self, *args) def raw(self): return _core.GenericRecord_raw(self) def clipMask(self): return _core.GenericRecord_clipMask(self) def setData(self, *args): return _core.GenericRecord_setData(self, *args) def setClipMask(self, clipMask): return _core.GenericRecord_setClipMask(self, clipMask) def dataUpdated(self): return _core.GenericRecord_dataUpdated(self) def saveSpace(self): return _core.GenericRecord_saveSpace(self) def copy(self): return _core.GenericRecord_copy(self) def read(self, _in): return _core.GenericRecord_read(self, _in) def write(self, out): return _core.GenericRecord_write(self, out) # Register GenericRecord in _core: _core.GenericRecord_swigregister(GenericRecord) def GenericRecord_ClassName(): return _core.GenericRecord_ClassName() def GenericRecord_TypeInfo(): return _core.GenericRecord_TypeInfo() def GenericRecord_Cast(*args): return _core.GenericRecord_Cast(*args) def GenericRecord_ConstCast(*args): return _core.GenericRecord_ConstCast(*args) class MessageIterator(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, *args): _core.MessageIterator_swiginit(self, _core.new_MessageIterator(*args)) __swig_destroy__ = _core.delete_MessageIterator def get(self): return _core.MessageIterator_get(self) def __ref__(self): return _core.MessageIterator___ref__(self) def step(self): return _core.MessageIterator_step(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 MessageIterator in _core: _core.MessageIterator_swigregister(MessageIterator) class Message(BaseObject): 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(): return _core.Message_ClassName() @staticmethod def TypeInfo(): return _core.Message_TypeInfo() def className(self): return _core.Message_className(self) def typeInfo(self): return _core.Message_typeInfo(self) @staticmethod def Cast(*args): return _core.Message_Cast(*args) @staticmethod def ConstCast(*args): return _core.Message_ConstCast(*args) def serialize(self, ar): return _core.Message_serialize(self, ar) __swig_destroy__ = _core.delete_Message def iter(self): return _core.Message_iter(self) def size(self): return _core.Message_size(self) def empty(self): return _core.Message_empty(self) def clear(self): return _core.Message_clear(self) def __iter__(self): return self.iter() # Register Message in _core: _core.Message_swigregister(Message) def Message_ClassName(): return _core.Message_ClassName() def Message_TypeInfo(): return _core.Message_TypeInfo() def Message_Cast(*args): return _core.Message_Cast(*args) def Message_ConstCast(*args): return _core.Message_ConstCast(*args) class DataMessageBase(Message): 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): return _core.DataMessageBase_serialize(self, ar) def __init__(self): _core.DataMessageBase_swiginit(self, _core.new_DataMessageBase()) __swig_destroy__ = _core.delete_DataMessageBase def attach(self, *args): return _core.DataMessageBase_attach(self, *args) def detach(self, *args): return _core.DataMessageBase_detach(self, *args) def clear(self): return _core.DataMessageBase_clear(self) def begin(self, *args): return _core.DataMessageBase_begin(self, *args) def end(self, *args): return _core.DataMessageBase_end(self, *args) def empty(self): return _core.DataMessageBase_empty(self) def size(self): return _core.DataMessageBase_size(self) # Register DataMessageBase in _core: _core.DataMessageBase_swigregister(DataMessageBase) class DataMessage(DataMessageBase): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.DataMessage_ClassName() @staticmethod def TypeInfo(): return _core.DataMessage_TypeInfo() def className(self): return _core.DataMessage_className(self) def typeInfo(self): return _core.DataMessage_typeInfo(self) @staticmethod def Cast(*args): return _core.DataMessage_Cast(*args) @staticmethod def ConstCast(*args): return _core.DataMessage_ConstCast(*args) def __init__(self): _core.DataMessage_swiginit(self, _core.new_DataMessage()) __swig_destroy__ = _core.delete_DataMessage # Register DataMessage in _core: _core.DataMessage_swigregister(DataMessage) def DataMessage_ClassName(): return _core.DataMessage_ClassName() def DataMessage_TypeInfo(): return _core.DataMessage_TypeInfo() def DataMessage_Cast(*args): return _core.DataMessage_Cast(*args) def DataMessage_ConstCast(*args): return _core.DataMessage_ConstCast(*args) class CharArrayT(Array): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.CharArrayT_ClassName() @staticmethod def TypeInfo(): return _core.CharArrayT_TypeInfo() def className(self): return _core.CharArrayT_className(self) def typeInfo(self): return _core.CharArrayT_typeInfo(self) @staticmethod def Cast(*args): return _core.CharArrayT_Cast(*args) @staticmethod def ConstCast(*args): return _core.CharArrayT_ConstCast(*args) def serialize(self, ar): return _core.CharArrayT_serialize(self, ar) ArrayType = property(_core.CharArrayT_ArrayType_get, _core.CharArrayT_ArrayType_set) def __init__(self, *args): _core.CharArrayT_swiginit(self, _core.new_CharArrayT(*args)) __swig_destroy__ = _core.delete_CharArrayT def copy(self, dt): return _core.CharArrayT_copy(self, dt) def setData(self, size, data): return _core.CharArrayT_setData(self, size, data) def data(self): return _core.CharArrayT_data(self) def typedData(self, *args): return _core.CharArrayT_typedData(self, *args) def size(self): return _core.CharArrayT_size(self) def elementSize(self): return _core.CharArrayT_elementSize(self) def resize(self, size): return _core.CharArrayT_resize(self, size) def clear(self): return _core.CharArrayT_clear(self) def fill(self, v): return _core.CharArrayT_fill(self, v) def set(self, index, v): return _core.CharArrayT_set(self, index, v) def get(self, index): return _core.CharArrayT_get(self, index) def append(self, *args): return _core.CharArrayT_append(self, *args) def prepend(self, *args): return _core.CharArrayT_prepend(self, *args) def slice(self, m, n): return _core.CharArrayT_slice(self, m, n) def begin(self, *args): return _core.CharArrayT_begin(self, *args) def end(self, *args): return _core.CharArrayT_end(self, *args) def impl(self, *args): return _core.CharArrayT_impl(self, *args) # Register CharArrayT in _core: _core.CharArrayT_swigregister(CharArrayT) def CharArrayT_ClassName(): return _core.CharArrayT_ClassName() def CharArrayT_TypeInfo(): return _core.CharArrayT_TypeInfo() def CharArrayT_Cast(*args): return _core.CharArrayT_Cast(*args) def CharArrayT_ConstCast(*args): return _core.CharArrayT_ConstCast(*args) class IntArrayT(Array): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.IntArrayT_ClassName() @staticmethod def TypeInfo(): return _core.IntArrayT_TypeInfo() def className(self): return _core.IntArrayT_className(self) def typeInfo(self): return _core.IntArrayT_typeInfo(self) @staticmethod def Cast(*args): return _core.IntArrayT_Cast(*args) @staticmethod def ConstCast(*args): return _core.IntArrayT_ConstCast(*args) def serialize(self, ar): return _core.IntArrayT_serialize(self, ar) ArrayType = property(_core.IntArrayT_ArrayType_get, _core.IntArrayT_ArrayType_set) def __init__(self, *args): _core.IntArrayT_swiginit(self, _core.new_IntArrayT(*args)) __swig_destroy__ = _core.delete_IntArrayT def copy(self, dt): return _core.IntArrayT_copy(self, dt) def setData(self, size, data): return _core.IntArrayT_setData(self, size, data) def data(self): return _core.IntArrayT_data(self) def typedData(self, *args): return _core.IntArrayT_typedData(self, *args) def size(self): return _core.IntArrayT_size(self) def elementSize(self): return _core.IntArrayT_elementSize(self) def resize(self, size): return _core.IntArrayT_resize(self, size) def clear(self): return _core.IntArrayT_clear(self) def fill(self, v): return _core.IntArrayT_fill(self, v) def set(self, index, v): return _core.IntArrayT_set(self, index, v) def get(self, index): return _core.IntArrayT_get(self, index) def append(self, *args): return _core.IntArrayT_append(self, *args) def prepend(self, *args): return _core.IntArrayT_prepend(self, *args) def slice(self, m, n): return _core.IntArrayT_slice(self, m, n) def begin(self, *args): return _core.IntArrayT_begin(self, *args) def end(self, *args): return _core.IntArrayT_end(self, *args) def impl(self, *args): return _core.IntArrayT_impl(self, *args) # Register IntArrayT in _core: _core.IntArrayT_swigregister(IntArrayT) def IntArrayT_ClassName(): return _core.IntArrayT_ClassName() def IntArrayT_TypeInfo(): return _core.IntArrayT_TypeInfo() def IntArrayT_Cast(*args): return _core.IntArrayT_Cast(*args) def IntArrayT_ConstCast(*args): return _core.IntArrayT_ConstCast(*args) class FloatArrayT(Array): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.FloatArrayT_ClassName() @staticmethod def TypeInfo(): return _core.FloatArrayT_TypeInfo() def className(self): return _core.FloatArrayT_className(self) def typeInfo(self): return _core.FloatArrayT_typeInfo(self) @staticmethod def Cast(*args): return _core.FloatArrayT_Cast(*args) @staticmethod def ConstCast(*args): return _core.FloatArrayT_ConstCast(*args) def serialize(self, ar): return _core.FloatArrayT_serialize(self, ar) ArrayType = property(_core.FloatArrayT_ArrayType_get, _core.FloatArrayT_ArrayType_set) def __init__(self, *args): _core.FloatArrayT_swiginit(self, _core.new_FloatArrayT(*args)) __swig_destroy__ = _core.delete_FloatArrayT def copy(self, dt): return _core.FloatArrayT_copy(self, dt) def setData(self, size, data): return _core.FloatArrayT_setData(self, size, data) def data(self): return _core.FloatArrayT_data(self) def typedData(self, *args): return _core.FloatArrayT_typedData(self, *args) def size(self): return _core.FloatArrayT_size(self) def elementSize(self): return _core.FloatArrayT_elementSize(self) def resize(self, size): return _core.FloatArrayT_resize(self, size) def clear(self): return _core.FloatArrayT_clear(self) def fill(self, v): return _core.FloatArrayT_fill(self, v) def set(self, index, v): return _core.FloatArrayT_set(self, index, v) def get(self, index): return _core.FloatArrayT_get(self, index) def append(self, *args): return _core.FloatArrayT_append(self, *args) def prepend(self, *args): return _core.FloatArrayT_prepend(self, *args) def slice(self, m, n): return _core.FloatArrayT_slice(self, m, n) def begin(self, *args): return _core.FloatArrayT_begin(self, *args) def end(self, *args): return _core.FloatArrayT_end(self, *args) def impl(self, *args): return _core.FloatArrayT_impl(self, *args) # Register FloatArrayT in _core: _core.FloatArrayT_swigregister(FloatArrayT) def FloatArrayT_ClassName(): return _core.FloatArrayT_ClassName() def FloatArrayT_TypeInfo(): return _core.FloatArrayT_TypeInfo() def FloatArrayT_Cast(*args): return _core.FloatArrayT_Cast(*args) def FloatArrayT_ConstCast(*args): return _core.FloatArrayT_ConstCast(*args) class DoubleArrayT(Array): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.DoubleArrayT_ClassName() @staticmethod def TypeInfo(): return _core.DoubleArrayT_TypeInfo() def className(self): return _core.DoubleArrayT_className(self) def typeInfo(self): return _core.DoubleArrayT_typeInfo(self) @staticmethod def Cast(*args): return _core.DoubleArrayT_Cast(*args) @staticmethod def ConstCast(*args): return _core.DoubleArrayT_ConstCast(*args) def serialize(self, ar): return _core.DoubleArrayT_serialize(self, ar) ArrayType = property(_core.DoubleArrayT_ArrayType_get, _core.DoubleArrayT_ArrayType_set) def __init__(self, *args): _core.DoubleArrayT_swiginit(self, _core.new_DoubleArrayT(*args)) __swig_destroy__ = _core.delete_DoubleArrayT def copy(self, dt): return _core.DoubleArrayT_copy(self, dt) def setData(self, size, data): return _core.DoubleArrayT_setData(self, size, data) def data(self): return _core.DoubleArrayT_data(self) def typedData(self, *args): return _core.DoubleArrayT_typedData(self, *args) def size(self): return _core.DoubleArrayT_size(self) def elementSize(self): return _core.DoubleArrayT_elementSize(self) def resize(self, size): return _core.DoubleArrayT_resize(self, size) def clear(self): return _core.DoubleArrayT_clear(self) def fill(self, v): return _core.DoubleArrayT_fill(self, v) def set(self, index, v): return _core.DoubleArrayT_set(self, index, v) def get(self, index): return _core.DoubleArrayT_get(self, index) def append(self, *args): return _core.DoubleArrayT_append(self, *args) def prepend(self, *args): return _core.DoubleArrayT_prepend(self, *args) def slice(self, m, n): return _core.DoubleArrayT_slice(self, m, n) def begin(self, *args): return _core.DoubleArrayT_begin(self, *args) def end(self, *args): return _core.DoubleArrayT_end(self, *args) def impl(self, *args): return _core.DoubleArrayT_impl(self, *args) # Register DoubleArrayT in _core: _core.DoubleArrayT_swigregister(DoubleArrayT) def DoubleArrayT_ClassName(): return _core.DoubleArrayT_ClassName() def DoubleArrayT_TypeInfo(): return _core.DoubleArrayT_TypeInfo() def DoubleArrayT_Cast(*args): return _core.DoubleArrayT_Cast(*args) def DoubleArrayT_ConstCast(*args): return _core.DoubleArrayT_ConstCast(*args) class ComplexFloatArray(Array): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.ComplexFloatArray_ClassName() @staticmethod def TypeInfo(): return _core.ComplexFloatArray_TypeInfo() def className(self): return _core.ComplexFloatArray_className(self) def typeInfo(self): return _core.ComplexFloatArray_typeInfo(self) @staticmethod def Cast(*args): return _core.ComplexFloatArray_Cast(*args) @staticmethod def ConstCast(*args): return _core.ComplexFloatArray_ConstCast(*args) def serialize(self, ar): return _core.ComplexFloatArray_serialize(self, ar) ArrayType = property(_core.ComplexFloatArray_ArrayType_get, _core.ComplexFloatArray_ArrayType_set) def __init__(self, *args): _core.ComplexFloatArray_swiginit(self, _core.new_ComplexFloatArray(*args)) __swig_destroy__ = _core.delete_ComplexFloatArray def copy(self, dt): return _core.ComplexFloatArray_copy(self, dt) def setData(self, size, data): return _core.ComplexFloatArray_setData(self, size, data) def data(self): return _core.ComplexFloatArray_data(self) def typedData(self, *args): return _core.ComplexFloatArray_typedData(self, *args) def size(self): return _core.ComplexFloatArray_size(self) def elementSize(self): return _core.ComplexFloatArray_elementSize(self) def resize(self, size): return _core.ComplexFloatArray_resize(self, size) def clear(self): return _core.ComplexFloatArray_clear(self) def fill(self, v): return _core.ComplexFloatArray_fill(self, v) def set(self, index, v): return _core.ComplexFloatArray_set(self, index, v) def get(self, index): return _core.ComplexFloatArray_get(self, index) def append(self, *args): return _core.ComplexFloatArray_append(self, *args) def prepend(self, *args): return _core.ComplexFloatArray_prepend(self, *args) def slice(self, m, n): return _core.ComplexFloatArray_slice(self, m, n) def begin(self, *args): return _core.ComplexFloatArray_begin(self, *args) def end(self, *args): return _core.ComplexFloatArray_end(self, *args) def impl(self, *args): return _core.ComplexFloatArray_impl(self, *args) # Register ComplexFloatArray in _core: _core.ComplexFloatArray_swigregister(ComplexFloatArray) def ComplexFloatArray_ClassName(): return _core.ComplexFloatArray_ClassName() def ComplexFloatArray_TypeInfo(): return _core.ComplexFloatArray_TypeInfo() def ComplexFloatArray_Cast(*args): return _core.ComplexFloatArray_Cast(*args) def ComplexFloatArray_ConstCast(*args): return _core.ComplexFloatArray_ConstCast(*args) class ComplexDoubleArray(Array): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.ComplexDoubleArray_ClassName() @staticmethod def TypeInfo(): return _core.ComplexDoubleArray_TypeInfo() def className(self): return _core.ComplexDoubleArray_className(self) def typeInfo(self): return _core.ComplexDoubleArray_typeInfo(self) @staticmethod def Cast(*args): return _core.ComplexDoubleArray_Cast(*args) @staticmethod def ConstCast(*args): return _core.ComplexDoubleArray_ConstCast(*args) def serialize(self, ar): return _core.ComplexDoubleArray_serialize(self, ar) ArrayType = property(_core.ComplexDoubleArray_ArrayType_get, _core.ComplexDoubleArray_ArrayType_set) def __init__(self, *args): _core.ComplexDoubleArray_swiginit(self, _core.new_ComplexDoubleArray(*args)) __swig_destroy__ = _core.delete_ComplexDoubleArray def copy(self, dt): return _core.ComplexDoubleArray_copy(self, dt) def setData(self, size, data): return _core.ComplexDoubleArray_setData(self, size, data) def data(self): return _core.ComplexDoubleArray_data(self) def typedData(self, *args): return _core.ComplexDoubleArray_typedData(self, *args) def size(self): return _core.ComplexDoubleArray_size(self) def elementSize(self): return _core.ComplexDoubleArray_elementSize(self) def resize(self, size): return _core.ComplexDoubleArray_resize(self, size) def clear(self): return _core.ComplexDoubleArray_clear(self) def fill(self, v): return _core.ComplexDoubleArray_fill(self, v) def set(self, index, v): return _core.ComplexDoubleArray_set(self, index, v) def get(self, index): return _core.ComplexDoubleArray_get(self, index) def append(self, *args): return _core.ComplexDoubleArray_append(self, *args) def prepend(self, *args): return _core.ComplexDoubleArray_prepend(self, *args) def slice(self, m, n): return _core.ComplexDoubleArray_slice(self, m, n) def begin(self, *args): return _core.ComplexDoubleArray_begin(self, *args) def end(self, *args): return _core.ComplexDoubleArray_end(self, *args) def impl(self, *args): return _core.ComplexDoubleArray_impl(self, *args) # Register ComplexDoubleArray in _core: _core.ComplexDoubleArray_swigregister(ComplexDoubleArray) def ComplexDoubleArray_ClassName(): return _core.ComplexDoubleArray_ClassName() def ComplexDoubleArray_TypeInfo(): return _core.ComplexDoubleArray_TypeInfo() def ComplexDoubleArray_Cast(*args): return _core.ComplexDoubleArray_Cast(*args) def ComplexDoubleArray_ConstCast(*args): return _core.ComplexDoubleArray_ConstCast(*args) class DateTimeArray(Array): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.DateTimeArray_ClassName() @staticmethod def TypeInfo(): return _core.DateTimeArray_TypeInfo() def className(self): return _core.DateTimeArray_className(self) def typeInfo(self): return _core.DateTimeArray_typeInfo(self) @staticmethod def Cast(*args): return _core.DateTimeArray_Cast(*args) @staticmethod def ConstCast(*args): return _core.DateTimeArray_ConstCast(*args) def serialize(self, ar): return _core.DateTimeArray_serialize(self, ar) ArrayType = property(_core.DateTimeArray_ArrayType_get, _core.DateTimeArray_ArrayType_set) def __init__(self, *args): _core.DateTimeArray_swiginit(self, _core.new_DateTimeArray(*args)) __swig_destroy__ = _core.delete_DateTimeArray def copy(self, dt): return _core.DateTimeArray_copy(self, dt) def setData(self, size, data): return _core.DateTimeArray_setData(self, size, data) def data(self): return _core.DateTimeArray_data(self) def typedData(self, *args): return _core.DateTimeArray_typedData(self, *args) def size(self): return _core.DateTimeArray_size(self) def elementSize(self): return _core.DateTimeArray_elementSize(self) def resize(self, size): return _core.DateTimeArray_resize(self, size) def clear(self): return _core.DateTimeArray_clear(self) def fill(self, v): return _core.DateTimeArray_fill(self, v) def set(self, index, v): return _core.DateTimeArray_set(self, index, v) def get(self, index): return _core.DateTimeArray_get(self, index) def append(self, *args): return _core.DateTimeArray_append(self, *args) def prepend(self, *args): return _core.DateTimeArray_prepend(self, *args) def slice(self, m, n): return _core.DateTimeArray_slice(self, m, n) def begin(self, *args): return _core.DateTimeArray_begin(self, *args) def end(self, *args): return _core.DateTimeArray_end(self, *args) def impl(self, *args): return _core.DateTimeArray_impl(self, *args) # Register DateTimeArray in _core: _core.DateTimeArray_swigregister(DateTimeArray) def DateTimeArray_ClassName(): return _core.DateTimeArray_ClassName() def DateTimeArray_TypeInfo(): return _core.DateTimeArray_TypeInfo() def DateTimeArray_Cast(*args): return _core.DateTimeArray_Cast(*args) def DateTimeArray_ConstCast(*args): return _core.DateTimeArray_ConstCast(*args) class StringArray(Array): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.StringArray_ClassName() @staticmethod def TypeInfo(): return _core.StringArray_TypeInfo() def className(self): return _core.StringArray_className(self) def typeInfo(self): return _core.StringArray_typeInfo(self) @staticmethod def Cast(*args): return _core.StringArray_Cast(*args) @staticmethod def ConstCast(*args): return _core.StringArray_ConstCast(*args) def serialize(self, ar): return _core.StringArray_serialize(self, ar) ArrayType = property(_core.StringArray_ArrayType_get, _core.StringArray_ArrayType_set) def __init__(self, *args): _core.StringArray_swiginit(self, _core.new_StringArray(*args)) __swig_destroy__ = _core.delete_StringArray def copy(self, dt): return _core.StringArray_copy(self, dt) def setData(self, size, data): return _core.StringArray_setData(self, size, data) def data(self): return _core.StringArray_data(self) def typedData(self, *args): return _core.StringArray_typedData(self, *args) def size(self): return _core.StringArray_size(self) def elementSize(self): return _core.StringArray_elementSize(self) def resize(self, size): return _core.StringArray_resize(self, size) def clear(self): return _core.StringArray_clear(self) def fill(self, v): return _core.StringArray_fill(self, v) def set(self, index, v): return _core.StringArray_set(self, index, v) def get(self, index): return _core.StringArray_get(self, index) def append(self, *args): return _core.StringArray_append(self, *args) def prepend(self, *args): return _core.StringArray_prepend(self, *args) def slice(self, m, n): return _core.StringArray_slice(self, m, n) def begin(self, *args): return _core.StringArray_begin(self, *args) def end(self, *args): return _core.StringArray_end(self, *args) def impl(self, *args): return _core.StringArray_impl(self, *args) # Register StringArray in _core: _core.StringArray_swigregister(StringArray) def StringArray_ClassName(): return _core.StringArray_ClassName() def StringArray_TypeInfo(): return _core.StringArray_TypeInfo() def StringArray_Cast(*args): return _core.StringArray_Cast(*args) def StringArray_ConstCast(*args): return _core.StringArray_ConstCast(*args) class CharArray(CharArrayT): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.CharArray_ClassName() @staticmethod def TypeInfo(): return _core.CharArray_TypeInfo() def className(self): return _core.CharArray_className(self) def typeInfo(self): return _core.CharArray_typeInfo(self) @staticmethod def Cast(*args): return _core.CharArray_Cast(*args) @staticmethod def ConstCast(*args): return _core.CharArray_ConstCast(*args) def __init__(self, *args): _core.CharArray_swiginit(self, _core.new_CharArray(*args)) __swig_destroy__ = _core.delete_CharArray def max(self): return _core.CharArray_max(self) def firstMax(self): return _core.CharArray_firstMax(self) def absMax(self): return _core.CharArray_absMax(self) def min(self): return _core.CharArray_min(self) def median(self): return _core.CharArray_median(self) def mean(self): return _core.CharArray_mean(self) def rms(self, offset=0): return _core.CharArray_rms(self, offset) def slice(self, m, n): return _core.CharArray_slice(self, m, n) def __iadd__(self, v): return _core.CharArray___iadd__(self, v) def __isub__(self, v): return _core.CharArray___isub__(self, v) def __imul__(self, v): return _core.CharArray___imul__(self, v) def __itruediv__(self, *args): return _core.CharArray___itruediv__(self, *args) __idiv__ = __itruediv__ # Register CharArray in _core: _core.CharArray_swigregister(CharArray) def CharArray_ClassName(): return _core.CharArray_ClassName() def CharArray_TypeInfo(): return _core.CharArray_TypeInfo() def CharArray_Cast(*args): return _core.CharArray_Cast(*args) def CharArray_ConstCast(*args): return _core.CharArray_ConstCast(*args) class IntArray(IntArrayT): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.IntArray_ClassName() @staticmethod def TypeInfo(): return _core.IntArray_TypeInfo() def className(self): return _core.IntArray_className(self) def typeInfo(self): return _core.IntArray_typeInfo(self) @staticmethod def Cast(*args): return _core.IntArray_Cast(*args) @staticmethod def ConstCast(*args): return _core.IntArray_ConstCast(*args) def __init__(self, *args): _core.IntArray_swiginit(self, _core.new_IntArray(*args)) __swig_destroy__ = _core.delete_IntArray def max(self): return _core.IntArray_max(self) def firstMax(self): return _core.IntArray_firstMax(self) def absMax(self): return _core.IntArray_absMax(self) def min(self): return _core.IntArray_min(self) def median(self): return _core.IntArray_median(self) def mean(self): return _core.IntArray_mean(self) def rms(self, offset=0): return _core.IntArray_rms(self, offset) def slice(self, m, n): return _core.IntArray_slice(self, m, n) def __iadd__(self, v): return _core.IntArray___iadd__(self, v) def __isub__(self, v): return _core.IntArray___isub__(self, v) def __imul__(self, v): return _core.IntArray___imul__(self, v) def __itruediv__(self, *args): return _core.IntArray___itruediv__(self, *args) __idiv__ = __itruediv__ # Register IntArray in _core: _core.IntArray_swigregister(IntArray) def IntArray_ClassName(): return _core.IntArray_ClassName() def IntArray_TypeInfo(): return _core.IntArray_TypeInfo() def IntArray_Cast(*args): return _core.IntArray_Cast(*args) def IntArray_ConstCast(*args): return _core.IntArray_ConstCast(*args) class FloatArray(FloatArrayT): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.FloatArray_ClassName() @staticmethod def TypeInfo(): return _core.FloatArray_TypeInfo() def className(self): return _core.FloatArray_className(self) def typeInfo(self): return _core.FloatArray_typeInfo(self) @staticmethod def Cast(*args): return _core.FloatArray_Cast(*args) @staticmethod def ConstCast(*args): return _core.FloatArray_ConstCast(*args) def __init__(self, *args): _core.FloatArray_swiginit(self, _core.new_FloatArray(*args)) __swig_destroy__ = _core.delete_FloatArray def max(self): return _core.FloatArray_max(self) def firstMax(self): return _core.FloatArray_firstMax(self) def absMax(self): return _core.FloatArray_absMax(self) def min(self): return _core.FloatArray_min(self) def median(self): return _core.FloatArray_median(self) def mean(self): return _core.FloatArray_mean(self) def rms(self, offset=0): return _core.FloatArray_rms(self, offset) def slice(self, m, n): return _core.FloatArray_slice(self, m, n) def __iadd__(self, v): return _core.FloatArray___iadd__(self, v) def __isub__(self, v): return _core.FloatArray___isub__(self, v) def __imul__(self, v): return _core.FloatArray___imul__(self, v) def __itruediv__(self, *args): return _core.FloatArray___itruediv__(self, *args) __idiv__ = __itruediv__ # Register FloatArray in _core: _core.FloatArray_swigregister(FloatArray) def FloatArray_ClassName(): return _core.FloatArray_ClassName() def FloatArray_TypeInfo(): return _core.FloatArray_TypeInfo() def FloatArray_Cast(*args): return _core.FloatArray_Cast(*args) def FloatArray_ConstCast(*args): return _core.FloatArray_ConstCast(*args) class DoubleArray(DoubleArrayT): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @staticmethod def ClassName(): return _core.DoubleArray_ClassName() @staticmethod def TypeInfo(): return _core.DoubleArray_TypeInfo() def className(self): return _core.DoubleArray_className(self) def typeInfo(self): return _core.DoubleArray_typeInfo(self) @staticmethod def Cast(*args): return _core.DoubleArray_Cast(*args) @staticmethod def ConstCast(*args): return _core.DoubleArray_ConstCast(*args) def __init__(self, *args): _core.DoubleArray_swiginit(self, _core.new_DoubleArray(*args)) __swig_destroy__ = _core.delete_DoubleArray def max(self): return _core.DoubleArray_max(self) def firstMax(self): return _core.DoubleArray_firstMax(self) def absMax(self): return _core.DoubleArray_absMax(self) def min(self): return _core.DoubleArray_min(self) def median(self): return _core.DoubleArray_median(self) def mean(self): return _core.DoubleArray_mean(self) def rms(self, offset=0): return _core.DoubleArray_rms(self, offset) def slice(self, m, n): return _core.DoubleArray_slice(self, m, n) def __iadd__(self, v): return _core.DoubleArray___iadd__(self, v) def __isub__(self, v): return _core.DoubleArray___isub__(self, v) def __imul__(self, v): return _core.DoubleArray___imul__(self, v) def __itruediv__(self, *args): return _core.DoubleArray___itruediv__(self, *args) __idiv__ = __itruediv__ # Register DoubleArray in _core: _core.DoubleArray_swigregister(DoubleArray) def DoubleArray_ClassName(): return _core.DoubleArray_ClassName() def DoubleArray_TypeInfo(): return _core.DoubleArray_TypeInfo() def DoubleArray_Cast(*args): return _core.DoubleArray_Cast(*args) def DoubleArray_ConstCast(*args): return _core.DoubleArray_ConstCast(*args)