# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _io
else:
    import _io

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import weakref

class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _io.delete_SwigPyIterator

    def value(self):
        return _io.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _io.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _io.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _io.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _io.SwigPyIterator_equal(self, x)

    def copy(self):
        return _io.SwigPyIterator_copy(self)

    def next(self):
        return _io.SwigPyIterator_next(self)

    def __next__(self):
        return _io.SwigPyIterator___next__(self)

    def previous(self):
        return _io.SwigPyIterator_previous(self)

    def advance(self, n):
        return _io.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _io.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _io.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _io.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _io.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _io.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _io.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _io:
_io.SwigPyIterator_swigregister(SwigPyIterator)

class ios_base(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    erase_event = _io.ios_base_erase_event
    imbue_event = _io.ios_base_imbue_event
    copyfmt_event = _io.ios_base_copyfmt_event

    def register_callback(self, __fn, __index):
        return _io.ios_base_register_callback(self, __fn, __index)

    def flags(self, *args):
        return _io.ios_base_flags(self, *args)

    def setf(self, *args):
        return _io.ios_base_setf(self, *args)

    def unsetf(self, __mask):
        return _io.ios_base_unsetf(self, __mask)

    def precision(self, *args):
        return _io.ios_base_precision(self, *args)

    def width(self, *args):
        return _io.ios_base_width(self, *args)

    @staticmethod
    def sync_with_stdio(__sync=True):
        return _io.ios_base_sync_with_stdio(__sync)

    def imbue(self, __loc):
        return _io.ios_base_imbue(self, __loc)

    def getloc(self):
        return _io.ios_base_getloc(self)

    @staticmethod
    def xalloc():
        return _io.ios_base_xalloc()

    def iword(self, __ix):
        return _io.ios_base_iword(self, __ix)

    def pword(self, __ix):
        return _io.ios_base_pword(self, __ix)
    __swig_destroy__ = _io.delete_ios_base

# Register ios_base in _io:
_io.ios_base_swigregister(ios_base)
cvar = _io.cvar
ios_base.boolalpha = _io.cvar.ios_base_boolalpha
ios_base.dec = _io.cvar.ios_base_dec
ios_base.fixed = _io.cvar.ios_base_fixed
ios_base.hex = _io.cvar.ios_base_hex
ios_base.internal = _io.cvar.ios_base_internal
ios_base.left = _io.cvar.ios_base_left
ios_base.oct = _io.cvar.ios_base_oct
ios_base.right = _io.cvar.ios_base_right
ios_base.scientific = _io.cvar.ios_base_scientific
ios_base.showbase = _io.cvar.ios_base_showbase
ios_base.showpoint = _io.cvar.ios_base_showpoint
ios_base.showpos = _io.cvar.ios_base_showpos
ios_base.skipws = _io.cvar.ios_base_skipws
ios_base.unitbuf = _io.cvar.ios_base_unitbuf
ios_base.uppercase = _io.cvar.ios_base_uppercase
ios_base.adjustfield = _io.cvar.ios_base_adjustfield
ios_base.basefield = _io.cvar.ios_base_basefield
ios_base.floatfield = _io.cvar.ios_base_floatfield
ios_base.badbit = _io.cvar.ios_base_badbit
ios_base.eofbit = _io.cvar.ios_base_eofbit
ios_base.failbit = _io.cvar.ios_base_failbit
ios_base.goodbit = _io.cvar.ios_base_goodbit
ios_base.app = _io.cvar.ios_base_app
ios_base.ate = _io.cvar.ios_base_ate
ios_base.binary = _io.cvar.ios_base_binary
ios_base.ios_base_in = _io.cvar.ios_base_ios_base_in
ios_base.out = _io.cvar.ios_base_out
ios_base.trunc = _io.cvar.ios_base_trunc
ios_base.beg = _io.cvar.ios_base_beg
ios_base.cur = _io.cvar.ios_base_cur
ios_base.end = _io.cvar.ios_base_end

def ios_base_sync_with_stdio(__sync=True):
    return _io.ios_base_sync_with_stdio(__sync)

def ios_base_xalloc():
    return _io.ios_base_xalloc()

class ios(ios_base):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def rdstate(self):
        return _io.ios_rdstate(self)

    def clear(self, *args):
        return _io.ios_clear(self, *args)

    def setstate(self, __state):
        return _io.ios_setstate(self, __state)

    def good(self):
        return _io.ios_good(self)

    def eof(self):
        return _io.ios_eof(self)

    def fail(self):
        return _io.ios_fail(self)

    def bad(self):
        return _io.ios_bad(self)

    def exceptions(self, *args):
        return _io.ios_exceptions(self, *args)

    def __init__(self, __sb):
        _io.ios_swiginit(self, _io.new_ios(__sb))
    __swig_destroy__ = _io.delete_ios

    def tie(self, *args):
        return _io.ios_tie(self, *args)

    def rdbuf(self, *args):
        return _io.ios_rdbuf(self, *args)

    def copyfmt(self, __rhs):
        return _io.ios_copyfmt(self, __rhs)

    def fill(self, *args):
        return _io.ios_fill(self, *args)

    def imbue(self, __loc):
        return _io.ios_imbue(self, __loc)

    def narrow(self, __c, __dfault):
        return _io.ios_narrow(self, __c, __dfault)

    def widen(self, __c):
        return _io.ios_widen(self, __c)

# Register ios in _io:
_io.ios_swigregister(ios)

import seiscomp.math
import seiscomp.core
class DatabaseInterface(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::IO::DatabaseInterface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def ClassName():
        r"""ClassName() -> char const *"""
        return _io.DatabaseInterface_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _io.DatabaseInterface_TypeInfo()

    def className(self):
        r"""className(DatabaseInterface self) -> char const *"""
        return _io.DatabaseInterface_className(self)

    def typeInfo(self):
        r"""typeInfo(DatabaseInterface self) -> RTTI"""
        return _io.DatabaseInterface_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> DatabaseInterface
        Cast(Seiscomp::Core::BaseObjectPtr o) -> DatabaseInterface
        """
        return _io.DatabaseInterface_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> DatabaseInterface
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DatabaseInterface
        """
        return _io.DatabaseInterface_ConstCast(*args)
    __swig_destroy__ = _io.delete_DatabaseInterface

    @staticmethod
    def Create(service):
        r"""Create(char const * service) -> DatabaseInterface"""
        return _io.DatabaseInterface_Create(service)

    @staticmethod
    def Open(uri):
        r"""Open(char const * uri) -> DatabaseInterface"""
        return _io.DatabaseInterface_Open(uri)

    def connect(self, connection):
        r"""connect(DatabaseInterface self, char const * connection) -> bool"""
        return _io.DatabaseInterface_connect(self, connection)

    def disconnect(self):
        r"""disconnect(DatabaseInterface self)"""
        return _io.DatabaseInterface_disconnect(self)

    def isConnected(self):
        r"""isConnected(DatabaseInterface self) -> bool"""
        return _io.DatabaseInterface_isConnected(self)

    def start(self):
        r"""start(DatabaseInterface self)"""
        return _io.DatabaseInterface_start(self)

    def commit(self):
        r"""commit(DatabaseInterface self)"""
        return _io.DatabaseInterface_commit(self)

    def rollback(self):
        r"""rollback(DatabaseInterface self)"""
        return _io.DatabaseInterface_rollback(self)

    def execute(self, command):
        r"""execute(DatabaseInterface self, char const * command) -> bool"""
        return _io.DatabaseInterface_execute(self, command)

    def beginQuery(self, query):
        r"""beginQuery(DatabaseInterface self, char const * query) -> bool"""
        return _io.DatabaseInterface_beginQuery(self, query)

    def endQuery(self):
        r"""endQuery(DatabaseInterface self)"""
        return _io.DatabaseInterface_endQuery(self)

    def defaultValue(self):
        r"""defaultValue(DatabaseInterface self) -> char const *"""
        return _io.DatabaseInterface_defaultValue(self)

    def lastInsertId(self, table):
        r"""lastInsertId(DatabaseInterface self, char const * table) -> Seiscomp::IO::DatabaseInterface::OID"""
        return _io.DatabaseInterface_lastInsertId(self, table)

    def numberOfAffectedRows(self):
        r"""numberOfAffectedRows(DatabaseInterface self) -> uint64_t"""
        return _io.DatabaseInterface_numberOfAffectedRows(self)

    def fetchRow(self):
        r"""fetchRow(DatabaseInterface self) -> bool"""
        return _io.DatabaseInterface_fetchRow(self)

    def findColumn(self, name):
        r"""findColumn(DatabaseInterface self, char const * name) -> int"""
        return _io.DatabaseInterface_findColumn(self, name)

    def getRowFieldCount(self):
        r"""getRowFieldCount(DatabaseInterface self) -> int"""
        return _io.DatabaseInterface_getRowFieldCount(self)

    def getRowFieldName(self, index):
        r"""getRowFieldName(DatabaseInterface self, int index) -> char const *"""
        return _io.DatabaseInterface_getRowFieldName(self, index)

    def getRowField(self, index):
        r"""getRowField(DatabaseInterface self, int index) -> void const *"""
        return _io.DatabaseInterface_getRowField(self, index)

    def getRowFieldString(self, index):
        r"""getRowFieldString(DatabaseInterface self, int index) -> string"""
        return _io.DatabaseInterface_getRowFieldString(self, index)

    def getRowFieldSize(self, index):
        r"""getRowFieldSize(DatabaseInterface self, int index) -> size_t"""
        return _io.DatabaseInterface_getRowFieldSize(self, index)

    def timeToString(self, arg2):
        r"""timeToString(DatabaseInterface self, Time arg2) -> string"""
        return _io.DatabaseInterface_timeToString(self, arg2)

    def stringToTime(self, arg2):
        r"""stringToTime(DatabaseInterface self, char const * arg2) -> Time"""
        return _io.DatabaseInterface_stringToTime(self, arg2)

    def escape(self, out, _in):
        r"""escape(DatabaseInterface self, string out, string _in) -> bool"""
        return _io.DatabaseInterface_escape(self, out, _in)

    def columnPrefix(self):
        r"""columnPrefix(DatabaseInterface self) -> string"""
        return _io.DatabaseInterface_columnPrefix(self)

    def convertColumnName(self, name):
        r"""convertColumnName(DatabaseInterface self, string name) -> string"""
        return _io.DatabaseInterface_convertColumnName(self, name)

# Register DatabaseInterface in _io:
_io.DatabaseInterface_swigregister(DatabaseInterface)

def DatabaseInterface_ClassName():
    r"""DatabaseInterface_ClassName() -> char const *"""
    return _io.DatabaseInterface_ClassName()

def DatabaseInterface_TypeInfo():
    r"""DatabaseInterface_TypeInfo() -> RTTI"""
    return _io.DatabaseInterface_TypeInfo()

def DatabaseInterface_Cast(*args):
    r"""
    DatabaseInterface_Cast(BaseObject o) -> DatabaseInterface
    DatabaseInterface_Cast(Seiscomp::Core::BaseObjectPtr o) -> DatabaseInterface
    """
    return _io.DatabaseInterface_Cast(*args)

def DatabaseInterface_ConstCast(*args):
    r"""
    DatabaseInterface_ConstCast(BaseObject o) -> DatabaseInterface
    DatabaseInterface_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> DatabaseInterface
    """
    return _io.DatabaseInterface_ConstCast(*args)
DatabaseInterface.INVALID_OID = _io.cvar.DatabaseInterface_INVALID_OID

def DatabaseInterface_Create(service):
    r"""DatabaseInterface_Create(char const * service) -> DatabaseInterface"""
    return _io.DatabaseInterface_Create(service)

def DatabaseInterface_Open(uri):
    r"""DatabaseInterface_Open(char const * uri) -> DatabaseInterface"""
    return _io.DatabaseInterface_Open(uri)

class GFSource(seiscomp.math.CoordD):
    r"""Proxy of C++ Seiscomp::IO::GFSource class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, lat=0.0, lon=0.0, d=0.0):
        r"""__init__(GFSource self, double lat=0.0, double lon=0.0, double d=0.0) -> GFSource"""
        _io.GFSource_swiginit(self, _io.new_GFSource(lat, lon, d))
    depth = property(_io.GFSource_depth_get, _io.GFSource_depth_set, doc=r"""depth : double""")
    __swig_destroy__ = _io.delete_GFSource

# Register GFSource in _io:
_io.GFSource_swigregister(GFSource)

class GFReceiver(seiscomp.math.CoordD):
    r"""Proxy of C++ Seiscomp::IO::GFReceiver class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, lat=0.0, lon=0.0, e=0.0):
        r"""__init__(GFReceiver self, double lat=0.0, double lon=0.0, double e=0.0) -> GFReceiver"""
        _io.GFReceiver_swiginit(self, _io.new_GFReceiver(lat, lon, e))
    elevation = property(_io.GFReceiver_elevation_get, _io.GFReceiver_elevation_set, doc=r"""elevation : double""")
    __swig_destroy__ = _io.delete_GFReceiver

# Register GFReceiver in _io:
_io.GFReceiver_swigregister(GFReceiver)

class GFArchive(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::IO::GFArchive class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def ClassName():
        r"""ClassName() -> char const *"""
        return _io.GFArchive_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _io.GFArchive_TypeInfo()

    def className(self):
        r"""className(GFArchive self) -> char const *"""
        return _io.GFArchive_className(self)

    def typeInfo(self):
        r"""typeInfo(GFArchive self) -> RTTI"""
        return _io.GFArchive_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> GFArchive
        Cast(Seiscomp::Core::BaseObjectPtr o) -> GFArchive
        """
        return _io.GFArchive_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> GFArchive
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> GFArchive
        """
        return _io.GFArchive_ConstCast(*args)
    __swig_destroy__ = _io.delete_GFArchive

    def setSource(self, arg2):
        r"""setSource(GFArchive self, string arg2) -> bool"""
        return _io.GFArchive_setSource(self, arg2)

    def close(self):
        r"""close(GFArchive self)"""
        return _io.GFArchive_close(self)

    def availableModels(self):
        r"""availableModels(GFArchive self) -> std::list< std::string >"""
        return _io.GFArchive_availableModels(self)

    def availableDepths(self, model):
        r"""availableDepths(GFArchive self, string model) -> std::list< double >"""
        return _io.GFArchive_availableDepths(self, model)

    def setTimeSpan(self, span):
        r"""setTimeSpan(GFArchive self, TimeSpan span) -> bool"""
        return _io.GFArchive_setTimeSpan(self, span)

    def addRequest(self, *args):
        r"""
        addRequest(GFArchive self, string id, string model, GFSource source, GFReceiver receiver) -> bool
        addRequest(GFArchive self, string id, string model, GFSource source, GFReceiver receiver, TimeSpan span) -> bool
        """
        return _io.GFArchive_addRequest(self, *args)

    def get(self):
        r"""get(GFArchive self) -> GreensFunction"""
        return _io.GFArchive_get(self)

    def getTravelTime(self, phase, model, source, receiver):
        r"""getTravelTime(GFArchive self, string phase, string model, GFSource source, GFReceiver receiver) -> Seiscomp::Core::Optional< double >::Impl"""
        return _io.GFArchive_getTravelTime(self, phase, model, source, receiver)

    def hasLocalTravelTimes(self):
        r"""hasLocalTravelTimes(GFArchive self) -> bool"""
        return _io.GFArchive_hasLocalTravelTimes(self)

    @staticmethod
    def Create(service):
        r"""Create(char const * service) -> GFArchive"""
        return _io.GFArchive_Create(service)

    @staticmethod
    def Open(url):
        r"""Open(char const * url) -> GFArchive"""
        return _io.GFArchive_Open(url)

# Register GFArchive in _io:
_io.GFArchive_swigregister(GFArchive)

def GFArchive_ClassName():
    r"""GFArchive_ClassName() -> char const *"""
    return _io.GFArchive_ClassName()

def GFArchive_TypeInfo():
    r"""GFArchive_TypeInfo() -> RTTI"""
    return _io.GFArchive_TypeInfo()

def GFArchive_Cast(*args):
    r"""
    GFArchive_Cast(BaseObject o) -> GFArchive
    GFArchive_Cast(Seiscomp::Core::BaseObjectPtr o) -> GFArchive
    """
    return _io.GFArchive_Cast(*args)

def GFArchive_ConstCast(*args):
    r"""
    GFArchive_ConstCast(BaseObject o) -> GFArchive
    GFArchive_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> GFArchive
    """
    return _io.GFArchive_ConstCast(*args)

def GFArchive_Create(service):
    r"""GFArchive_Create(char const * service) -> GFArchive"""
    return _io.GFArchive_Create(service)

def GFArchive_Open(url):
    r"""GFArchive_Open(char const * url) -> GFArchive"""
    return _io.GFArchive_Open(url)

class RecordStream(object):
    r"""Proxy of C++ Seiscomp::IO::RecordStream class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def ClassName():
        r"""ClassName() -> char const *"""
        return _io.RecordStream_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _io.RecordStream_TypeInfo()

    def className(self):
        r"""className(RecordStream self) -> char const *"""
        return _io.RecordStream_className(self)

    def typeInfo(self):
        r"""typeInfo(RecordStream self) -> RTTI"""
        return _io.RecordStream_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> RecordStream
        Cast(Seiscomp::Core::BaseObjectPtr o) -> RecordStream
        """
        return _io.RecordStream_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> RecordStream
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RecordStream
        """
        return _io.RecordStream_ConstCast(*args)
    __swig_destroy__ = _io.delete_RecordStream

    def setSource(self, source):
        r"""setSource(RecordStream self, string source) -> bool"""
        return _io.RecordStream_setSource(self, source)

    def close(self):
        r"""close(RecordStream self)"""
        return _io.RecordStream_close(self)

    def addStream(self, *args):
        r"""
        addStream(RecordStream self, string networkCode, string stationCode, string locationCode, string channelCode) -> bool
        addStream(RecordStream self, string networkCode, string stationCode, string locationCode, string channelCode, Time startTime, Time endTime) -> bool
        """
        return _io.RecordStream_addStream(self, *args)

    def setStartTime(self, startTime):
        r"""setStartTime(RecordStream self, Time startTime) -> bool"""
        return _io.RecordStream_setStartTime(self, startTime)

    def setEndTime(self, endTime):
        r"""setEndTime(RecordStream self, Time endTime) -> bool"""
        return _io.RecordStream_setEndTime(self, endTime)

    def setTimeWindow(self, timeWindow):
        r"""setTimeWindow(RecordStream self, Seiscomp::Core::TimeWindow const & timeWindow) -> bool"""
        return _io.RecordStream_setTimeWindow(self, timeWindow)

    def setTimeout(self, seconds):
        r"""setTimeout(RecordStream self, int seconds) -> bool"""
        return _io.RecordStream_setTimeout(self, seconds)

    def setRecordType(self, type):
        r"""setRecordType(RecordStream self, char const * type) -> bool"""
        return _io.RecordStream_setRecordType(self, type)

    def setDataType(self, dataType):
        r"""setDataType(RecordStream self, Seiscomp::Array::DataType dataType)"""
        return _io.RecordStream_setDataType(self, dataType)

    def setDataHint(self, hint):
        r"""setDataHint(RecordStream self, Seiscomp::Record::Hint hint)"""
        return _io.RecordStream_setDataHint(self, hint)

    def next(self):
        r"""next(RecordStream self) -> Record"""
        return _io.RecordStream_next(self)

    @staticmethod
    def Create(service):
        r"""Create(char const * service) -> RecordStream"""
        return _io.RecordStream_Create(service)

    @staticmethod
    def Open(url):
        r"""Open(char const * url) -> RecordStream"""
        return _io.RecordStream_Open(url)

# Register RecordStream in _io:
_io.RecordStream_swigregister(RecordStream)

def RecordStream_ClassName():
    r"""RecordStream_ClassName() -> char const *"""
    return _io.RecordStream_ClassName()

def RecordStream_TypeInfo():
    r"""RecordStream_TypeInfo() -> RTTI"""
    return _io.RecordStream_TypeInfo()

def RecordStream_Cast(*args):
    r"""
    RecordStream_Cast(BaseObject o) -> RecordStream
    RecordStream_Cast(Seiscomp::Core::BaseObjectPtr o) -> RecordStream
    """
    return _io.RecordStream_Cast(*args)

def RecordStream_ConstCast(*args):
    r"""
    RecordStream_ConstCast(BaseObject o) -> RecordStream
    RecordStream_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> RecordStream
    """
    return _io.RecordStream_ConstCast(*args)

def RecordStream_Create(service):
    r"""RecordStream_Create(char const * service) -> RecordStream"""
    return _io.RecordStream_Create(service)

def RecordStream_Open(url):
    r"""RecordStream_Open(char const * url) -> RecordStream"""
    return _io.RecordStream_Open(url)

class RecordIterator(object):
    r"""Proxy of C++ Seiscomp::IO::RecordIterator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(RecordIterator self) -> RecordIterator
        __init__(RecordIterator self, RecordIterator iter) -> RecordIterator
        """
        _io.RecordIterator_swiginit(self, _io.new_RecordIterator(*args))
    __swig_destroy__ = _io.delete_RecordIterator

    def __ref__(self):
        r"""__ref__(RecordIterator self) -> Record"""
        return _io.RecordIterator___ref__(self)

    def __ne__(self, iter):
        r"""__ne__(RecordIterator self, RecordIterator iter) -> bool"""
        return _io.RecordIterator___ne__(self, iter)

    def __eq__(self, iter):
        r"""__eq__(RecordIterator self, RecordIterator iter) -> bool"""
        return _io.RecordIterator___eq__(self, iter)

    def source(self):
        r"""source(RecordIterator self) -> RecordInput"""
        return _io.RecordIterator_source(self)

    def current(self):
        r"""current(RecordIterator self) -> Record"""
        return _io.RecordIterator_current(self)

# Register RecordIterator in _io:
_io.RecordIterator_swigregister(RecordIterator)

class RecordInput(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::IO::RecordInput class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""__init__(RecordInput self, RecordStream _in, Seiscomp::Array::DataType dt=DOUBLE, Seiscomp::Record::Hint h=SAVE_RAW) -> RecordInput"""
        _io.RecordInput_swiginit(self, _io.new_RecordInput(*args))

    def begin(self):
        r"""begin(RecordInput self) -> RecordIterator"""
        return _io.RecordInput_begin(self)

    def end(self):
        r"""end(RecordInput self) -> RecordIterator"""
        return _io.RecordInput_end(self)

    def next(self):
        r"""next(RecordInput self) -> Record"""
        return _io.RecordInput_next(self)

    def __iter__(self):
        while 1:
            rec = self.next()
            if not rec:
                return
            yield rec

    def __next__(self):
        rec = self.next()
        if not rec:
            return
        return rec

    ## for Python 2 compatibility
    #def next(self):
    #    return self.__next__()

    __swig_destroy__ = _io.delete_RecordInput

# Register RecordInput in _io:
_io.RecordInput_swigregister(RecordInput)

class RecordFilterInterface(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::IO::RecordFilterInterface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _io.delete_RecordFilterInterface

    def feed(self, rec):
        r"""feed(RecordFilterInterface self, Record rec) -> Record"""
        return _io.RecordFilterInterface_feed(self, rec)

    def flush(self):
        r"""flush(RecordFilterInterface self) -> Record"""
        return _io.RecordFilterInterface_flush(self)

    def reset(self):
        r"""reset(RecordFilterInterface self)"""
        return _io.RecordFilterInterface_reset(self)

    def clone(self):
        r"""clone(RecordFilterInterface self) -> RecordFilterInterface"""
        return _io.RecordFilterInterface_clone(self)

# Register RecordFilterInterface in _io:
_io.RecordFilterInterface_swigregister(RecordFilterInterface)

class RecordDemuxFilter(RecordFilterInterface):
    r"""Proxy of C++ Seiscomp::IO::RecordDemuxFilter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, recordFilter=None):
        r"""__init__(RecordDemuxFilter self, RecordFilterInterface recordFilter=None) -> RecordDemuxFilter"""
        _io.RecordDemuxFilter_swiginit(self, _io.new_RecordDemuxFilter(recordFilter))
    __swig_destroy__ = _io.delete_RecordDemuxFilter

    def setFilter(self, recordFilter):
        r"""setFilter(RecordDemuxFilter self, RecordFilterInterface recordFilter)"""
        return _io.RecordDemuxFilter_setFilter(self, recordFilter)

    def feed(self, rec):
        r"""feed(RecordDemuxFilter self, Record rec) -> Record"""
        return _io.RecordDemuxFilter_feed(self, rec)

    def flush(self):
        r"""flush(RecordDemuxFilter self) -> Record"""
        return _io.RecordDemuxFilter_flush(self)

    def reset(self):
        r"""reset(RecordDemuxFilter self)"""
        return _io.RecordDemuxFilter_reset(self)

    def clone(self):
        r"""clone(RecordDemuxFilter self) -> RecordFilterInterface"""
        return _io.RecordDemuxFilter_clone(self)

# Register RecordDemuxFilter in _io:
_io.RecordDemuxFilter_swigregister(RecordDemuxFilter)

class RecordResamplerBase(RecordFilterInterface):
    r"""Proxy of C++ Seiscomp::IO::RecordResamplerBase class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def flush(self):
        r"""flush(RecordResamplerBase self) -> Record"""
        return _io.RecordResamplerBase_flush(self)

    def reset(self):
        r"""reset(RecordResamplerBase self)"""
        return _io.RecordResamplerBase_reset(self)

# Register RecordResamplerBase in _io:
_io.RecordResamplerBase_swigregister(RecordResamplerBase)

class RecordStreamException(seiscomp.core.StreamException):
    r"""Proxy of C++ Seiscomp::IO::RecordStreamException class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(RecordStreamException self) -> RecordStreamException
        __init__(RecordStreamException self, string what) -> RecordStreamException
        """
        _io.RecordStreamException_swiginit(self, _io.new_RecordStreamException(*args))
    __swig_destroy__ = _io.delete_RecordStreamException

# Register RecordStreamException in _io:
_io.RecordStreamException_swigregister(RecordStreamException)

class RecordStreamTimeout(RecordStreamException):
    r"""Proxy of C++ Seiscomp::IO::RecordStreamTimeout class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(RecordStreamTimeout self) -> RecordStreamTimeout
        __init__(RecordStreamTimeout self, string what) -> RecordStreamTimeout
        """
        _io.RecordStreamTimeout_swiginit(self, _io.new_RecordStreamTimeout(*args))
    __swig_destroy__ = _io.delete_RecordStreamTimeout

# Register RecordStreamTimeout in _io:
_io.RecordStreamTimeout_swigregister(RecordStreamTimeout)

class Importer(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::IO::Importer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def ClassName():
        r"""ClassName() -> char const *"""
        return _io.Importer_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _io.Importer_TypeInfo()

    def className(self):
        r"""className(Importer self) -> char const *"""
        return _io.Importer_className(self)

    def typeInfo(self):
        r"""typeInfo(Importer self) -> RTTI"""
        return _io.Importer_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Importer
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Importer
        """
        return _io.Importer_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Importer
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Importer
        """
        return _io.Importer_ConstCast(*args)
    __swig_destroy__ = _io.delete_Importer

    @staticmethod
    def Create(type):
        r"""Create(char const * type) -> Importer"""
        return _io.Importer_Create(type)

    def read(self, *args):
        r"""
        read(Importer self, std::streambuf * buf) -> BaseObject
        read(Importer self, string filename) -> BaseObject
        """
        return _io.Importer_read(self, *args)

    def withoutErrors(self):
        r"""withoutErrors(Importer self) -> bool"""
        return _io.Importer_withoutErrors(self)

# Register Importer in _io:
_io.Importer_swigregister(Importer)

def Importer_ClassName():
    r"""Importer_ClassName() -> char const *"""
    return _io.Importer_ClassName()

def Importer_TypeInfo():
    r"""Importer_TypeInfo() -> RTTI"""
    return _io.Importer_TypeInfo()

def Importer_Cast(*args):
    r"""
    Importer_Cast(BaseObject o) -> Importer
    Importer_Cast(Seiscomp::Core::BaseObjectPtr o) -> Importer
    """
    return _io.Importer_Cast(*args)

def Importer_ConstCast(*args):
    r"""
    Importer_ConstCast(BaseObject o) -> Importer
    Importer_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Importer
    """
    return _io.Importer_ConstCast(*args)

def Importer_Create(type):
    r"""Importer_Create(char const * type) -> Importer"""
    return _io.Importer_Create(type)

class ExportSink(object):
    r"""Proxy of C++ Seiscomp::IO::ExportSink class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _io.delete_ExportSink

    def write(self, data):
        r"""write(ExportSink self, char const * data) -> int"""
        return _io.ExportSink_write(self, data)

    def __init__(self):
        r"""__init__(ExportSink self) -> ExportSink"""
        if self.__class__ == ExportSink:
            _self = None
        else:
            _self = self
        _io.ExportSink_swiginit(self, _io.new_ExportSink(_self, ))
    def __disown__(self):
        self.this.disown()
        _io.disown_ExportSink(self)
        return weakref.proxy(self)

# Register ExportSink in _io:
_io.ExportSink_swigregister(ExportSink)

class Exporter(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::IO::Exporter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def ClassName():
        r"""ClassName() -> char const *"""
        return _io.Exporter_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _io.Exporter_TypeInfo()

    def className(self):
        r"""className(Exporter self) -> char const *"""
        return _io.Exporter_className(self)

    def typeInfo(self):
        r"""typeInfo(Exporter self) -> RTTI"""
        return _io.Exporter_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> Exporter
        Cast(Seiscomp::Core::BaseObjectPtr o) -> Exporter
        """
        return _io.Exporter_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> Exporter
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Exporter
        """
        return _io.Exporter_ConstCast(*args)
    __swig_destroy__ = _io.delete_Exporter

    @staticmethod
    def Create(type):
        r"""Create(char const * type) -> Exporter"""
        return _io.Exporter_Create(type)

    def setFormattedOutput(self, enable):
        r"""setFormattedOutput(Exporter self, bool enable)"""
        return _io.Exporter_setFormattedOutput(self, enable)

    def setIndent(self, arg2):
        r"""setIndent(Exporter self, int arg2)"""
        return _io.Exporter_setIndent(self, arg2)

    def write(self, *args):
        r"""
        write(Exporter self, std::streambuf * buf, BaseObject arg3) -> bool
        write(Exporter self, string filename, BaseObject arg3) -> bool
        write(Exporter self, ExportSink sink, BaseObject arg3) -> bool
        write(Exporter self, std::streambuf * buf, ExportObjectList objects) -> bool
        write(Exporter self, string filename, ExportObjectList objects) -> bool
        write(Exporter self, ExportSink sink, ExportObjectList objects) -> bool
        """
        return _io.Exporter_write(self, *args)

# Register Exporter in _io:
_io.Exporter_swigregister(Exporter)

def Exporter_ClassName():
    r"""Exporter_ClassName() -> char const *"""
    return _io.Exporter_ClassName()

def Exporter_TypeInfo():
    r"""Exporter_TypeInfo() -> RTTI"""
    return _io.Exporter_TypeInfo()

def Exporter_Cast(*args):
    r"""
    Exporter_Cast(BaseObject o) -> Exporter
    Exporter_Cast(Seiscomp::Core::BaseObjectPtr o) -> Exporter
    """
    return _io.Exporter_Cast(*args)

def Exporter_ConstCast(*args):
    r"""
    Exporter_ConstCast(BaseObject o) -> Exporter
    Exporter_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> Exporter
    """
    return _io.Exporter_ConstCast(*args)

def Exporter_Create(type):
    r"""Exporter_Create(char const * type) -> Exporter"""
    return _io.Exporter_Create(type)

class XMLArchive(seiscomp.core.GenericArchive):
    r"""Proxy of C++ Seiscomp::IO::XMLArchive class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ZIP = _io.XMLArchive_ZIP
    
    GZIP = _io.XMLArchive_GZIP
    

    def __init__(self, *args):
        r"""
        __init__(XMLArchive self) -> XMLArchive
        __init__(XMLArchive self, std::streambuf * buf, bool isReading=True, int forceWriteVersion=-1) -> XMLArchive
        """
        _io.XMLArchive_swiginit(self, _io.new_XMLArchive(*args))
    __swig_destroy__ = _io.delete_XMLArchive

    def open(self, *args):
        r"""
        open(XMLArchive self, std::streambuf * arg2) -> bool
        open(XMLArchive self, char const * filename) -> bool
        """
        return _io.XMLArchive_open(self, *args)

    def create(self, *args):
        r"""
        create(XMLArchive self, std::streambuf * buf, bool writeVersion=True, bool headerNode=True) -> bool
        create(XMLArchive self, char const * filename, bool writeVersion=True, bool headerNode=True) -> bool
        """
        return _io.XMLArchive_create(self, *args)

    def close(self):
        r"""close(XMLArchive self)"""
        return _io.XMLArchive_close(self)

    def setRootName(self, name):
        r"""setRootName(XMLArchive self, string name)"""
        return _io.XMLArchive_setRootName(self, name)

    def setFormattedOutput(self, enable):
        r"""setFormattedOutput(XMLArchive self, bool enable)"""
        return _io.XMLArchive_setFormattedOutput(self, enable)

    def setCompression(self, enable):
        r"""setCompression(XMLArchive self, bool enable)"""
        return _io.XMLArchive_setCompression(self, enable)

    def setCompressionMethod(self, method):
        r"""setCompressionMethod(XMLArchive self, Seiscomp::IO::XMLArchive::CompressionMethod method)"""
        return _io.XMLArchive_setCompressionMethod(self, method)

    def rootNamespace(self):
        r"""rootNamespace(XMLArchive self) -> string"""
        return _io.XMLArchive_rootNamespace(self)

    def rootNamespaceUri(self):
        r"""rootNamespaceUri(XMLArchive self) -> string"""
        return _io.XMLArchive_rootNamespaceUri(self)

    def setRootNamespace(self, name, uri):
        r"""setRootNamespace(XMLArchive self, string name, string uri)"""
        return _io.XMLArchive_setRootNamespace(self, name, uri)

    def read(self, *args):
        r"""
        read(XMLArchive self, std::int8_t & value)
        read(XMLArchive self, std::int16_t & value)
        read(XMLArchive self, std::int32_t & value)
        read(XMLArchive self, std::int64_t & value)
        read(XMLArchive self, float & value)
        read(XMLArchive self, double & value)
        read(XMLArchive self, std::vector< char,std::allocator< char > > & value)
        read(XMLArchive self, std::vector< int8_t,std::allocator< int8_t > > & value)
        read(XMLArchive self, std::vector< int16_t,std::allocator< int16_t > > & value)
        read(XMLArchive self, std::vector< int32_t,std::allocator< int32_t > > & value)
        read(XMLArchive self, std::vector< int64_t,std::allocator< int64_t > > & value)
        read(XMLArchive self, vectorf value)
        read(XMLArchive self, vectord value)
        read(XMLArchive self, std::vector< std::string,std::allocator< std::string > > & value)
        read(XMLArchive self, std::vector< Seiscomp::Core::Time,std::allocator< Seiscomp::Core::Time > > & value)
        read(XMLArchive self, std::complex< float > & value)
        read(XMLArchive self, std::complex< double > & value)
        read(XMLArchive self, bool & value)
        read(XMLArchive self, vectorc value)
        read(XMLArchive self, string value)
        read(XMLArchive self, Time value)
        """
        return _io.XMLArchive_read(self, *args)

    def write(self, *args):
        r"""
        write(XMLArchive self, std::int8_t value)
        write(XMLArchive self, std::int16_t value)
        write(XMLArchive self, std::int32_t value)
        write(XMLArchive self, std::int64_t value)
        write(XMLArchive self, float value)
        write(XMLArchive self, double value)
        write(XMLArchive self, std::vector< char,std::allocator< char > > & value)
        write(XMLArchive self, std::vector< int8_t,std::allocator< int8_t > > & value)
        write(XMLArchive self, std::vector< int16_t,std::allocator< int16_t > > & value)
        write(XMLArchive self, std::vector< int32_t,std::allocator< int32_t > > & value)
        write(XMLArchive self, std::vector< int64_t,std::allocator< int64_t > > & value)
        write(XMLArchive self, vectorf value)
        write(XMLArchive self, vectord value)
        write(XMLArchive self, std::vector< std::string,std::allocator< std::string > > & value)
        write(XMLArchive self, std::vector< Seiscomp::Core::Time,std::allocator< Seiscomp::Core::Time > > & value)
        write(XMLArchive self, std::complex< float > & value)
        write(XMLArchive self, std::complex< double > & value)
        write(XMLArchive self, bool value)
        write(XMLArchive self, vectorc value)
        write(XMLArchive self, string value)
        write(XMLArchive self, Time value)
        """
        return _io.XMLArchive_write(self, *args)

# Register XMLArchive in _io:
_io.XMLArchive_swigregister(XMLArchive)

class BinaryArchive(seiscomp.core.GenericArchive):
    r"""Proxy of C++ Seiscomp::IO::BinaryArchive class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(BinaryArchive self) -> BinaryArchive
        __init__(BinaryArchive self, std::streambuf * buf, bool isReading=True) -> BinaryArchive
        """
        _io.BinaryArchive_swiginit(self, _io.new_BinaryArchive(*args))
    __swig_destroy__ = _io.delete_BinaryArchive

    def open(self, *args):
        r"""
        open(BinaryArchive self, char const * file) -> bool
        open(BinaryArchive self, std::streambuf * arg2) -> bool
        """
        return _io.BinaryArchive_open(self, *args)

    def create(self, *args):
        r"""
        create(BinaryArchive self, char const * file) -> bool
        create(BinaryArchive self, std::streambuf * arg2) -> bool
        """
        return _io.BinaryArchive_create(self, *args)

    def close(self):
        r"""close(BinaryArchive self)"""
        return _io.BinaryArchive_close(self)

    def read(self, *args):
        r"""
        read(BinaryArchive self, std::int8_t & value)
        read(BinaryArchive self, std::int16_t & value)
        read(BinaryArchive self, std::int32_t & value)
        read(BinaryArchive self, std::int64_t & value)
        read(BinaryArchive self, float & value)
        read(BinaryArchive self, double & value)
        read(BinaryArchive self, std::vector< char,std::allocator< char > > & value)
        read(BinaryArchive self, std::vector< int8_t,std::allocator< int8_t > > & value)
        read(BinaryArchive self, std::vector< int16_t,std::allocator< int16_t > > & value)
        read(BinaryArchive self, std::vector< int32_t,std::allocator< int32_t > > & value)
        read(BinaryArchive self, std::vector< int64_t,std::allocator< int64_t > > & value)
        read(BinaryArchive self, vectorf value)
        read(BinaryArchive self, vectord value)
        read(BinaryArchive self, std::vector< std::string,std::allocator< std::string > > & value)
        read(BinaryArchive self, std::vector< Seiscomp::Core::Time,std::allocator< Seiscomp::Core::Time > > & value)
        read(BinaryArchive self, std::complex< float > & value)
        read(BinaryArchive self, std::complex< double > & value)
        read(BinaryArchive self, bool & value)
        read(BinaryArchive self, vectorc value)
        read(BinaryArchive self, string value)
        read(BinaryArchive self, Time value)
        """
        return _io.BinaryArchive_read(self, *args)

    def write(self, *args):
        r"""
        write(BinaryArchive self, std::int8_t value)
        write(BinaryArchive self, std::int16_t value)
        write(BinaryArchive self, std::int32_t value)
        write(BinaryArchive self, std::int64_t value)
        write(BinaryArchive self, float value)
        write(BinaryArchive self, double value)
        write(BinaryArchive self, std::vector< char,std::allocator< char > > & value)
        write(BinaryArchive self, std::vector< int8_t,std::allocator< int8_t > > & value)
        write(BinaryArchive self, std::vector< int16_t,std::allocator< int16_t > > & value)
        write(BinaryArchive self, std::vector< int32_t,std::allocator< int32_t > > & value)
        write(BinaryArchive self, std::vector< int64_t,std::allocator< int64_t > > & value)
        write(BinaryArchive self, vectorf value)
        write(BinaryArchive self, vectord value)
        write(BinaryArchive self, std::vector< std::string,std::allocator< std::string > > & value)
        write(BinaryArchive self, std::vector< Seiscomp::Core::Time,std::allocator< Seiscomp::Core::Time > > & value)
        write(BinaryArchive self, std::complex< float > & value)
        write(BinaryArchive self, std::complex< double > & value)
        write(BinaryArchive self, bool value)
        write(BinaryArchive self, vectorc value)
        write(BinaryArchive self, string value)
        write(BinaryArchive self, Time value)
        """
        return _io.BinaryArchive_write(self, *args)

# Register BinaryArchive in _io:
_io.BinaryArchive_swigregister(BinaryArchive)

class VBinaryArchive(BinaryArchive):
    r"""Proxy of C++ Seiscomp::IO::VBinaryArchive class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(VBinaryArchive self, int forceWriteVersion=-1) -> VBinaryArchive
        __init__(VBinaryArchive self, std::streambuf * buf, bool isReading=True, int forceWriteVersion=-1) -> VBinaryArchive
        """
        _io.VBinaryArchive_swiginit(self, _io.new_VBinaryArchive(*args))

    def setWriteVersion(self, version):
        r"""setWriteVersion(VBinaryArchive self, int version)"""
        return _io.VBinaryArchive_setWriteVersion(self, version)

    def open(self, *args):
        r"""
        open(VBinaryArchive self, char const * file) -> bool
        open(VBinaryArchive self, std::streambuf * arg2) -> bool
        """
        return _io.VBinaryArchive_open(self, *args)

    def create(self, *args):
        r"""
        create(VBinaryArchive self, char const * file) -> bool
        create(VBinaryArchive self, std::streambuf * arg2) -> bool
        """
        return _io.VBinaryArchive_create(self, *args)

    def close(self):
        r"""close(VBinaryArchive self)"""
        return _io.VBinaryArchive_close(self)

    def errorMsg(self):
        r"""errorMsg(VBinaryArchive self) -> char const *"""
        return _io.VBinaryArchive_errorMsg(self)
    __swig_destroy__ = _io.delete_VBinaryArchive

# Register VBinaryArchive in _io:
_io.VBinaryArchive_swigregister(VBinaryArchive)

class LibmseedException(seiscomp.core.StreamException):
    r"""Proxy of C++ Seiscomp::IO::LibmseedException class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(LibmseedException self) -> LibmseedException
        __init__(LibmseedException self, string what) -> LibmseedException
        """
        _io.LibmseedException_swiginit(self, _io.new_LibmseedException(*args))
    __swig_destroy__ = _io.delete_LibmseedException

# Register LibmseedException in _io:
_io.LibmseedException_swigregister(LibmseedException)

class MSeedRecord(seiscomp.core.Record):
    r"""Proxy of C++ Seiscomp::IO::MSeedRecord class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def ClassName():
        r"""ClassName() -> char const *"""
        return _io.MSeedRecord_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _io.MSeedRecord_TypeInfo()

    def className(self):
        r"""className(MSeedRecord self) -> char const *"""
        return _io.MSeedRecord_className(self)

    def typeInfo(self):
        r"""typeInfo(MSeedRecord self) -> RTTI"""
        return _io.MSeedRecord_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> MSeedRecord
        Cast(Seiscomp::Core::BaseObjectPtr o) -> MSeedRecord
        """
        return _io.MSeedRecord_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> MSeedRecord
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MSeedRecord
        """
        return _io.MSeedRecord_ConstCast(*args)

    def __init__(self, *args):
        r"""
        __init__(MSeedRecord self, Seiscomp::Array::DataType dt=DOUBLE, Seiscomp::Record::Hint h=SAVE_RAW) -> MSeedRecord
        __init__(MSeedRecord self, MSRecord * msrec, Seiscomp::Array::DataType dt=DOUBLE, Seiscomp::Record::Hint h=SAVE_RAW) -> MSeedRecord
        __init__(MSeedRecord self, MSeedRecord ms) -> MSeedRecord
        __init__(MSeedRecord self, Record rec, int reclen=512) -> MSeedRecord
        """
        _io.MSeedRecord_swiginit(self, _io.new_MSeedRecord(*args))
    __swig_destroy__ = _io.delete_MSeedRecord

    def setNetworkCode(self, net):
        r"""setNetworkCode(MSeedRecord self, string net)"""
        return _io.MSeedRecord_setNetworkCode(self, net)

    def setStationCode(self, sta):
        r"""setStationCode(MSeedRecord self, string sta)"""
        return _io.MSeedRecord_setStationCode(self, sta)

    def setLocationCode(self, loc):
        r"""setLocationCode(MSeedRecord self, string loc)"""
        return _io.MSeedRecord_setLocationCode(self, loc)

    def setChannelCode(self, cha):
        r"""setChannelCode(MSeedRecord self, string cha)"""
        return _io.MSeedRecord_setChannelCode(self, cha)

    def setStartTime(self, time):
        r"""setStartTime(MSeedRecord self, Time time)"""
        return _io.MSeedRecord_setStartTime(self, time)

    def sequenceNumber(self):
        r"""sequenceNumber(MSeedRecord self) -> int"""
        return _io.MSeedRecord_sequenceNumber(self)

    def setSequenceNumber(self, seqno):
        r"""setSequenceNumber(MSeedRecord self, int seqno)"""
        return _io.MSeedRecord_setSequenceNumber(self, seqno)

    def dataQuality(self):
        r"""dataQuality(MSeedRecord self) -> char"""
        return _io.MSeedRecord_dataQuality(self)

    def setDataQuality(self, qual):
        r"""setDataQuality(MSeedRecord self, char qual)"""
        return _io.MSeedRecord_setDataQuality(self, qual)

    def sampleRateFactor(self):
        r"""sampleRateFactor(MSeedRecord self) -> int"""
        return _io.MSeedRecord_sampleRateFactor(self)

    def setSampleRateFactor(self, srfact):
        r"""setSampleRateFactor(MSeedRecord self, int srfact)"""
        return _io.MSeedRecord_setSampleRateFactor(self, srfact)

    def sampleRateMultiplier(self):
        r"""sampleRateMultiplier(MSeedRecord self) -> int"""
        return _io.MSeedRecord_sampleRateMultiplier(self)

    def setSampleRateMultiplier(self, srmult):
        r"""setSampleRateMultiplier(MSeedRecord self, int srmult)"""
        return _io.MSeedRecord_setSampleRateMultiplier(self, srmult)

    def byteOrder(self):
        r"""byteOrder(MSeedRecord self) -> int8_t"""
        return _io.MSeedRecord_byteOrder(self)

    def encoding(self):
        r"""encoding(MSeedRecord self) -> int8_t"""
        return _io.MSeedRecord_encoding(self)

    def sampleRateNumerator(self):
        r"""sampleRateNumerator(MSeedRecord self) -> int"""
        return _io.MSeedRecord_sampleRateNumerator(self)

    def sampleRateDenominator(self):
        r"""sampleRateDenominator(MSeedRecord self) -> int"""
        return _io.MSeedRecord_sampleRateDenominator(self)

    def frameNumber(self):
        r"""frameNumber(MSeedRecord self) -> int"""
        return _io.MSeedRecord_frameNumber(self)

    def endTime(self):
        r"""endTime(MSeedRecord self) -> Time"""
        return _io.MSeedRecord_endTime(self)

    def recordLength(self):
        r"""recordLength(MSeedRecord self) -> int"""
        return _io.MSeedRecord_recordLength(self)

    def leapSeconds(self):
        r"""leapSeconds(MSeedRecord self) -> int"""
        return _io.MSeedRecord_leapSeconds(self)

    def data(self):
        r"""data(MSeedRecord self) -> Array"""
        return _io.MSeedRecord_data(self)

    def raw(self):
        r"""raw(MSeedRecord self) -> Array"""
        return _io.MSeedRecord_raw(self)

    def saveSpace(self):
        r"""saveSpace(MSeedRecord self)"""
        return _io.MSeedRecord_saveSpace(self)

    def copy(self):
        r"""copy(MSeedRecord self) -> Record"""
        return _io.MSeedRecord_copy(self)

    def useEncoding(self, flag):
        r"""useEncoding(MSeedRecord self, bool flag)"""
        return _io.MSeedRecord_useEncoding(self, flag)

    def setOutputRecordLength(self, reclen):
        r"""setOutputRecordLength(MSeedRecord self, int reclen)"""
        return _io.MSeedRecord_setOutputRecordLength(self, reclen)

    def read(self, _in):
        r"""read(MSeedRecord self, std::istream & _in)"""
        return _io.MSeedRecord_read(self, _in)

    def write(self, out):
        r"""write(MSeedRecord self, std::ostream & out)"""
        return _io.MSeedRecord_write(self, out)

# Register MSeedRecord in _io:
_io.MSeedRecord_swigregister(MSeedRecord)

def MSeedRecord_ClassName():
    r"""MSeedRecord_ClassName() -> char const *"""
    return _io.MSeedRecord_ClassName()

def MSeedRecord_TypeInfo():
    r"""MSeedRecord_TypeInfo() -> RTTI"""
    return _io.MSeedRecord_TypeInfo()

def MSeedRecord_Cast(*args):
    r"""
    MSeedRecord_Cast(BaseObject o) -> MSeedRecord
    MSeedRecord_Cast(Seiscomp::Core::BaseObjectPtr o) -> MSeedRecord
    """
    return _io.MSeedRecord_Cast(*args)

def MSeedRecord_ConstCast(*args):
    r"""
    MSeedRecord_ConstCast(BaseObject o) -> MSeedRecord
    MSeedRecord_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> MSeedRecord
    """
    return _io.MSeedRecord_ConstCast(*args)

class FileRecordStream(RecordStream):
    r"""Proxy of C++ Seiscomp::RecordStream::File class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Begin = _io.FileRecordStream_Begin
    
    Current = _io.FileRecordStream_Current
    
    End = _io.FileRecordStream_End
    

    def __init__(self, *args):
        r"""
        File() -> FileRecordStream
        File(string name) -> FileRecordStream
        __init__(FileRecordStream self, FileRecordStream f) -> FileRecordStream
        """
        _io.FileRecordStream_swiginit(self, _io.new_FileRecordStream(*args))
    __swig_destroy__ = _io.delete_FileRecordStream

    def setSource(self, filename):
        r"""setSource(FileRecordStream self, string filename) -> bool"""
        return _io.FileRecordStream_setSource(self, filename)

    def addStream(self, *args):
        r"""
        addStream(FileRecordStream self, string networkCode, string stationCode, string locationCode, string channelCode) -> bool
        addStream(FileRecordStream self, string networkCode, string stationCode, string locationCode, string channelCode, Time startTime, Time endTime) -> bool
        """
        return _io.FileRecordStream_addStream(self, *args)

    def setStartTime(self, startTime):
        r"""setStartTime(FileRecordStream self, Time startTime) -> bool"""
        return _io.FileRecordStream_setStartTime(self, startTime)

    def setEndTime(self, endTime):
        r"""setEndTime(FileRecordStream self, Time endTime) -> bool"""
        return _io.FileRecordStream_setEndTime(self, endTime)

    def close(self):
        r"""close(FileRecordStream self)"""
        return _io.FileRecordStream_close(self)

    def setRecordType(self, type):
        r"""setRecordType(FileRecordStream self, char const * type) -> bool"""
        return _io.FileRecordStream_setRecordType(self, type)

    def next(self):
        r"""next(FileRecordStream self) -> Record"""
        return _io.FileRecordStream_next(self)

    def name(self):
        r"""name(FileRecordStream self) -> string"""
        return _io.FileRecordStream_name(self)

    def tell(self):
        r"""tell(FileRecordStream self) -> size_t"""
        return _io.FileRecordStream_tell(self)

    def seek(self, *args):
        r"""
        seek(FileRecordStream self, size_t pos) -> FileRecordStream
        seek(FileRecordStream self, int off, Seiscomp::RecordStream::File::SeekDir dir) -> FileRecordStream
        """
        return _io.FileRecordStream_seek(self, *args)

# Register FileRecordStream in _io:
_io.FileRecordStream_swigregister(FileRecordStream)

class SeedlinkException(RecordStreamException):
    r"""Proxy of C++ Seiscomp::RecordStream::SeedlinkException class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SeedlinkException self) -> SeedlinkException
        __init__(SeedlinkException self, string what) -> SeedlinkException
        """
        _io.SeedlinkException_swiginit(self, _io.new_SeedlinkException(*args))
    __swig_destroy__ = _io.delete_SeedlinkException

# Register SeedlinkException in _io:
_io.SeedlinkException_swigregister(SeedlinkException)

class SeedlinkCommandException(SeedlinkException):
    r"""Proxy of C++ Seiscomp::RecordStream::SeedlinkCommandException class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SeedlinkCommandException self) -> SeedlinkCommandException
        __init__(SeedlinkCommandException self, string what) -> SeedlinkCommandException
        """
        _io.SeedlinkCommandException_swiginit(self, _io.new_SeedlinkCommandException(*args))
    __swig_destroy__ = _io.delete_SeedlinkCommandException

# Register SeedlinkCommandException in _io:
_io.SeedlinkCommandException_swigregister(SeedlinkCommandException)

class SLStreamIdx(object):
    r"""Proxy of C++ Seiscomp::RecordStream::SLStreamIdx class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SLStreamIdx self) -> SLStreamIdx
        __init__(SLStreamIdx self, string net, string sta, string loc, string cha) -> SLStreamIdx
        __init__(SLStreamIdx self, string net, string sta, string loc, string cha, Time stime, Time etime) -> SLStreamIdx
        """
        _io.SLStreamIdx_swiginit(self, _io.new_SLStreamIdx(*args))

    def __lt__(self, other):
        r"""__lt__(SLStreamIdx self, SLStreamIdx other) -> bool"""
        return _io.SLStreamIdx___lt__(self, other)

    def __eq__(self, other):
        r"""__eq__(SLStreamIdx self, SLStreamIdx other) -> bool"""
        return _io.SLStreamIdx___eq__(self, other)

    def network(self):
        r"""network(SLStreamIdx self) -> string"""
        return _io.SLStreamIdx_network(self)

    def station(self):
        r"""station(SLStreamIdx self) -> string"""
        return _io.SLStreamIdx_station(self)

    def channel(self):
        r"""channel(SLStreamIdx self) -> string"""
        return _io.SLStreamIdx_channel(self)

    def location(self):
        r"""location(SLStreamIdx self) -> string"""
        return _io.SLStreamIdx_location(self)

    def selector(self):
        r"""selector(SLStreamIdx self) -> string"""
        return _io.SLStreamIdx_selector(self)

    def startTime(self):
        r"""startTime(SLStreamIdx self) -> Time"""
        return _io.SLStreamIdx_startTime(self)

    def endTime(self):
        r"""endTime(SLStreamIdx self) -> Time"""
        return _io.SLStreamIdx_endTime(self)

    def timestamp(self):
        r"""timestamp(SLStreamIdx self) -> Time"""
        return _io.SLStreamIdx_timestamp(self)

    def setTimestamp(self, rectime):
        r"""setTimestamp(SLStreamIdx self, Time rectime)"""
        return _io.SLStreamIdx_setTimestamp(self, rectime)
    __swig_destroy__ = _io.delete_SLStreamIdx

# Register SLStreamIdx in _io:
_io.SLStreamIdx_swigregister(SLStreamIdx)

class SLConnection(RecordStream):
    r"""Proxy of C++ Seiscomp::RecordStream::SLConnection class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def ClassName():
        r"""ClassName() -> char const *"""
        return _io.SLConnection_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _io.SLConnection_TypeInfo()

    def className(self):
        r"""className(SLConnection self) -> char const *"""
        return _io.SLConnection_className(self)

    def typeInfo(self):
        r"""typeInfo(SLConnection self) -> RTTI"""
        return _io.SLConnection_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> SLConnection
        Cast(Seiscomp::Core::BaseObjectPtr o) -> SLConnection
        """
        return _io.SLConnection_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> SLConnection
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SLConnection
        """
        return _io.SLConnection_ConstCast(*args)

    def __init__(self, *args):
        r"""
        __init__(SLConnection self) -> SLConnection
        __init__(SLConnection self, string serverloc) -> SLConnection
        """
        _io.SLConnection_swiginit(self, _io.new_SLConnection(*args))
    __swig_destroy__ = _io.delete_SLConnection

    def setRecordType(self, arg2):
        r"""setRecordType(SLConnection self, char const * arg2) -> bool"""
        return _io.SLConnection_setRecordType(self, arg2)

    def setSource(self, source):
        r"""setSource(SLConnection self, string source) -> bool"""
        return _io.SLConnection_setSource(self, source)

    def addStream(self, *args):
        r"""
        addStream(SLConnection self, string networkCode, string stationCode, string locationCode, string channelCode) -> bool
        addStream(SLConnection self, string networkCode, string stationCode, string locationCode, string channelCode, Time startTime, Time endTime) -> bool
        """
        return _io.SLConnection_addStream(self, *args)

    def setStartTime(self, startTime):
        r"""setStartTime(SLConnection self, Time startTime) -> bool"""
        return _io.SLConnection_setStartTime(self, startTime)

    def setEndTime(self, endTime):
        r"""setEndTime(SLConnection self, Time endTime) -> bool"""
        return _io.SLConnection_setEndTime(self, endTime)

    def setTimeout(self, seconds):
        r"""setTimeout(SLConnection self, int seconds) -> bool"""
        return _io.SLConnection_setTimeout(self, seconds)

    def close(self):
        r"""close(SLConnection self)"""
        return _io.SLConnection_close(self)

    def next(self):
        r"""next(SLConnection self) -> Record"""
        return _io.SLConnection_next(self)

    def clear(self):
        r"""clear(SLConnection self) -> bool"""
        return _io.SLConnection_clear(self)

    def reconnect(self):
        r"""reconnect(SLConnection self) -> bool"""
        return _io.SLConnection_reconnect(self)

# Register SLConnection in _io:
_io.SLConnection_swigregister(SLConnection)

def SLConnection_ClassName():
    r"""SLConnection_ClassName() -> char const *"""
    return _io.SLConnection_ClassName()

def SLConnection_TypeInfo():
    r"""SLConnection_TypeInfo() -> RTTI"""
    return _io.SLConnection_TypeInfo()

def SLConnection_Cast(*args):
    r"""
    SLConnection_Cast(BaseObject o) -> SLConnection
    SLConnection_Cast(Seiscomp::Core::BaseObjectPtr o) -> SLConnection
    """
    return _io.SLConnection_Cast(*args)

def SLConnection_ConstCast(*args):
    r"""
    SLConnection_ConstCast(BaseObject o) -> SLConnection
    SLConnection_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> SLConnection
    """
    return _io.SLConnection_ConstCast(*args)

class ArclinkException(RecordStreamException):
    r"""Proxy of C++ Seiscomp::RecordStream::Arclink::_private::ArclinkException class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(ArclinkException self) -> ArclinkException
        __init__(ArclinkException self, string what) -> ArclinkException
        """
        _io.ArclinkException_swiginit(self, _io.new_ArclinkException(*args))
    __swig_destroy__ = _io.delete_ArclinkException

# Register ArclinkException in _io:
_io.ArclinkException_swigregister(ArclinkException)

class ArclinkCommandException(ArclinkException):
    r"""Proxy of C++ Seiscomp::RecordStream::Arclink::_private::ArclinkCommandException class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(ArclinkCommandException self) -> ArclinkCommandException
        __init__(ArclinkCommandException self, string what) -> ArclinkCommandException
        """
        _io.ArclinkCommandException_swiginit(self, _io.new_ArclinkCommandException(*args))
    __swig_destroy__ = _io.delete_ArclinkCommandException

# Register ArclinkCommandException in _io:
_io.ArclinkCommandException_swigregister(ArclinkCommandException)

class ArclinkConnection(RecordStream):
    r"""Proxy of C++ Seiscomp::RecordStream::Arclink::_private::ArclinkConnection class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def ClassName():
        r"""ClassName() -> char const *"""
        return _io.ArclinkConnection_ClassName()

    @staticmethod
    def TypeInfo():
        r"""TypeInfo() -> RTTI"""
        return _io.ArclinkConnection_TypeInfo()

    def className(self):
        r"""className(ArclinkConnection self) -> char const *"""
        return _io.ArclinkConnection_className(self)

    def typeInfo(self):
        r"""typeInfo(ArclinkConnection self) -> RTTI"""
        return _io.ArclinkConnection_typeInfo(self)

    @staticmethod
    def Cast(*args):
        r"""
        Cast(BaseObject o) -> ArclinkConnection
        Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkConnection
        """
        return _io.ArclinkConnection_Cast(*args)

    @staticmethod
    def ConstCast(*args):
        r"""
        ConstCast(BaseObject o) -> ArclinkConnection
        ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkConnection
        """
        return _io.ArclinkConnection_ConstCast(*args)

    def __init__(self, *args):
        r"""
        __init__(ArclinkConnection self) -> ArclinkConnection
        __init__(ArclinkConnection self, string serverloc) -> ArclinkConnection
        """
        _io.ArclinkConnection_swiginit(self, _io.new_ArclinkConnection(*args))
    __swig_destroy__ = _io.delete_ArclinkConnection

    def setRecordType(self, arg2):
        r"""setRecordType(ArclinkConnection self, char const * arg2) -> bool"""
        return _io.ArclinkConnection_setRecordType(self, arg2)

    def setSource(self, serverloc):
        r"""setSource(ArclinkConnection self, string serverloc) -> bool"""
        return _io.ArclinkConnection_setSource(self, serverloc)

    def setUser(self, name, password):
        r"""setUser(ArclinkConnection self, string name, string password) -> bool"""
        return _io.ArclinkConnection_setUser(self, name, password)

    def addStream(self, *args):
        r"""
        addStream(ArclinkConnection self, string networkCode, string stationCode, string locationCode, string channelCode) -> bool
        addStream(ArclinkConnection self, string networkCode, string stationCode, string locationCode, string channelCode, Time stime, Time etime) -> bool
        """
        return _io.ArclinkConnection_addStream(self, *args)

    def setStartTime(self, stime):
        r"""setStartTime(ArclinkConnection self, Time stime) -> bool"""
        return _io.ArclinkConnection_setStartTime(self, stime)

    def setEndTime(self, etime):
        r"""setEndTime(ArclinkConnection self, Time etime) -> bool"""
        return _io.ArclinkConnection_setEndTime(self, etime)

    def setTimeout(self, seconds):
        r"""setTimeout(ArclinkConnection self, int seconds) -> bool"""
        return _io.ArclinkConnection_setTimeout(self, seconds)

    def close(self):
        r"""close(ArclinkConnection self)"""
        return _io.ArclinkConnection_close(self)

    def next(self):
        r"""next(ArclinkConnection self) -> Record"""
        return _io.ArclinkConnection_next(self)

    def clear(self):
        r"""clear(ArclinkConnection self) -> bool"""
        return _io.ArclinkConnection_clear(self)

    def reconnect(self):
        r"""reconnect(ArclinkConnection self) -> bool"""
        return _io.ArclinkConnection_reconnect(self)

# Register ArclinkConnection in _io:
_io.ArclinkConnection_swigregister(ArclinkConnection)

def ArclinkConnection_ClassName():
    r"""ArclinkConnection_ClassName() -> char const *"""
    return _io.ArclinkConnection_ClassName()

def ArclinkConnection_TypeInfo():
    r"""ArclinkConnection_TypeInfo() -> RTTI"""
    return _io.ArclinkConnection_TypeInfo()

def ArclinkConnection_Cast(*args):
    r"""
    ArclinkConnection_Cast(BaseObject o) -> ArclinkConnection
    ArclinkConnection_Cast(Seiscomp::Core::BaseObjectPtr o) -> ArclinkConnection
    """
    return _io.ArclinkConnection_Cast(*args)

def ArclinkConnection_ConstCast(*args):
    r"""
    ArclinkConnection_ConstCast(BaseObject o) -> ArclinkConnection
    ArclinkConnection_ConstCast(Seiscomp::Core::BaseObjectCPtr o) -> ArclinkConnection
    """
    return _io.ArclinkConnection_ConstCast(*args)

class CombinedConnection(RecordStream):
    r"""Proxy of C++ Seiscomp::RecordStream::CombinedConnection class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(CombinedConnection self) -> CombinedConnection
        __init__(CombinedConnection self, string serverloc) -> CombinedConnection
        """
        _io.CombinedConnection_swiginit(self, _io.new_CombinedConnection(*args))
    __swig_destroy__ = _io.delete_CombinedConnection

    def setRecordType(self, arg2):
        r"""setRecordType(CombinedConnection self, char const * arg2) -> bool"""
        return _io.CombinedConnection_setRecordType(self, arg2)

    def setSource(self, serverloc):
        r"""setSource(CombinedConnection self, string serverloc) -> bool"""
        return _io.CombinedConnection_setSource(self, serverloc)

    def addStream(self, *args):
        r"""
        addStream(CombinedConnection self, string networkCode, string stationCode, string locationCode, string channelCode) -> bool
        addStream(CombinedConnection self, string networkCode, string stationCode, string locationCode, string channelCode, Time startTime, Time endTime) -> bool
        """
        return _io.CombinedConnection_addStream(self, *args)

    def setStartTime(self, stime):
        r"""setStartTime(CombinedConnection self, Time stime) -> bool"""
        return _io.CombinedConnection_setStartTime(self, stime)

    def setEndTime(self, etime):
        r"""setEndTime(CombinedConnection self, Time etime) -> bool"""
        return _io.CombinedConnection_setEndTime(self, etime)

    def setTimeout(self, seconds):
        r"""setTimeout(CombinedConnection self, int seconds) -> bool"""
        return _io.CombinedConnection_setTimeout(self, seconds)

    def close(self):
        r"""close(CombinedConnection self)"""
        return _io.CombinedConnection_close(self)

    def next(self):
        r"""next(CombinedConnection self) -> Record"""
        return _io.CombinedConnection_next(self)

# Register CombinedConnection in _io:
_io.CombinedConnection_swigregister(CombinedConnection)

class RecordIIRFilterF(RecordFilterInterface):
    r"""Proxy of C++ Seiscomp::IO::RecordIIRFilter< float > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, filter=None):
        r"""__init__(RecordIIRFilterF self, InPlaceFilterF filter=None) -> RecordIIRFilterF"""
        _io.RecordIIRFilterF_swiginit(self, _io.new_RecordIIRFilterF(filter))
    __swig_destroy__ = _io.delete_RecordIIRFilterF

    def setIIR(self, f):
        r"""setIIR(RecordIIRFilterF self, InPlaceFilterF f)"""
        return _io.RecordIIRFilterF_setIIR(self, f)

    def filter(self, *args):
        r"""
        filter(RecordIIRFilterF self) -> InPlaceFilterF
        filter(RecordIIRFilterF self) -> InPlaceFilterF
        """
        return _io.RecordIIRFilterF_filter(self, *args)

    def apply(self, rec):
        r"""apply(RecordIIRFilterF self, GenericRecord rec) -> bool"""
        return _io.RecordIIRFilterF_apply(self, rec)

    def __nonzero__(self):
        return _io.RecordIIRFilterF___nonzero__(self)
    __bool__ = __nonzero__



    def lastError(self):
        r"""lastError(RecordIIRFilterF self) -> string"""
        return _io.RecordIIRFilterF_lastError(self)

    def feed(self, rec):
        r"""feed(RecordIIRFilterF self, Record rec) -> Record"""
        return _io.RecordIIRFilterF_feed(self, rec)

    def flush(self):
        r"""flush(RecordIIRFilterF self) -> Record"""
        return _io.RecordIIRFilterF_flush(self)

    def reset(self):
        r"""reset(RecordIIRFilterF self)"""
        return _io.RecordIIRFilterF_reset(self)

    def clone(self):
        r"""clone(RecordIIRFilterF self) -> RecordFilterInterface"""
        return _io.RecordIIRFilterF_clone(self)

# Register RecordIIRFilterF in _io:
_io.RecordIIRFilterF_swigregister(RecordIIRFilterF)

class RecordIIRFilterD(RecordFilterInterface):
    r"""Proxy of C++ Seiscomp::IO::RecordIIRFilter< double > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, filter=None):
        r"""__init__(RecordIIRFilterD self, InPlaceFilterD filter=None) -> RecordIIRFilterD"""
        _io.RecordIIRFilterD_swiginit(self, _io.new_RecordIIRFilterD(filter))
    __swig_destroy__ = _io.delete_RecordIIRFilterD

    def setIIR(self, f):
        r"""setIIR(RecordIIRFilterD self, InPlaceFilterD f)"""
        return _io.RecordIIRFilterD_setIIR(self, f)

    def filter(self, *args):
        r"""
        filter(RecordIIRFilterD self) -> InPlaceFilterD
        filter(RecordIIRFilterD self) -> InPlaceFilterD
        """
        return _io.RecordIIRFilterD_filter(self, *args)

    def apply(self, rec):
        r"""apply(RecordIIRFilterD self, GenericRecord rec) -> bool"""
        return _io.RecordIIRFilterD_apply(self, rec)

    def __nonzero__(self):
        return _io.RecordIIRFilterD___nonzero__(self)
    __bool__ = __nonzero__



    def lastError(self):
        r"""lastError(RecordIIRFilterD self) -> string"""
        return _io.RecordIIRFilterD_lastError(self)

    def feed(self, rec):
        r"""feed(RecordIIRFilterD self, Record rec) -> Record"""
        return _io.RecordIIRFilterD_feed(self, rec)

    def flush(self):
        r"""flush(RecordIIRFilterD self) -> Record"""
        return _io.RecordIIRFilterD_flush(self)

    def reset(self):
        r"""reset(RecordIIRFilterD self)"""
        return _io.RecordIIRFilterD_reset(self)

    def clone(self):
        r"""clone(RecordIIRFilterD self) -> RecordFilterInterface"""
        return _io.RecordIIRFilterD_clone(self)

# Register RecordIIRFilterD in _io:
_io.RecordIIRFilterD_swigregister(RecordIIRFilterD)

class RecordResamplerF(RecordResamplerBase):
    r"""Proxy of C++ Seiscomp::IO::RecordResampler< float > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, targetFrequency, fp=0.7, fs=0.9, coeffScale=10, lanczosWidth=3):
        r"""__init__(RecordResamplerF self, double targetFrequency, double fp=0.7, double fs=0.9, double coeffScale=10, int lanczosWidth=3) -> RecordResamplerF"""
        _io.RecordResamplerF_swiginit(self, _io.new_RecordResamplerF(targetFrequency, fp, fs, coeffScale, lanczosWidth))
    __swig_destroy__ = _io.delete_RecordResamplerF

    def feed(self, record):
        r"""feed(RecordResamplerF self, Record record) -> Record"""
        return _io.RecordResamplerF_feed(self, record)

    def reset(self):
        r"""reset(RecordResamplerF self)"""
        return _io.RecordResamplerF_reset(self)

    def clone(self):
        r"""clone(RecordResamplerF self) -> RecordFilterInterface"""
        return _io.RecordResamplerF_clone(self)

# Register RecordResamplerF in _io:
_io.RecordResamplerF_swigregister(RecordResamplerF)

class RecordResamplerD(RecordResamplerBase):
    r"""Proxy of C++ Seiscomp::IO::RecordResampler< double > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, targetFrequency, fp=0.7, fs=0.9, coeffScale=10, lanczosWidth=3):
        r"""__init__(RecordResamplerD self, double targetFrequency, double fp=0.7, double fs=0.9, double coeffScale=10, int lanczosWidth=3) -> RecordResamplerD"""
        _io.RecordResamplerD_swiginit(self, _io.new_RecordResamplerD(targetFrequency, fp, fs, coeffScale, lanczosWidth))
    __swig_destroy__ = _io.delete_RecordResamplerD

    def feed(self, record):
        r"""feed(RecordResamplerD self, Record record) -> Record"""
        return _io.RecordResamplerD_feed(self, record)

    def reset(self):
        r"""reset(RecordResamplerD self)"""
        return _io.RecordResamplerD_reset(self)

    def clone(self):
        r"""clone(RecordResamplerD self) -> RecordFilterInterface"""
        return _io.RecordResamplerD_clone(self)

# Register RecordResamplerD in _io:
_io.RecordResamplerD_swigregister(RecordResamplerD)

class RecordResamplerI(RecordResamplerBase):
    r"""Proxy of C++ Seiscomp::IO::RecordResampler< int > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, targetFrequency, fp=0.7, fs=0.9, coeffScale=10, lanczosWidth=3):
        r"""__init__(RecordResamplerI self, double targetFrequency, double fp=0.7, double fs=0.9, double coeffScale=10, int lanczosWidth=3) -> RecordResamplerI"""
        _io.RecordResamplerI_swiginit(self, _io.new_RecordResamplerI(targetFrequency, fp, fs, coeffScale, lanczosWidth))
    __swig_destroy__ = _io.delete_RecordResamplerI

    def feed(self, record):
        r"""feed(RecordResamplerI self, Record record) -> Record"""
        return _io.RecordResamplerI_feed(self, record)

    def reset(self):
        r"""reset(RecordResamplerI self)"""
        return _io.RecordResamplerI_reset(self)

    def clone(self):
        r"""clone(RecordResamplerI self) -> RecordFilterInterface"""
        return _io.RecordResamplerI_clone(self)

# Register RecordResamplerI in _io:
_io.RecordResamplerI_swigregister(RecordResamplerI)

class ExportObjectList(object):
    r"""Proxy of C++ std::vector< Seiscomp::Core::BaseObject * > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(ExportObjectList self) -> SwigPyIterator"""
        return _io.ExportObjectList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(ExportObjectList self) -> bool"""
        return _io.ExportObjectList___nonzero__(self)

    def __bool__(self):
        r"""__bool__(ExportObjectList self) -> bool"""
        return _io.ExportObjectList___bool__(self)

    def __len__(self):
        r"""__len__(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::size_type"""
        return _io.ExportObjectList___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::difference_type i, std::vector< Seiscomp::Core::BaseObject * >::difference_type j) -> ExportObjectList"""
        return _io.ExportObjectList___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::difference_type i, std::vector< Seiscomp::Core::BaseObject * >::difference_type j)
        __setslice__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::difference_type i, std::vector< Seiscomp::Core::BaseObject * >::difference_type j, ExportObjectList v)
        """
        return _io.ExportObjectList___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::difference_type i, std::vector< Seiscomp::Core::BaseObject * >::difference_type j)"""
        return _io.ExportObjectList___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::difference_type i)
        __delitem__(ExportObjectList self, PySliceObject * slice)
        """
        return _io.ExportObjectList___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(ExportObjectList self, PySliceObject * slice) -> ExportObjectList
        __getitem__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::difference_type i) -> BaseObject
        """
        return _io.ExportObjectList___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(ExportObjectList self, PySliceObject * slice, ExportObjectList v)
        __setitem__(ExportObjectList self, PySliceObject * slice)
        __setitem__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::difference_type i, BaseObject x)
        """
        return _io.ExportObjectList___setitem__(self, *args)

    def pop(self):
        r"""pop(ExportObjectList self) -> BaseObject"""
        return _io.ExportObjectList_pop(self)

    def append(self, x):
        r"""append(ExportObjectList self, BaseObject x)"""
        return _io.ExportObjectList_append(self, x)

    def empty(self):
        r"""empty(ExportObjectList self) -> bool"""
        return _io.ExportObjectList_empty(self)

    def size(self):
        r"""size(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::size_type"""
        return _io.ExportObjectList_size(self)

    def swap(self, v):
        r"""swap(ExportObjectList self, ExportObjectList v)"""
        return _io.ExportObjectList_swap(self, v)

    def begin(self):
        r"""begin(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::iterator"""
        return _io.ExportObjectList_begin(self)

    def end(self):
        r"""end(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::iterator"""
        return _io.ExportObjectList_end(self)

    def rbegin(self):
        r"""rbegin(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::reverse_iterator"""
        return _io.ExportObjectList_rbegin(self)

    def rend(self):
        r"""rend(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::reverse_iterator"""
        return _io.ExportObjectList_rend(self)

    def clear(self):
        r"""clear(ExportObjectList self)"""
        return _io.ExportObjectList_clear(self)

    def get_allocator(self):
        r"""get_allocator(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::allocator_type"""
        return _io.ExportObjectList_get_allocator(self)

    def pop_back(self):
        r"""pop_back(ExportObjectList self)"""
        return _io.ExportObjectList_pop_back(self)

    def erase(self, *args):
        r"""
        erase(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::iterator pos) -> std::vector< Seiscomp::Core::BaseObject * >::iterator
        erase(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::iterator first, std::vector< Seiscomp::Core::BaseObject * >::iterator last) -> std::vector< Seiscomp::Core::BaseObject * >::iterator
        """
        return _io.ExportObjectList_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(ExportObjectList self) -> ExportObjectList
        __init__(ExportObjectList self, ExportObjectList other) -> ExportObjectList
        __init__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::size_type size) -> ExportObjectList
        __init__(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::size_type size, BaseObject value) -> ExportObjectList
        """
        _io.ExportObjectList_swiginit(self, _io.new_ExportObjectList(*args))

    def push_back(self, x):
        r"""push_back(ExportObjectList self, BaseObject x)"""
        return _io.ExportObjectList_push_back(self, x)

    def front(self):
        r"""front(ExportObjectList self) -> BaseObject"""
        return _io.ExportObjectList_front(self)

    def back(self):
        r"""back(ExportObjectList self) -> BaseObject"""
        return _io.ExportObjectList_back(self)

    def assign(self, n, x):
        r"""assign(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::size_type n, BaseObject x)"""
        return _io.ExportObjectList_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::size_type new_size)
        resize(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::size_type new_size, BaseObject x)
        """
        return _io.ExportObjectList_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::iterator pos, BaseObject x) -> std::vector< Seiscomp::Core::BaseObject * >::iterator
        insert(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::iterator pos, std::vector< Seiscomp::Core::BaseObject * >::size_type n, BaseObject x)
        """
        return _io.ExportObjectList_insert(self, *args)

    def reserve(self, n):
        r"""reserve(ExportObjectList self, std::vector< Seiscomp::Core::BaseObject * >::size_type n)"""
        return _io.ExportObjectList_reserve(self, n)

    def capacity(self):
        r"""capacity(ExportObjectList self) -> std::vector< Seiscomp::Core::BaseObject * >::size_type"""
        return _io.ExportObjectList_capacity(self)
    __swig_destroy__ = _io.delete_ExportObjectList

# Register ExportObjectList in _io:
_io.ExportObjectList_swigregister(ExportObjectList)