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.
2756 lines
74 KiB
Python
2756 lines
74 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 _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)
|
|
|
|
|
|
|