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

"""
@mainpage API Reference

Introduction
------------

The pysigrok API provides an object-oriented Python interface to the
functionality in libsigrok. It is built on top of the libsigrokcxx C++ API.

Getting started
---------------

Usage of the pysigrok API needs to begin with a call to Context.create().
This will create the global libsigrok context and returns a Context object.
Methods on this object provide access to the hardware drivers, input and output
formats supported by the library, as well as means of creating other objects
such as sessions and triggers.

Error handling
--------------

When any libsigrok C API call returns an error, an Error exception is raised,
which provides access to the error code and description.
"""


from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_classes')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_classes')
    _classes = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_classes', [dirname(__file__)])
        except ImportError:
            import _classes
            return _classes
        try:
            _mod = imp.load_module('_classes', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _classes = swig_import_helper()
    del swig_import_helper
else:
    import _classes
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

SHARED_PTR_DISOWN = _classes.SHARED_PTR_DISOWN
class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        return _classes.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _classes.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class StringMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.StringMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.StringMap___nonzero__(self)

    def __bool__(self):
        return _classes.StringMap___bool__(self)

    def __len__(self):
        return _classes.StringMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _classes.StringMap___getitem__(self, key)

    def __delitem__(self, key):
        return _classes.StringMap___delitem__(self, key)

    def has_key(self, key):
        return _classes.StringMap_has_key(self, key)

    def keys(self):
        return _classes.StringMap_keys(self)

    def values(self):
        return _classes.StringMap_values(self)

    def items(self):
        return _classes.StringMap_items(self)

    def __contains__(self, key):
        return _classes.StringMap___contains__(self, key)

    def key_iterator(self):
        return _classes.StringMap_key_iterator(self)

    def value_iterator(self):
        return _classes.StringMap_value_iterator(self)

    def __setitem__(self, *args):
        return _classes.StringMap___setitem__(self, *args)

    def asdict(self):
        return _classes.StringMap_asdict(self)

    def __init__(self, *args):
        this = _classes.new_StringMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _classes.StringMap_empty(self)

    def size(self):
        return _classes.StringMap_size(self)

    def swap(self, v):
        return _classes.StringMap_swap(self, v)

    def begin(self):
        return _classes.StringMap_begin(self)

    def end(self):
        return _classes.StringMap_end(self)

    def rbegin(self):
        return _classes.StringMap_rbegin(self)

    def rend(self):
        return _classes.StringMap_rend(self)

    def clear(self):
        return _classes.StringMap_clear(self)

    def get_allocator(self):
        return _classes.StringMap_get_allocator(self)

    def count(self, x):
        return _classes.StringMap_count(self, x)

    def erase(self, *args):
        return _classes.StringMap_erase(self, *args)

    def find(self, x):
        return _classes.StringMap_find(self, x)

    def lower_bound(self, x):
        return _classes.StringMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _classes.StringMap_upper_bound(self, x)
    __swig_destroy__ = _classes.delete_StringMap
    __del__ = lambda self: None
StringMap_swigregister = _classes.StringMap_swigregister
StringMap_swigregister(StringMap)

class DriverMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DriverMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DriverMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.DriverMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.DriverMap___nonzero__(self)

    def __bool__(self):
        return _classes.DriverMap___bool__(self)

    def __len__(self):
        return _classes.DriverMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _classes.DriverMap___getitem__(self, key)

    def __delitem__(self, key):
        return _classes.DriverMap___delitem__(self, key)

    def has_key(self, key):
        return _classes.DriverMap_has_key(self, key)

    def keys(self):
        return _classes.DriverMap_keys(self)

    def values(self):
        return _classes.DriverMap_values(self)

    def items(self):
        return _classes.DriverMap_items(self)

    def __contains__(self, key):
        return _classes.DriverMap___contains__(self, key)

    def key_iterator(self):
        return _classes.DriverMap_key_iterator(self)

    def value_iterator(self):
        return _classes.DriverMap_value_iterator(self)

    def __setitem__(self, *args):
        return _classes.DriverMap___setitem__(self, *args)

    def asdict(self):
        return _classes.DriverMap_asdict(self)

    def __init__(self, *args):
        this = _classes.new_DriverMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _classes.DriverMap_empty(self)

    def size(self):
        return _classes.DriverMap_size(self)

    def swap(self, v):
        return _classes.DriverMap_swap(self, v)

    def begin(self):
        return _classes.DriverMap_begin(self)

    def end(self):
        return _classes.DriverMap_end(self)

    def rbegin(self):
        return _classes.DriverMap_rbegin(self)

    def rend(self):
        return _classes.DriverMap_rend(self)

    def clear(self):
        return _classes.DriverMap_clear(self)

    def get_allocator(self):
        return _classes.DriverMap_get_allocator(self)

    def count(self, x):
        return _classes.DriverMap_count(self, x)

    def erase(self, *args):
        return _classes.DriverMap_erase(self, *args)

    def find(self, x):
        return _classes.DriverMap_find(self, x)

    def lower_bound(self, x):
        return _classes.DriverMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _classes.DriverMap_upper_bound(self, x)
    __swig_destroy__ = _classes.delete_DriverMap
    __del__ = lambda self: None
DriverMap_swigregister = _classes.DriverMap_swigregister
DriverMap_swigregister(DriverMap)

class InputFormatMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InputFormatMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InputFormatMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.InputFormatMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.InputFormatMap___nonzero__(self)

    def __bool__(self):
        return _classes.InputFormatMap___bool__(self)

    def __len__(self):
        return _classes.InputFormatMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _classes.InputFormatMap___getitem__(self, key)

    def __delitem__(self, key):
        return _classes.InputFormatMap___delitem__(self, key)

    def has_key(self, key):
        return _classes.InputFormatMap_has_key(self, key)

    def keys(self):
        return _classes.InputFormatMap_keys(self)

    def values(self):
        return _classes.InputFormatMap_values(self)

    def items(self):
        return _classes.InputFormatMap_items(self)

    def __contains__(self, key):
        return _classes.InputFormatMap___contains__(self, key)

    def key_iterator(self):
        return _classes.InputFormatMap_key_iterator(self)

    def value_iterator(self):
        return _classes.InputFormatMap_value_iterator(self)

    def __setitem__(self, *args):
        return _classes.InputFormatMap___setitem__(self, *args)

    def asdict(self):
        return _classes.InputFormatMap_asdict(self)

    def __init__(self, *args):
        this = _classes.new_InputFormatMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _classes.InputFormatMap_empty(self)

    def size(self):
        return _classes.InputFormatMap_size(self)

    def swap(self, v):
        return _classes.InputFormatMap_swap(self, v)

    def begin(self):
        return _classes.InputFormatMap_begin(self)

    def end(self):
        return _classes.InputFormatMap_end(self)

    def rbegin(self):
        return _classes.InputFormatMap_rbegin(self)

    def rend(self):
        return _classes.InputFormatMap_rend(self)

    def clear(self):
        return _classes.InputFormatMap_clear(self)

    def get_allocator(self):
        return _classes.InputFormatMap_get_allocator(self)

    def count(self, x):
        return _classes.InputFormatMap_count(self, x)

    def erase(self, *args):
        return _classes.InputFormatMap_erase(self, *args)

    def find(self, x):
        return _classes.InputFormatMap_find(self, x)

    def lower_bound(self, x):
        return _classes.InputFormatMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _classes.InputFormatMap_upper_bound(self, x)
    __swig_destroy__ = _classes.delete_InputFormatMap
    __del__ = lambda self: None
InputFormatMap_swigregister = _classes.InputFormatMap_swigregister
InputFormatMap_swigregister(InputFormatMap)

class OutputFormatMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutputFormatMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OutputFormatMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.OutputFormatMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.OutputFormatMap___nonzero__(self)

    def __bool__(self):
        return _classes.OutputFormatMap___bool__(self)

    def __len__(self):
        return _classes.OutputFormatMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _classes.OutputFormatMap___getitem__(self, key)

    def __delitem__(self, key):
        return _classes.OutputFormatMap___delitem__(self, key)

    def has_key(self, key):
        return _classes.OutputFormatMap_has_key(self, key)

    def keys(self):
        return _classes.OutputFormatMap_keys(self)

    def values(self):
        return _classes.OutputFormatMap_values(self)

    def items(self):
        return _classes.OutputFormatMap_items(self)

    def __contains__(self, key):
        return _classes.OutputFormatMap___contains__(self, key)

    def key_iterator(self):
        return _classes.OutputFormatMap_key_iterator(self)

    def value_iterator(self):
        return _classes.OutputFormatMap_value_iterator(self)

    def __setitem__(self, *args):
        return _classes.OutputFormatMap___setitem__(self, *args)

    def asdict(self):
        return _classes.OutputFormatMap_asdict(self)

    def __init__(self, *args):
        this = _classes.new_OutputFormatMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _classes.OutputFormatMap_empty(self)

    def size(self):
        return _classes.OutputFormatMap_size(self)

    def swap(self, v):
        return _classes.OutputFormatMap_swap(self, v)

    def begin(self):
        return _classes.OutputFormatMap_begin(self)

    def end(self):
        return _classes.OutputFormatMap_end(self)

    def rbegin(self):
        return _classes.OutputFormatMap_rbegin(self)

    def rend(self):
        return _classes.OutputFormatMap_rend(self)

    def clear(self):
        return _classes.OutputFormatMap_clear(self)

    def get_allocator(self):
        return _classes.OutputFormatMap_get_allocator(self)

    def count(self, x):
        return _classes.OutputFormatMap_count(self, x)

    def erase(self, *args):
        return _classes.OutputFormatMap_erase(self, *args)

    def find(self, x):
        return _classes.OutputFormatMap_find(self, x)

    def lower_bound(self, x):
        return _classes.OutputFormatMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _classes.OutputFormatMap_upper_bound(self, x)
    __swig_destroy__ = _classes.delete_OutputFormatMap
    __del__ = lambda self: None
OutputFormatMap_swigregister = _classes.OutputFormatMap_swigregister
OutputFormatMap_swigregister(OutputFormatMap)

class HardwareDeviceVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HardwareDeviceVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HardwareDeviceVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.HardwareDeviceVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.HardwareDeviceVector___nonzero__(self)

    def __bool__(self):
        return _classes.HardwareDeviceVector___bool__(self)

    def __len__(self):
        return _classes.HardwareDeviceVector___len__(self)

    def __getslice__(self, i, j):
        return _classes.HardwareDeviceVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _classes.HardwareDeviceVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _classes.HardwareDeviceVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _classes.HardwareDeviceVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _classes.HardwareDeviceVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _classes.HardwareDeviceVector___setitem__(self, *args)

    def pop(self):
        return _classes.HardwareDeviceVector_pop(self)

    def append(self, x):
        return _classes.HardwareDeviceVector_append(self, x)

    def empty(self):
        return _classes.HardwareDeviceVector_empty(self)

    def size(self):
        return _classes.HardwareDeviceVector_size(self)

    def swap(self, v):
        return _classes.HardwareDeviceVector_swap(self, v)

    def begin(self):
        return _classes.HardwareDeviceVector_begin(self)

    def end(self):
        return _classes.HardwareDeviceVector_end(self)

    def rbegin(self):
        return _classes.HardwareDeviceVector_rbegin(self)

    def rend(self):
        return _classes.HardwareDeviceVector_rend(self)

    def clear(self):
        return _classes.HardwareDeviceVector_clear(self)

    def get_allocator(self):
        return _classes.HardwareDeviceVector_get_allocator(self)

    def pop_back(self):
        return _classes.HardwareDeviceVector_pop_back(self)

    def erase(self, *args):
        return _classes.HardwareDeviceVector_erase(self, *args)

    def __init__(self, *args):
        this = _classes.new_HardwareDeviceVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _classes.HardwareDeviceVector_push_back(self, x)

    def front(self):
        return _classes.HardwareDeviceVector_front(self)

    def back(self):
        return _classes.HardwareDeviceVector_back(self)

    def assign(self, n, x):
        return _classes.HardwareDeviceVector_assign(self, n, x)

    def resize(self, *args):
        return _classes.HardwareDeviceVector_resize(self, *args)

    def insert(self, *args):
        return _classes.HardwareDeviceVector_insert(self, *args)

    def reserve(self, n):
        return _classes.HardwareDeviceVector_reserve(self, n)

    def capacity(self):
        return _classes.HardwareDeviceVector_capacity(self)
    __swig_destroy__ = _classes.delete_HardwareDeviceVector
    __del__ = lambda self: None
HardwareDeviceVector_swigregister = _classes.HardwareDeviceVector_swigregister
HardwareDeviceVector_swigregister(HardwareDeviceVector)

class DeviceVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DeviceVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DeviceVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.DeviceVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.DeviceVector___nonzero__(self)

    def __bool__(self):
        return _classes.DeviceVector___bool__(self)

    def __len__(self):
        return _classes.DeviceVector___len__(self)

    def __getslice__(self, i, j):
        return _classes.DeviceVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _classes.DeviceVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _classes.DeviceVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _classes.DeviceVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _classes.DeviceVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _classes.DeviceVector___setitem__(self, *args)

    def pop(self):
        return _classes.DeviceVector_pop(self)

    def append(self, x):
        return _classes.DeviceVector_append(self, x)

    def empty(self):
        return _classes.DeviceVector_empty(self)

    def size(self):
        return _classes.DeviceVector_size(self)

    def swap(self, v):
        return _classes.DeviceVector_swap(self, v)

    def begin(self):
        return _classes.DeviceVector_begin(self)

    def end(self):
        return _classes.DeviceVector_end(self)

    def rbegin(self):
        return _classes.DeviceVector_rbegin(self)

    def rend(self):
        return _classes.DeviceVector_rend(self)

    def clear(self):
        return _classes.DeviceVector_clear(self)

    def get_allocator(self):
        return _classes.DeviceVector_get_allocator(self)

    def pop_back(self):
        return _classes.DeviceVector_pop_back(self)

    def erase(self, *args):
        return _classes.DeviceVector_erase(self, *args)

    def __init__(self, *args):
        this = _classes.new_DeviceVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _classes.DeviceVector_push_back(self, x)

    def front(self):
        return _classes.DeviceVector_front(self)

    def back(self):
        return _classes.DeviceVector_back(self)

    def assign(self, n, x):
        return _classes.DeviceVector_assign(self, n, x)

    def resize(self, *args):
        return _classes.DeviceVector_resize(self, *args)

    def insert(self, *args):
        return _classes.DeviceVector_insert(self, *args)

    def reserve(self, n):
        return _classes.DeviceVector_reserve(self, n)

    def capacity(self):
        return _classes.DeviceVector_capacity(self)
    __swig_destroy__ = _classes.delete_DeviceVector
    __del__ = lambda self: None
DeviceVector_swigregister = _classes.DeviceVector_swigregister
DeviceVector_swigregister(DeviceVector)

class ChannelVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChannelVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChannelVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.ChannelVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.ChannelVector___nonzero__(self)

    def __bool__(self):
        return _classes.ChannelVector___bool__(self)

    def __len__(self):
        return _classes.ChannelVector___len__(self)

    def __getslice__(self, i, j):
        return _classes.ChannelVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _classes.ChannelVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _classes.ChannelVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _classes.ChannelVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _classes.ChannelVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _classes.ChannelVector___setitem__(self, *args)

    def pop(self):
        return _classes.ChannelVector_pop(self)

    def append(self, x):
        return _classes.ChannelVector_append(self, x)

    def empty(self):
        return _classes.ChannelVector_empty(self)

    def size(self):
        return _classes.ChannelVector_size(self)

    def swap(self, v):
        return _classes.ChannelVector_swap(self, v)

    def begin(self):
        return _classes.ChannelVector_begin(self)

    def end(self):
        return _classes.ChannelVector_end(self)

    def rbegin(self):
        return _classes.ChannelVector_rbegin(self)

    def rend(self):
        return _classes.ChannelVector_rend(self)

    def clear(self):
        return _classes.ChannelVector_clear(self)

    def get_allocator(self):
        return _classes.ChannelVector_get_allocator(self)

    def pop_back(self):
        return _classes.ChannelVector_pop_back(self)

    def erase(self, *args):
        return _classes.ChannelVector_erase(self, *args)

    def __init__(self, *args):
        this = _classes.new_ChannelVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _classes.ChannelVector_push_back(self, x)

    def front(self):
        return _classes.ChannelVector_front(self)

    def back(self):
        return _classes.ChannelVector_back(self)

    def assign(self, n, x):
        return _classes.ChannelVector_assign(self, n, x)

    def resize(self, *args):
        return _classes.ChannelVector_resize(self, *args)

    def insert(self, *args):
        return _classes.ChannelVector_insert(self, *args)

    def reserve(self, n):
        return _classes.ChannelVector_reserve(self, n)

    def capacity(self):
        return _classes.ChannelVector_capacity(self)
    __swig_destroy__ = _classes.delete_ChannelVector
    __del__ = lambda self: None
ChannelVector_swigregister = _classes.ChannelVector_swigregister
ChannelVector_swigregister(ChannelVector)

class ChannelGroupMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChannelGroupMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChannelGroupMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.ChannelGroupMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.ChannelGroupMap___nonzero__(self)

    def __bool__(self):
        return _classes.ChannelGroupMap___bool__(self)

    def __len__(self):
        return _classes.ChannelGroupMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _classes.ChannelGroupMap___getitem__(self, key)

    def __delitem__(self, key):
        return _classes.ChannelGroupMap___delitem__(self, key)

    def has_key(self, key):
        return _classes.ChannelGroupMap_has_key(self, key)

    def keys(self):
        return _classes.ChannelGroupMap_keys(self)

    def values(self):
        return _classes.ChannelGroupMap_values(self)

    def items(self):
        return _classes.ChannelGroupMap_items(self)

    def __contains__(self, key):
        return _classes.ChannelGroupMap___contains__(self, key)

    def key_iterator(self):
        return _classes.ChannelGroupMap_key_iterator(self)

    def value_iterator(self):
        return _classes.ChannelGroupMap_value_iterator(self)

    def __setitem__(self, *args):
        return _classes.ChannelGroupMap___setitem__(self, *args)

    def asdict(self):
        return _classes.ChannelGroupMap_asdict(self)

    def __init__(self, *args):
        this = _classes.new_ChannelGroupMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _classes.ChannelGroupMap_empty(self)

    def size(self):
        return _classes.ChannelGroupMap_size(self)

    def swap(self, v):
        return _classes.ChannelGroupMap_swap(self, v)

    def begin(self):
        return _classes.ChannelGroupMap_begin(self)

    def end(self):
        return _classes.ChannelGroupMap_end(self)

    def rbegin(self):
        return _classes.ChannelGroupMap_rbegin(self)

    def rend(self):
        return _classes.ChannelGroupMap_rend(self)

    def clear(self):
        return _classes.ChannelGroupMap_clear(self)

    def get_allocator(self):
        return _classes.ChannelGroupMap_get_allocator(self)

    def count(self, x):
        return _classes.ChannelGroupMap_count(self, x)

    def erase(self, *args):
        return _classes.ChannelGroupMap_erase(self, *args)

    def find(self, x):
        return _classes.ChannelGroupMap_find(self, x)

    def lower_bound(self, x):
        return _classes.ChannelGroupMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _classes.ChannelGroupMap_upper_bound(self, x)
    __swig_destroy__ = _classes.delete_ChannelGroupMap
    __del__ = lambda self: None
ChannelGroupMap_swigregister = _classes.ChannelGroupMap_swigregister
ChannelGroupMap_swigregister(ChannelGroupMap)

class ConfigVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfigVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConfigVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.ConfigVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.ConfigVector___nonzero__(self)

    def __bool__(self):
        return _classes.ConfigVector___bool__(self)

    def __len__(self):
        return _classes.ConfigVector___len__(self)

    def __getslice__(self, i, j):
        return _classes.ConfigVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _classes.ConfigVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _classes.ConfigVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _classes.ConfigVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _classes.ConfigVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _classes.ConfigVector___setitem__(self, *args)

    def pop(self):
        return _classes.ConfigVector_pop(self)

    def append(self, x):
        return _classes.ConfigVector_append(self, x)

    def empty(self):
        return _classes.ConfigVector_empty(self)

    def size(self):
        return _classes.ConfigVector_size(self)

    def swap(self, v):
        return _classes.ConfigVector_swap(self, v)

    def begin(self):
        return _classes.ConfigVector_begin(self)

    def end(self):
        return _classes.ConfigVector_end(self)

    def rbegin(self):
        return _classes.ConfigVector_rbegin(self)

    def rend(self):
        return _classes.ConfigVector_rend(self)

    def clear(self):
        return _classes.ConfigVector_clear(self)

    def get_allocator(self):
        return _classes.ConfigVector_get_allocator(self)

    def pop_back(self):
        return _classes.ConfigVector_pop_back(self)

    def erase(self, *args):
        return _classes.ConfigVector_erase(self, *args)

    def __init__(self, *args):
        this = _classes.new_ConfigVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _classes.ConfigVector_push_back(self, x)

    def front(self):
        return _classes.ConfigVector_front(self)

    def back(self):
        return _classes.ConfigVector_back(self)

    def assign(self, n, x):
        return _classes.ConfigVector_assign(self, n, x)

    def resize(self, *args):
        return _classes.ConfigVector_resize(self, *args)

    def insert(self, *args):
        return _classes.ConfigVector_insert(self, *args)

    def reserve(self, n):
        return _classes.ConfigVector_reserve(self, n)

    def capacity(self):
        return _classes.ConfigVector_capacity(self)
    __swig_destroy__ = _classes.delete_ConfigVector
    __del__ = lambda self: None
ConfigVector_swigregister = _classes.ConfigVector_swigregister
ConfigVector_swigregister(ConfigVector)

class ConfigMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfigMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConfigMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.ConfigMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.ConfigMap___nonzero__(self)

    def __bool__(self):
        return _classes.ConfigMap___bool__(self)

    def __len__(self):
        return _classes.ConfigMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _classes.ConfigMap___getitem__(self, key)

    def __delitem__(self, key):
        return _classes.ConfigMap___delitem__(self, key)

    def has_key(self, key):
        return _classes.ConfigMap_has_key(self, key)

    def keys(self):
        return _classes.ConfigMap_keys(self)

    def values(self):
        return _classes.ConfigMap_values(self)

    def items(self):
        return _classes.ConfigMap_items(self)

    def __contains__(self, key):
        return _classes.ConfigMap___contains__(self, key)

    def key_iterator(self):
        return _classes.ConfigMap_key_iterator(self)

    def value_iterator(self):
        return _classes.ConfigMap_value_iterator(self)

    def __setitem__(self, *args):
        return _classes.ConfigMap___setitem__(self, *args)

    def asdict(self):
        return _classes.ConfigMap_asdict(self)

    def __init__(self, *args):
        this = _classes.new_ConfigMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _classes.ConfigMap_empty(self)

    def size(self):
        return _classes.ConfigMap_size(self)

    def swap(self, v):
        return _classes.ConfigMap_swap(self, v)

    def begin(self):
        return _classes.ConfigMap_begin(self)

    def end(self):
        return _classes.ConfigMap_end(self)

    def rbegin(self):
        return _classes.ConfigMap_rbegin(self)

    def rend(self):
        return _classes.ConfigMap_rend(self)

    def clear(self):
        return _classes.ConfigMap_clear(self)

    def get_allocator(self):
        return _classes.ConfigMap_get_allocator(self)

    def count(self, x):
        return _classes.ConfigMap_count(self, x)

    def erase(self, *args):
        return _classes.ConfigMap_erase(self, *args)

    def find(self, x):
        return _classes.ConfigMap_find(self, x)

    def lower_bound(self, x):
        return _classes.ConfigMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _classes.ConfigMap_upper_bound(self, x)
    __swig_destroy__ = _classes.delete_ConfigMap
    __del__ = lambda self: None
ConfigMap_swigregister = _classes.ConfigMap_swigregister
ConfigMap_swigregister(ConfigMap)

class ConfigSet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfigSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConfigSet, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.ConfigSet_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.ConfigSet___nonzero__(self)

    def __bool__(self):
        return _classes.ConfigSet___bool__(self)

    def __len__(self):
        return _classes.ConfigSet___len__(self)

    def append(self, x):
        return _classes.ConfigSet_append(self, x)

    def __contains__(self, x):
        return _classes.ConfigSet___contains__(self, x)

    def __getitem__(self, i):
        return _classes.ConfigSet___getitem__(self, i)

    def add(self, x):
        return _classes.ConfigSet_add(self, x)

    def discard(self, x):
        return _classes.ConfigSet_discard(self, x)

    def __init__(self, *args):
        this = _classes.new_ConfigSet(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _classes.ConfigSet_empty(self)

    def size(self):
        return _classes.ConfigSet_size(self)

    def clear(self):
        return _classes.ConfigSet_clear(self)

    def swap(self, v):
        return _classes.ConfigSet_swap(self, v)

    def count(self, x):
        return _classes.ConfigSet_count(self, x)

    def begin(self):
        return _classes.ConfigSet_begin(self)

    def end(self):
        return _classes.ConfigSet_end(self)

    def rbegin(self):
        return _classes.ConfigSet_rbegin(self)

    def rend(self):
        return _classes.ConfigSet_rend(self)

    def erase(self, *args):
        return _classes.ConfigSet_erase(self, *args)

    def find(self, x):
        return _classes.ConfigSet_find(self, x)

    def lower_bound(self, x):
        return _classes.ConfigSet_lower_bound(self, x)

    def upper_bound(self, x):
        return _classes.ConfigSet_upper_bound(self, x)

    def equal_range(self, x):
        return _classes.ConfigSet_equal_range(self, x)

    def insert(self, __x):
        return _classes.ConfigSet_insert(self, __x)
    __swig_destroy__ = _classes.delete_ConfigSet
    __del__ = lambda self: None
ConfigSet_swigregister = _classes.ConfigSet_swigregister
ConfigSet_swigregister(ConfigSet)

class CapabilityVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CapabilityVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CapabilityVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.CapabilityVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.CapabilityVector___nonzero__(self)

    def __bool__(self):
        return _classes.CapabilityVector___bool__(self)

    def __len__(self):
        return _classes.CapabilityVector___len__(self)

    def __getslice__(self, i, j):
        return _classes.CapabilityVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _classes.CapabilityVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _classes.CapabilityVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _classes.CapabilityVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _classes.CapabilityVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _classes.CapabilityVector___setitem__(self, *args)

    def pop(self):
        return _classes.CapabilityVector_pop(self)

    def append(self, x):
        return _classes.CapabilityVector_append(self, x)

    def empty(self):
        return _classes.CapabilityVector_empty(self)

    def size(self):
        return _classes.CapabilityVector_size(self)

    def swap(self, v):
        return _classes.CapabilityVector_swap(self, v)

    def begin(self):
        return _classes.CapabilityVector_begin(self)

    def end(self):
        return _classes.CapabilityVector_end(self)

    def rbegin(self):
        return _classes.CapabilityVector_rbegin(self)

    def rend(self):
        return _classes.CapabilityVector_rend(self)

    def clear(self):
        return _classes.CapabilityVector_clear(self)

    def get_allocator(self):
        return _classes.CapabilityVector_get_allocator(self)

    def pop_back(self):
        return _classes.CapabilityVector_pop_back(self)

    def erase(self, *args):
        return _classes.CapabilityVector_erase(self, *args)

    def __init__(self, *args):
        this = _classes.new_CapabilityVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _classes.CapabilityVector_push_back(self, x)

    def front(self):
        return _classes.CapabilityVector_front(self)

    def back(self):
        return _classes.CapabilityVector_back(self)

    def assign(self, n, x):
        return _classes.CapabilityVector_assign(self, n, x)

    def resize(self, *args):
        return _classes.CapabilityVector_resize(self, *args)

    def insert(self, *args):
        return _classes.CapabilityVector_insert(self, *args)

    def reserve(self, n):
        return _classes.CapabilityVector_reserve(self, n)

    def capacity(self):
        return _classes.CapabilityVector_capacity(self)
    __swig_destroy__ = _classes.delete_CapabilityVector
    __del__ = lambda self: None
CapabilityVector_swigregister = _classes.CapabilityVector_swigregister
CapabilityVector_swigregister(CapabilityVector)

class CapabilitySet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CapabilitySet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CapabilitySet, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.CapabilitySet_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.CapabilitySet___nonzero__(self)

    def __bool__(self):
        return _classes.CapabilitySet___bool__(self)

    def __len__(self):
        return _classes.CapabilitySet___len__(self)

    def append(self, x):
        return _classes.CapabilitySet_append(self, x)

    def __contains__(self, x):
        return _classes.CapabilitySet___contains__(self, x)

    def __getitem__(self, i):
        return _classes.CapabilitySet___getitem__(self, i)

    def add(self, x):
        return _classes.CapabilitySet_add(self, x)

    def discard(self, x):
        return _classes.CapabilitySet_discard(self, x)

    def __init__(self, *args):
        this = _classes.new_CapabilitySet(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _classes.CapabilitySet_empty(self)

    def size(self):
        return _classes.CapabilitySet_size(self)

    def clear(self):
        return _classes.CapabilitySet_clear(self)

    def swap(self, v):
        return _classes.CapabilitySet_swap(self, v)

    def count(self, x):
        return _classes.CapabilitySet_count(self, x)

    def begin(self):
        return _classes.CapabilitySet_begin(self)

    def end(self):
        return _classes.CapabilitySet_end(self)

    def rbegin(self):
        return _classes.CapabilitySet_rbegin(self)

    def rend(self):
        return _classes.CapabilitySet_rend(self)

    def erase(self, *args):
        return _classes.CapabilitySet_erase(self, *args)

    def find(self, x):
        return _classes.CapabilitySet_find(self, x)

    def lower_bound(self, x):
        return _classes.CapabilitySet_lower_bound(self, x)

    def upper_bound(self, x):
        return _classes.CapabilitySet_upper_bound(self, x)

    def equal_range(self, x):
        return _classes.CapabilitySet_equal_range(self, x)

    def insert(self, __x):
        return _classes.CapabilitySet_insert(self, __x)
    __swig_destroy__ = _classes.delete_CapabilitySet
    __del__ = lambda self: None
CapabilitySet_swigregister = _classes.CapabilitySet_swigregister
CapabilitySet_swigregister(CapabilitySet)

class OptionVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OptionVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OptionVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.OptionVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.OptionVector___nonzero__(self)

    def __bool__(self):
        return _classes.OptionVector___bool__(self)

    def __len__(self):
        return _classes.OptionVector___len__(self)

    def __getslice__(self, i, j):
        return _classes.OptionVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _classes.OptionVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _classes.OptionVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _classes.OptionVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _classes.OptionVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _classes.OptionVector___setitem__(self, *args)

    def pop(self):
        return _classes.OptionVector_pop(self)

    def append(self, x):
        return _classes.OptionVector_append(self, x)

    def empty(self):
        return _classes.OptionVector_empty(self)

    def size(self):
        return _classes.OptionVector_size(self)

    def swap(self, v):
        return _classes.OptionVector_swap(self, v)

    def begin(self):
        return _classes.OptionVector_begin(self)

    def end(self):
        return _classes.OptionVector_end(self)

    def rbegin(self):
        return _classes.OptionVector_rbegin(self)

    def rend(self):
        return _classes.OptionVector_rend(self)

    def clear(self):
        return _classes.OptionVector_clear(self)

    def get_allocator(self):
        return _classes.OptionVector_get_allocator(self)

    def pop_back(self):
        return _classes.OptionVector_pop_back(self)

    def erase(self, *args):
        return _classes.OptionVector_erase(self, *args)

    def __init__(self, *args):
        this = _classes.new_OptionVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _classes.OptionVector_push_back(self, x)

    def front(self):
        return _classes.OptionVector_front(self)

    def back(self):
        return _classes.OptionVector_back(self)

    def assign(self, n, x):
        return _classes.OptionVector_assign(self, n, x)

    def resize(self, *args):
        return _classes.OptionVector_resize(self, *args)

    def insert(self, *args):
        return _classes.OptionVector_insert(self, *args)

    def reserve(self, n):
        return _classes.OptionVector_reserve(self, n)

    def capacity(self):
        return _classes.OptionVector_capacity(self)
    __swig_destroy__ = _classes.delete_OptionVector
    __del__ = lambda self: None
OptionVector_swigregister = _classes.OptionVector_swigregister
OptionVector_swigregister(OptionVector)

class OptionMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OptionMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OptionMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.OptionMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.OptionMap___nonzero__(self)

    def __bool__(self):
        return _classes.OptionMap___bool__(self)

    def __len__(self):
        return _classes.OptionMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _classes.OptionMap___getitem__(self, key)

    def __delitem__(self, key):
        return _classes.OptionMap___delitem__(self, key)

    def has_key(self, key):
        return _classes.OptionMap_has_key(self, key)

    def keys(self):
        return _classes.OptionMap_keys(self)

    def values(self):
        return _classes.OptionMap_values(self)

    def items(self):
        return _classes.OptionMap_items(self)

    def __contains__(self, key):
        return _classes.OptionMap___contains__(self, key)

    def key_iterator(self):
        return _classes.OptionMap_key_iterator(self)

    def value_iterator(self):
        return _classes.OptionMap_value_iterator(self)

    def __setitem__(self, *args):
        return _classes.OptionMap___setitem__(self, *args)

    def asdict(self):
        return _classes.OptionMap_asdict(self)

    def __init__(self, *args):
        this = _classes.new_OptionMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _classes.OptionMap_empty(self)

    def size(self):
        return _classes.OptionMap_size(self)

    def swap(self, v):
        return _classes.OptionMap_swap(self, v)

    def begin(self):
        return _classes.OptionMap_begin(self)

    def end(self):
        return _classes.OptionMap_end(self)

    def rbegin(self):
        return _classes.OptionMap_rbegin(self)

    def rend(self):
        return _classes.OptionMap_rend(self)

    def clear(self):
        return _classes.OptionMap_clear(self)

    def get_allocator(self):
        return _classes.OptionMap_get_allocator(self)

    def count(self, x):
        return _classes.OptionMap_count(self, x)

    def erase(self, *args):
        return _classes.OptionMap_erase(self, *args)

    def find(self, x):
        return _classes.OptionMap_find(self, x)

    def lower_bound(self, x):
        return _classes.OptionMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _classes.OptionMap_upper_bound(self, x)
    __swig_destroy__ = _classes.delete_OptionMap
    __del__ = lambda self: None
OptionMap_swigregister = _classes.OptionMap_swigregister
OptionMap_swigregister(OptionMap)

class VariantVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VariantVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VariantVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.VariantVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.VariantVector___nonzero__(self)

    def __bool__(self):
        return _classes.VariantVector___bool__(self)

    def __len__(self):
        return _classes.VariantVector___len__(self)

    def __getslice__(self, i, j):
        return _classes.VariantVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _classes.VariantVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _classes.VariantVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _classes.VariantVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _classes.VariantVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _classes.VariantVector___setitem__(self, *args)

    def pop(self):
        return _classes.VariantVector_pop(self)

    def append(self, x):
        return _classes.VariantVector_append(self, x)

    def empty(self):
        return _classes.VariantVector_empty(self)

    def size(self):
        return _classes.VariantVector_size(self)

    def swap(self, v):
        return _classes.VariantVector_swap(self, v)

    def begin(self):
        return _classes.VariantVector_begin(self)

    def end(self):
        return _classes.VariantVector_end(self)

    def rbegin(self):
        return _classes.VariantVector_rbegin(self)

    def rend(self):
        return _classes.VariantVector_rend(self)

    def clear(self):
        return _classes.VariantVector_clear(self)

    def get_allocator(self):
        return _classes.VariantVector_get_allocator(self)

    def pop_back(self):
        return _classes.VariantVector_pop_back(self)

    def erase(self, *args):
        return _classes.VariantVector_erase(self, *args)

    def __init__(self, *args):
        this = _classes.new_VariantVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _classes.VariantVector_push_back(self, x)

    def front(self):
        return _classes.VariantVector_front(self)

    def back(self):
        return _classes.VariantVector_back(self)

    def assign(self, n, x):
        return _classes.VariantVector_assign(self, n, x)

    def resize(self, *args):
        return _classes.VariantVector_resize(self, *args)

    def insert(self, *args):
        return _classes.VariantVector_insert(self, *args)

    def reserve(self, n):
        return _classes.VariantVector_reserve(self, n)

    def capacity(self):
        return _classes.VariantVector_capacity(self)
    __swig_destroy__ = _classes.delete_VariantVector
    __del__ = lambda self: None
VariantVector_swigregister = _classes.VariantVector_swigregister
VariantVector_swigregister(VariantVector)

class VariantMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VariantMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VariantMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.VariantMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.VariantMap___nonzero__(self)

    def __bool__(self):
        return _classes.VariantMap___bool__(self)

    def __len__(self):
        return _classes.VariantMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _classes.VariantMap___getitem__(self, key)

    def __delitem__(self, key):
        return _classes.VariantMap___delitem__(self, key)

    def has_key(self, key):
        return _classes.VariantMap_has_key(self, key)

    def keys(self):
        return _classes.VariantMap_keys(self)

    def values(self):
        return _classes.VariantMap_values(self)

    def items(self):
        return _classes.VariantMap_items(self)

    def __contains__(self, key):
        return _classes.VariantMap___contains__(self, key)

    def key_iterator(self):
        return _classes.VariantMap_key_iterator(self)

    def value_iterator(self):
        return _classes.VariantMap_value_iterator(self)

    def __setitem__(self, *args):
        return _classes.VariantMap___setitem__(self, *args)

    def asdict(self):
        return _classes.VariantMap_asdict(self)

    def __init__(self, *args):
        this = _classes.new_VariantMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        return _classes.VariantMap_empty(self)

    def size(self):
        return _classes.VariantMap_size(self)

    def swap(self, v):
        return _classes.VariantMap_swap(self, v)

    def begin(self):
        return _classes.VariantMap_begin(self)

    def end(self):
        return _classes.VariantMap_end(self)

    def rbegin(self):
        return _classes.VariantMap_rbegin(self)

    def rend(self):
        return _classes.VariantMap_rend(self)

    def clear(self):
        return _classes.VariantMap_clear(self)

    def get_allocator(self):
        return _classes.VariantMap_get_allocator(self)

    def count(self, x):
        return _classes.VariantMap_count(self, x)

    def erase(self, *args):
        return _classes.VariantMap_erase(self, *args)

    def find(self, x):
        return _classes.VariantMap_find(self, x)

    def lower_bound(self, x):
        return _classes.VariantMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _classes.VariantMap_upper_bound(self, x)
    __swig_destroy__ = _classes.delete_VariantMap
    __del__ = lambda self: None
VariantMap_swigregister = _classes.VariantMap_swigregister
VariantMap_swigregister(VariantMap)

class QuantityFlagVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuantityFlagVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, QuantityFlagVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.QuantityFlagVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.QuantityFlagVector___nonzero__(self)

    def __bool__(self):
        return _classes.QuantityFlagVector___bool__(self)

    def __len__(self):
        return _classes.QuantityFlagVector___len__(self)

    def __getslice__(self, i, j):
        return _classes.QuantityFlagVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _classes.QuantityFlagVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _classes.QuantityFlagVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _classes.QuantityFlagVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _classes.QuantityFlagVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _classes.QuantityFlagVector___setitem__(self, *args)

    def pop(self):
        return _classes.QuantityFlagVector_pop(self)

    def append(self, x):
        return _classes.QuantityFlagVector_append(self, x)

    def empty(self):
        return _classes.QuantityFlagVector_empty(self)

    def size(self):
        return _classes.QuantityFlagVector_size(self)

    def swap(self, v):
        return _classes.QuantityFlagVector_swap(self, v)

    def begin(self):
        return _classes.QuantityFlagVector_begin(self)

    def end(self):
        return _classes.QuantityFlagVector_end(self)

    def rbegin(self):
        return _classes.QuantityFlagVector_rbegin(self)

    def rend(self):
        return _classes.QuantityFlagVector_rend(self)

    def clear(self):
        return _classes.QuantityFlagVector_clear(self)

    def get_allocator(self):
        return _classes.QuantityFlagVector_get_allocator(self)

    def pop_back(self):
        return _classes.QuantityFlagVector_pop_back(self)

    def erase(self, *args):
        return _classes.QuantityFlagVector_erase(self, *args)

    def __init__(self, *args):
        this = _classes.new_QuantityFlagVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _classes.QuantityFlagVector_push_back(self, x)

    def front(self):
        return _classes.QuantityFlagVector_front(self)

    def back(self):
        return _classes.QuantityFlagVector_back(self)

    def assign(self, n, x):
        return _classes.QuantityFlagVector_assign(self, n, x)

    def resize(self, *args):
        return _classes.QuantityFlagVector_resize(self, *args)

    def insert(self, *args):
        return _classes.QuantityFlagVector_insert(self, *args)

    def reserve(self, n):
        return _classes.QuantityFlagVector_reserve(self, n)

    def capacity(self):
        return _classes.QuantityFlagVector_capacity(self)
    __swig_destroy__ = _classes.delete_QuantityFlagVector
    __del__ = lambda self: None
QuantityFlagVector_swigregister = _classes.QuantityFlagVector_swigregister
QuantityFlagVector_swigregister(QuantityFlagVector)

class TriggerStageVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TriggerStageVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TriggerStageVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.TriggerStageVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.TriggerStageVector___nonzero__(self)

    def __bool__(self):
        return _classes.TriggerStageVector___bool__(self)

    def __len__(self):
        return _classes.TriggerStageVector___len__(self)

    def __getslice__(self, i, j):
        return _classes.TriggerStageVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _classes.TriggerStageVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _classes.TriggerStageVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _classes.TriggerStageVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _classes.TriggerStageVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _classes.TriggerStageVector___setitem__(self, *args)

    def pop(self):
        return _classes.TriggerStageVector_pop(self)

    def append(self, x):
        return _classes.TriggerStageVector_append(self, x)

    def empty(self):
        return _classes.TriggerStageVector_empty(self)

    def size(self):
        return _classes.TriggerStageVector_size(self)

    def swap(self, v):
        return _classes.TriggerStageVector_swap(self, v)

    def begin(self):
        return _classes.TriggerStageVector_begin(self)

    def end(self):
        return _classes.TriggerStageVector_end(self)

    def rbegin(self):
        return _classes.TriggerStageVector_rbegin(self)

    def rend(self):
        return _classes.TriggerStageVector_rend(self)

    def clear(self):
        return _classes.TriggerStageVector_clear(self)

    def get_allocator(self):
        return _classes.TriggerStageVector_get_allocator(self)

    def pop_back(self):
        return _classes.TriggerStageVector_pop_back(self)

    def erase(self, *args):
        return _classes.TriggerStageVector_erase(self, *args)

    def __init__(self, *args):
        this = _classes.new_TriggerStageVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _classes.TriggerStageVector_push_back(self, x)

    def front(self):
        return _classes.TriggerStageVector_front(self)

    def back(self):
        return _classes.TriggerStageVector_back(self)

    def assign(self, n, x):
        return _classes.TriggerStageVector_assign(self, n, x)

    def resize(self, *args):
        return _classes.TriggerStageVector_resize(self, *args)

    def insert(self, *args):
        return _classes.TriggerStageVector_insert(self, *args)

    def reserve(self, n):
        return _classes.TriggerStageVector_reserve(self, n)

    def capacity(self):
        return _classes.TriggerStageVector_capacity(self)
    __swig_destroy__ = _classes.delete_TriggerStageVector
    __del__ = lambda self: None
TriggerStageVector_swigregister = _classes.TriggerStageVector_swigregister
TriggerStageVector_swigregister(TriggerStageVector)

class TriggerMatchVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TriggerMatchVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TriggerMatchVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _classes.TriggerMatchVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _classes.TriggerMatchVector___nonzero__(self)

    def __bool__(self):
        return _classes.TriggerMatchVector___bool__(self)

    def __len__(self):
        return _classes.TriggerMatchVector___len__(self)

    def __getslice__(self, i, j):
        return _classes.TriggerMatchVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _classes.TriggerMatchVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _classes.TriggerMatchVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _classes.TriggerMatchVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _classes.TriggerMatchVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _classes.TriggerMatchVector___setitem__(self, *args)

    def pop(self):
        return _classes.TriggerMatchVector_pop(self)

    def append(self, x):
        return _classes.TriggerMatchVector_append(self, x)

    def empty(self):
        return _classes.TriggerMatchVector_empty(self)

    def size(self):
        return _classes.TriggerMatchVector_size(self)

    def swap(self, v):
        return _classes.TriggerMatchVector_swap(self, v)

    def begin(self):
        return _classes.TriggerMatchVector_begin(self)

    def end(self):
        return _classes.TriggerMatchVector_end(self)

    def rbegin(self):
        return _classes.TriggerMatchVector_rbegin(self)

    def rend(self):
        return _classes.TriggerMatchVector_rend(self)

    def clear(self):
        return _classes.TriggerMatchVector_clear(self)

    def get_allocator(self):
        return _classes.TriggerMatchVector_get_allocator(self)

    def pop_back(self):
        return _classes.TriggerMatchVector_pop_back(self)

    def erase(self, *args):
        return _classes.TriggerMatchVector_erase(self, *args)

    def __init__(self, *args):
        this = _classes.new_TriggerMatchVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _classes.TriggerMatchVector_push_back(self, x)

    def front(self):
        return _classes.TriggerMatchVector_front(self)

    def back(self):
        return _classes.TriggerMatchVector_back(self)

    def assign(self, n, x):
        return _classes.TriggerMatchVector_assign(self, n, x)

    def resize(self, *args):
        return _classes.TriggerMatchVector_resize(self, *args)

    def insert(self, *args):
        return _classes.TriggerMatchVector_insert(self, *args)

    def reserve(self, n):
        return _classes.TriggerMatchVector_reserve(self, n)

    def capacity(self):
        return _classes.TriggerMatchVector_capacity(self)
    __swig_destroy__ = _classes.delete_TriggerMatchVector
    __del__ = lambda self: None
TriggerMatchVector_swigregister = _classes.TriggerMatchVector_swigregister
TriggerMatchVector_swigregister(TriggerMatchVector)

class Error(_object):
    """Exception thrown when an error code is returned by any libsigrok call."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Error, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Error, name)
    __repr__ = _swig_repr

    def __init__(self, result):
        this = _classes.new_Error(result)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _classes.delete_Error
    __del__ = lambda self: None
    __swig_getmethods__["result"] = _classes.Error_result_get
    if _newclass:
        result = _swig_property(_classes.Error_result_get)

    def what(self):
        return _classes.Error_what(self)
Error_swigregister = _classes.Error_swigregister
Error_swigregister(Error)

class ResourceReader(_object):
    """Resource reader delegate."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ResourceReader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ResourceReader, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _classes.delete_ResourceReader
    __del__ = lambda self: None
ResourceReader_swigregister = _classes.ResourceReader_swigregister
ResourceReader_swigregister(ResourceReader)

class Context(_object):
    """The global libsigrok context."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Context, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Context, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    if _newclass:
        create = staticmethod(_classes.Context_create)
    else:
        create = _classes.Context_create

    def _drivers(self):
        """Available hardware drivers, indexed by name."""
        return _classes.Context__drivers(self)


    def _input_formats(self):
        """Available input formats, indexed by name."""
        return _classes.Context__input_formats(self)


    def input_format_match(self, filename):
        """Lookup the responsible input module for an input file."""
        return _classes.Context_input_format_match(self, filename)


    def _output_formats(self):
        """Available output formats, indexed by name."""
        return _classes.Context__output_formats(self)


    def set_log_callback(self, callback):
        """
        Set the log callback.
        @param callback Callback of the form callback(LogLevel, string).
        """
        return _classes.Context_set_log_callback(self, callback)


    def set_log_callback_default(self):
        """Set the log callback to the default handler."""
        return _classes.Context_set_log_callback_default(self)


    def set_resource_reader(self, reader):
        """
        Install a delegate for reading resource files.
        @param reader The resource reader delegate, or nullptr to unset.
        """
        return _classes.Context_set_resource_reader(self, reader)


    def create_session(self):
        """Create a new session."""
        return _classes.Context_create_session(self)


    def create_user_device(self, vendor, model, version):
        """Create a new user device."""
        return _classes.Context_create_user_device(self, vendor, model, version)


    def create_header_packet(self, start_time):
        """Create a header packet."""
        return _classes.Context_create_header_packet(self, start_time)


    def create_meta_packet(self, config):
        """Create a meta packet."""
        return _classes.Context_create_meta_packet(self, config)


    def create_logic_packet(self, data_pointer, data_length, unit_size):
        """Create a logic packet."""
        return _classes.Context_create_logic_packet(self, data_pointer, data_length, unit_size)


    def create_analog_packet(self, channels, data_pointer, num_samples, mq, unit, mqflags):
        """Create an analog packet."""
        return _classes.Context_create_analog_packet(self, channels, data_pointer, num_samples, mq, unit, mqflags)


    def load_session(self, filename):
        """
        Load a saved session.
        @param filename File name string.
        """
        return _classes.Context_load_session(self, filename)


    def create_trigger(self, name):
        """
        Create a new trigger.
        @param name Name string for new trigger.
        """
        return _classes.Context_create_trigger(self, name)


    def open_file(self, filename):
        """
        Open an input file.
        @param filename File name string.
        """
        return _classes.Context_open_file(self, filename)


    def open_stream(self, header):
        """
        Open an input stream based on header data.
        @param header Initial data from stream.
        """
        return _classes.Context_open_stream(self, header)


    def serials(self, driver):
        return _classes.Context_serials(self, driver)
    __swig_destroy__ = _classes.delete_Context
    __del__ = lambda self: None

    drivers = property(fget = lambda x: x._drivers().asdict(), doc=_drivers.__doc__)


    input_formats = property(fget = lambda x: x._input_formats().asdict(), doc=_input_formats.__doc__)


    output_formats = property(fget = lambda x: x._output_formats().asdict(), doc=_output_formats.__doc__)

    __swig_getmethods__["package_version"] = _classes.Context_package_version_get
    if _newclass:
        package_version = _swig_property(_classes.Context_package_version_get)
    __swig_getmethods__["lib_version"] = _classes.Context_lib_version_get
    if _newclass:
        lib_version = _swig_property(_classes.Context_lib_version_get)
    __swig_setmethods__["log_level"] = _classes.Context_log_level_set
    __swig_getmethods__["log_level"] = _classes.Context_log_level_get
    if _newclass:
        log_level = _swig_property(_classes.Context_log_level_get, _classes.Context_log_level_set)
Context_swigregister = _classes.Context_swigregister
Context_swigregister(Context)

def Context_create():
    return _classes.Context_create()
Context_create = _classes.Context_create

class Configurable(_object):
    """An object that can be configured."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Configurable, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Configurable, name)

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

    def config_keys(self):
        """Supported configuration keys."""
        return _classes.Configurable_config_keys(self)


    def config_get(self, key):
        """
        Read configuration for the given key.
        @param key ConfigKey to read.
        """
        return _classes.Configurable_config_get(self, key)


    def config_list(self, key):
        """
        Enumerate available values for the given configuration key.
        @param key ConfigKey to enumerate values for.
        """
        return _classes.Configurable_config_list(self, key)


    def config_capabilities(self, key):
        """
        Enumerate configuration capabilities for the given configuration key.
        @param key ConfigKey to enumerate capabilities for.
        """
        return _classes.Configurable_config_capabilities(self, key)


    def config_check(self, key, capability):
        """
        Check whether a configuration capability is supported for a given key.
        @param capability Capability to check for.
        @param key ConfigKey to check.
        """
        return _classes.Configurable_config_check(self, key, capability)

    __swig_destroy__ = _classes.delete_Configurable
    __del__ = lambda self: None

    def config_set(self, *args):
        """
        Set configuration for the given key to a specified value.
        @param value Value to set.
        @param key ConfigKey to set.
        """
        return _classes.Configurable_config_set(self, *args)

Configurable_swigregister = _classes.Configurable_swigregister
Configurable_swigregister(Configurable)

class Driver(Configurable):
    """A hardware driver provided by the library."""

    __swig_setmethods__ = {}
    for _s in [Configurable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Driver, name, value)
    __swig_getmethods__ = {}
    for _s in [Configurable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Driver, name)

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

    def scan_options(self):
        """Scan options supported by this driver."""
        return _classes.Driver_scan_options(self)

    __swig_destroy__ = _classes.delete_Driver
    __del__ = lambda self: None
    __swig_getmethods__["name"] = _classes.Driver_name_get
    if _newclass:
        name = _swig_property(_classes.Driver_name_get)
    __swig_getmethods__["long_name"] = _classes.Driver_long_name_get
    if _newclass:
        long_name = _swig_property(_classes.Driver_long_name_get)

    def _scan_kwargs(self, dict):
        return _classes.Driver__scan_kwargs(self, dict)
Driver_swigregister = _classes.Driver_swigregister
Driver_swigregister(Driver)

class Device(Configurable):
    """A generic device, either hardware or virtual."""

    __swig_setmethods__ = {}
    for _s in [Configurable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Device, name, value)
    __swig_getmethods__ = {}
    for _s in [Configurable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Device, name)

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

    def serial_number(self):
        """Serial number for this device."""
        return _classes.Device_serial_number(self)


    def connection_id(self):
        """Connection ID for this device."""
        return _classes.Device_connection_id(self)


    def _channels(self):
        """List of the channels available on this device."""
        return _classes.Device__channels(self)


    def _channel_groups(self):
        """Channel groups available on this device, indexed by name."""
        return _classes.Device__channel_groups(self)


    def open(self):
        """Open device."""
        return _classes.Device_open(self)


    def close(self):
        """Close device."""
        return _classes.Device_close(self)

    __swig_destroy__ = _classes.delete_Device
    __del__ = lambda self: None
    __swig_getmethods__["vendor"] = _classes.Device_vendor_get
    if _newclass:
        vendor = _swig_property(_classes.Device_vendor_get)
    __swig_getmethods__["model"] = _classes.Device_model_get
    if _newclass:
        model = _swig_property(_classes.Device_model_get)
    __swig_getmethods__["version"] = _classes.Device_version_get
    if _newclass:
        version = _swig_property(_classes.Device_version_get)

    channels = property(_channels)


    channel_groups = property(fget = lambda x: x._channel_groups().asdict(), doc=_channel_groups.__doc__)

Device_swigregister = _classes.Device_swigregister
Device_swigregister(Device)

class HardwareDevice(Device):
    """A real hardware device, connected via a driver."""

    __swig_setmethods__ = {}
    for _s in [Device]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HardwareDevice, name, value)
    __swig_getmethods__ = {}
    for _s in [Device]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HardwareDevice, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _classes.delete_HardwareDevice
    __del__ = lambda self: None
    __swig_getmethods__["driver"] = _classes.HardwareDevice_driver_get
    if _newclass:
        driver = _swig_property(_classes.HardwareDevice_driver_get)
HardwareDevice_swigregister = _classes.HardwareDevice_swigregister
HardwareDevice_swigregister(HardwareDevice)

class UserDevice(Device):
    """A virtual device, created by the user."""

    __swig_setmethods__ = {}
    for _s in [Device]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UserDevice, name, value)
    __swig_getmethods__ = {}
    for _s in [Device]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, UserDevice, name)

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

    def add_channel(self, index, type, name):
        """Add a new channel to this device."""
        return _classes.UserDevice_add_channel(self, index, type, name)

    __swig_destroy__ = _classes.delete_UserDevice
    __del__ = lambda self: None
UserDevice_swigregister = _classes.UserDevice_swigregister
UserDevice_swigregister(UserDevice)

class Channel(_object):
    """A channel on a device."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Channel, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Channel, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _classes.delete_Channel
    __del__ = lambda self: None
    __swig_setmethods__["name"] = _classes.Channel_name_set
    __swig_getmethods__["name"] = _classes.Channel_name_get
    if _newclass:
        name = _swig_property(_classes.Channel_name_get, _classes.Channel_name_set)
    __swig_setmethods__["enabled"] = _classes.Channel_enabled_set
    __swig_getmethods__["enabled"] = _classes.Channel_enabled_get
    if _newclass:
        enabled = _swig_property(_classes.Channel_enabled_get, _classes.Channel_enabled_set)
    __swig_getmethods__["type"] = _classes.Channel_type_get
    if _newclass:
        type = _swig_property(_classes.Channel_type_get)
    __swig_getmethods__["index"] = _classes.Channel_index_get
    if _newclass:
        index = _swig_property(_classes.Channel_index_get)
Channel_swigregister = _classes.Channel_swigregister
Channel_swigregister(Channel)

class ChannelGroup(Configurable):
    """A group of channels on a device, which share some configuration."""

    __swig_setmethods__ = {}
    for _s in [Configurable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChannelGroup, name, value)
    __swig_getmethods__ = {}
    for _s in [Configurable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChannelGroup, name)

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

    def _channels(self):
        """List of the channels in this group."""
        return _classes.ChannelGroup__channels(self)

    __swig_destroy__ = _classes.delete_ChannelGroup
    __del__ = lambda self: None
    __swig_getmethods__["name"] = _classes.ChannelGroup_name_get
    if _newclass:
        name = _swig_property(_classes.ChannelGroup_name_get)

    channels = property(_channels)

ChannelGroup_swigregister = _classes.ChannelGroup_swigregister
ChannelGroup_swigregister(ChannelGroup)

class Trigger(_object):
    """A trigger configuration."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Trigger, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Trigger, name)

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

    def _stages(self):
        """List of the stages in this trigger."""
        return _classes.Trigger__stages(self)


    def add_stage(self):
        """Add a new stage to this trigger."""
        return _classes.Trigger_add_stage(self)

    __swig_destroy__ = _classes.delete_Trigger
    __del__ = lambda self: None
    __swig_getmethods__["name"] = _classes.Trigger_name_get
    if _newclass:
        name = _swig_property(_classes.Trigger_name_get)

    stages = property(_stages)

Trigger_swigregister = _classes.Trigger_swigregister
Trigger_swigregister(Trigger)

class TriggerStage(_object):
    """A stage in a trigger configuration."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TriggerStage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TriggerStage, name)

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

    def _matches(self):
        """List of match conditions on this stage."""
        return _classes.TriggerStage__matches(self)


    def add_match(self, *args):
        """
        Add a new match condition to this stage.
        @param type TriggerMatchType to apply.
        @param value Threshold value.
        @param channel Channel to match on.
        """
        return _classes.TriggerStage_add_match(self, *args)

    __swig_destroy__ = _classes.delete_TriggerStage
    __del__ = lambda self: None
    __swig_getmethods__["number"] = _classes.TriggerStage_number_get
    if _newclass:
        number = _swig_property(_classes.TriggerStage_number_get)

    matches = property(_matches)

TriggerStage_swigregister = _classes.TriggerStage_swigregister
TriggerStage_swigregister(TriggerStage)

class TriggerMatch(_object):
    """A match condition in a trigger configuration"""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TriggerMatch, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TriggerMatch, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _classes.delete_TriggerMatch
    __del__ = lambda self: None
    __swig_getmethods__["channel"] = _classes.TriggerMatch_channel_get
    if _newclass:
        channel = _swig_property(_classes.TriggerMatch_channel_get)
    __swig_getmethods__["type"] = _classes.TriggerMatch_type_get
    if _newclass:
        type = _swig_property(_classes.TriggerMatch_type_get)
    __swig_getmethods__["value"] = _classes.TriggerMatch_value_get
    if _newclass:
        value = _swig_property(_classes.TriggerMatch_value_get)
TriggerMatch_swigregister = _classes.TriggerMatch_swigregister
TriggerMatch_swigregister(TriggerMatch)

class SessionDevice(Device):
    """A virtual device associated with a stored session."""

    __swig_setmethods__ = {}
    for _s in [Device]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SessionDevice, name, value)
    __swig_getmethods__ = {}
    for _s in [Device]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SessionDevice, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _classes.delete_SessionDevice
    __del__ = lambda self: None
SessionDevice_swigregister = _classes.SessionDevice_swigregister
SessionDevice_swigregister(SessionDevice)

class Session(_object):
    """A sigrok session."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Session, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Session, name)

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

    def add_device(self, device):
        """
        Add a device to this session.
        @param device Device to add.
        """
        return _classes.Session_add_device(self, device)


    def _devices(self):
        """List devices attached to this session."""
        return _classes.Session__devices(self)


    def remove_devices(self):
        """Remove all devices from this session."""
        return _classes.Session_remove_devices(self)


    def add_datafeed_callback(self, callback):
        """
        Add a datafeed callback to this session.
        @param callback Callback of the form callback(Device, Packet).
        """
        return _classes.Session_add_datafeed_callback(self, callback)


    def remove_datafeed_callbacks(self):
        """Remove all datafeed callbacks from this session."""
        return _classes.Session_remove_datafeed_callbacks(self)


    def start(self):
        """Start the session."""
        return _classes.Session_start(self)


    def run(self):
        """Run the session event loop."""
        return _classes.Session_run(self)


    def stop(self):
        """Stop the session."""
        return _classes.Session_stop(self)


    def is_running(self):
        """Return whether the session is running."""
        return _classes.Session_is_running(self)


    def set_stopped_callback(self, callback):
        """Set callback to be invoked on session stop."""
        return _classes.Session_set_stopped_callback(self, callback)


    def context(self):
        """Get the context."""
        return _classes.Session_context(self)

    __swig_destroy__ = _classes.delete_Session
    __del__ = lambda self: None

    devices = property(_devices)

    __swig_setmethods__["trigger"] = _classes.Session_trigger_set
    __swig_getmethods__["trigger"] = _classes.Session_trigger_get
    if _newclass:
        trigger = _swig_property(_classes.Session_trigger_get, _classes.Session_trigger_set)
    __swig_getmethods__["filename"] = _classes.Session_filename_get
    if _newclass:
        filename = _swig_property(_classes.Session_filename_get)
Session_swigregister = _classes.Session_swigregister
Session_swigregister(Session)

class Packet(_object):
    """A packet on the session datafeed."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Packet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Packet, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _classes.delete_Packet
    __del__ = lambda self: None

    def _payload_header(self):
        return _classes.Packet__payload_header(self)

    def _payload_meta(self):
        return _classes.Packet__payload_meta(self)

    def _payload_analog(self):
        return _classes.Packet__payload_analog(self)

    def _payload_logic(self):
        return _classes.Packet__payload_logic(self)

    def _payload(self):
        if self.type == PacketType.HEADER:
            return self._payload_header()
        elif self.type == PacketType.META:
            return self._payload_meta()
        elif self.type == PacketType.LOGIC:
            return self._payload_logic()
        elif self.type == PacketType.ANALOG:
            return self._payload_analog()
        else:
            return None

    payload = property(_payload)

    __swig_getmethods__["type"] = _classes.Packet_type_get
    if _newclass:
        type = _swig_property(_classes.Packet_type_get)
Packet_swigregister = _classes.Packet_swigregister
Packet_swigregister(Packet)

class PacketPayload(_object):
    """Abstract base class for datafeed packet payloads."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PacketPayload, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PacketPayload, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _classes.delete_PacketPayload
    __del__ = lambda self: None
PacketPayload_swigregister = _classes.PacketPayload_swigregister
PacketPayload_swigregister(PacketPayload)

class Header(PacketPayload):
    """Payload of a datafeed header packet."""

    __swig_setmethods__ = {}
    for _s in [PacketPayload]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Header, name, value)
    __swig_getmethods__ = {}
    for _s in [PacketPayload]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Header, name)

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

    def feed_version(self):
        return _classes.Header_feed_version(self)

    def start_time(self):
        return _classes.Header_start_time(self)
    __swig_destroy__ = _classes.delete_Header
    __del__ = lambda self: None
Header_swigregister = _classes.Header_swigregister
Header_swigregister(Header)

class Meta(PacketPayload):
    """Payload of a datafeed metadata packet."""

    __swig_setmethods__ = {}
    for _s in [PacketPayload]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Meta, name, value)
    __swig_getmethods__ = {}
    for _s in [PacketPayload]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Meta, name)

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

    def _config(self):
        return _classes.Meta__config(self)
    __swig_destroy__ = _classes.delete_Meta
    __del__ = lambda self: None

    config = property(fget = lambda x: x._config().asdict(), doc=_config.__doc__)

Meta_swigregister = _classes.Meta_swigregister
Meta_swigregister(Meta)

class Logic(PacketPayload):
    """Payload of a datafeed packet with logic data."""

    __swig_setmethods__ = {}
    for _s in [PacketPayload]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Logic, name, value)
    __swig_getmethods__ = {}
    for _s in [PacketPayload]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Logic, name)

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

    def data_pointer(self):
        return _classes.Logic_data_pointer(self)

    def data_length(self):
        return _classes.Logic_data_length(self)

    def unit_size(self):
        return _classes.Logic_unit_size(self)
    __swig_destroy__ = _classes.delete_Logic
    __del__ = lambda self: None
Logic_swigregister = _classes.Logic_swigregister
Logic_swigregister(Logic)

class Analog(PacketPayload):
    """Payload of a datafeed packet with analog data."""

    __swig_setmethods__ = {}
    for _s in [PacketPayload]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Analog, name, value)
    __swig_getmethods__ = {}
    for _s in [PacketPayload]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Analog, name)

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

    def data_pointer(self):
        """Pointer to data."""
        return _classes.Analog_data_pointer(self)


    def get_data_as_float(self, dest):
        """Fills dest pointer with the analog data converted to float."""
        return _classes.Analog_get_data_as_float(self, dest)


    def _channels(self):
        """Channels for which this packet contains data."""
        return _classes.Analog__channels(self)


    def unitsize(self):
        """Size of a single sample in bytes."""
        return _classes.Analog_unitsize(self)


    def is_signed(self):
        """Samples use a signed data type."""
        return _classes.Analog_is_signed(self)


    def is_float(self):
        """Samples use float."""
        return _classes.Analog_is_float(self)


    def is_bigendian(self):
        """Samples are stored in big-endian order."""
        return _classes.Analog_is_bigendian(self)


    def digits(self):
        """Number of significant digits after the decimal point if positive, or number of non-significant digits before the decimal point if negative (refers to the value we actually read on the wire)."""
        return _classes.Analog_digits(self)


    def is_digits_decimal(self):
        """TBD."""
        return _classes.Analog_is_digits_decimal(self)


    def scale(self):
        """TBD."""
        return _classes.Analog_scale(self)


    def offset(self):
        """TBD."""
        return _classes.Analog_offset(self)


    def _mq_flags(self):
        """Measurement flags associated with the samples in this packet."""
        return _classes.Analog__mq_flags(self)


    def get_logic_via_threshold(self, threshold, data_ptr=None):
        """
        Provides a Logic packet that contains a conversion of the analog data using a simple threshold.
        @param threshold Threshold to use.
        @param data_ptr Pointer to num_samples() bytes where the logic samples are stored. When nullptr, memory for logic->data_pointer() will be allocated and must be freed by the caller.
        """
        return _classes.Analog_get_logic_via_threshold(self, threshold, data_ptr)


    def get_logic_via_schmitt_trigger(self, lo_thr, hi_thr, state, data_ptr=None):
        """
        Provides a Logic packet that contains a conversion of the analog data using a Schmitt-Trigger.
        @param lo_thr Low threshold to use (anything below this is low).
        @param data_ptr Pointer to num_samples() bytes where the logic samples are stored. When nullptr, memory for logic->data_pointer() will be allocated and must be freed by the caller.
        @param hi_thr High threshold to use (anything above this is high).
        @param state Points to a byte that contains the current state of the converter. For best results, set to value of logic sample n-1.
        """
        return _classes.Analog_get_logic_via_schmitt_trigger(self, lo_thr, hi_thr, state, data_ptr)

    __swig_destroy__ = _classes.delete_Analog
    __del__ = lambda self: None

    channels = property(_channels)

    __swig_getmethods__["num_samples"] = _classes.Analog_num_samples_get
    if _newclass:
        num_samples = _swig_property(_classes.Analog_num_samples_get)
    __swig_getmethods__["mq"] = _classes.Analog_mq_get
    if _newclass:
        mq = _swig_property(_classes.Analog_mq_get)
    __swig_getmethods__["unit"] = _classes.Analog_unit_get
    if _newclass:
        unit = _swig_property(_classes.Analog_unit_get)

    mq_flags = property(_mq_flags)


    def _data(self):
        return _classes.Analog__data(self)

    data = property(_data)

Analog_swigregister = _classes.Analog_swigregister
Analog_swigregister(Analog)

class Rational(_object):
    """Number represented by a numerator/denominator integer pair."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Rational, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Rational, name)

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

    def numerator(self):
        """Numerator, i.e."""
        return _classes.Rational_numerator(self)


    def denominator(self):
        """Denominator, i.e."""
        return _classes.Rational_denominator(self)


    def value(self):
        """Actual (lossy) value."""
        return _classes.Rational_value(self)

Rational_swigregister = _classes.Rational_swigregister
Rational_swigregister(Rational)

class InputFormat(_object):
    """An input format supported by the library."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InputFormat, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InputFormat, name)

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

    def extensions(self):
        """A list of preferred file name extensions for this file format."""
        return _classes.InputFormat_extensions(self)


    def options(self):
        """Options supported by this input format."""
        return _classes.InputFormat_options(self)

    __swig_destroy__ = _classes.delete_InputFormat
    __del__ = lambda self: None
    __swig_getmethods__["name"] = _classes.InputFormat_name_get
    if _newclass:
        name = _swig_property(_classes.InputFormat_name_get)
    __swig_getmethods__["description"] = _classes.InputFormat_description_get
    if _newclass:
        description = _swig_property(_classes.InputFormat_description_get)

    def _create_input_kwargs(self, dict):
        return _classes.InputFormat__create_input_kwargs(self, dict)
InputFormat_swigregister = _classes.InputFormat_swigregister
InputFormat_swigregister(InputFormat)

class Input(_object):
    """An input instance (an input format applied to a file or stream)"""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Input, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Input, name)

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

    def send(self, data, length):
        """
        Send next stream data.
        @param length Length of data.
        @param data Next stream data.
        """
        return _classes.Input_send(self, data, length)


    def end(self):
        """Signal end of input data."""
        return _classes.Input_end(self)


    def reset(self):
        return _classes.Input_reset(self)
    __swig_destroy__ = _classes.delete_Input
    __del__ = lambda self: None
    __swig_getmethods__["device"] = _classes.Input_device_get
    if _newclass:
        device = _swig_property(_classes.Input_device_get)
Input_swigregister = _classes.Input_swigregister
Input_swigregister(Input)

class InputDevice(Device):
    """A virtual device associated with an input."""

    __swig_setmethods__ = {}
    for _s in [Device]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InputDevice, name, value)
    __swig_getmethods__ = {}
    for _s in [Device]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InputDevice, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _classes.delete_InputDevice
    __del__ = lambda self: None
InputDevice_swigregister = _classes.InputDevice_swigregister
InputDevice_swigregister(InputDevice)

class Option(_object):
    """An option used by an output format."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Option, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Option, name)

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

    def default_value(self):
        """Default value for this option."""
        return _classes.Option_default_value(self)


    def _values(self):
        """Possible values for this option, if a limited set."""
        return _classes.Option__values(self)


    def parse_string(self, value):
        """Parse a string argument into the appropriate type for this option."""
        return _classes.Option_parse_string(self, value)

    __swig_destroy__ = _classes.delete_Option
    __del__ = lambda self: None
    __swig_getmethods__["id"] = _classes.Option_id_get
    if _newclass:
        id = _swig_property(_classes.Option_id_get)
    __swig_getmethods__["name"] = _classes.Option_name_get
    if _newclass:
        name = _swig_property(_classes.Option_name_get)
    __swig_getmethods__["description"] = _classes.Option_description_get
    if _newclass:
        description = _swig_property(_classes.Option_description_get)

    values = property(_values)

Option_swigregister = _classes.Option_swigregister
Option_swigregister(Option)

class OutputFormat(_object):
    """An output format supported by the library."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutputFormat, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OutputFormat, name)

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

    def extensions(self):
        """A list of preferred file name extensions for this file format."""
        return _classes.OutputFormat_extensions(self)


    def _options(self):
        """Options supported by this output format."""
        return _classes.OutputFormat__options(self)


    def test_flag(self, flag):
        """
        Checks whether a given flag is set.
        @param flag Flag to check
        """
        return _classes.OutputFormat_test_flag(self, flag)

    __swig_destroy__ = _classes.delete_OutputFormat
    __del__ = lambda self: None
    __swig_getmethods__["name"] = _classes.OutputFormat_name_get
    if _newclass:
        name = _swig_property(_classes.OutputFormat_name_get)
    __swig_getmethods__["description"] = _classes.OutputFormat_description_get
    if _newclass:
        description = _swig_property(_classes.OutputFormat_description_get)

    options = property(fget = lambda x: x._options().asdict(), doc=_options.__doc__)


    def _create_output_kwargs(self, device, dict):
        return _classes.OutputFormat__create_output_kwargs(self, device, dict)
OutputFormat_swigregister = _classes.OutputFormat_swigregister
OutputFormat_swigregister(OutputFormat)

class Output(_object):
    """An output instance (an output format applied to a device)"""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Output, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Output, name)

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

    def receive(self, packet):
        """
        Update output with data from the given packet.
        @param packet Packet to handle.
        """
        return _classes.Output_receive(self, packet)

    __swig_destroy__ = _classes.delete_Output
    __del__ = lambda self: None
Output_swigregister = _classes.Output_swigregister
Output_swigregister(Output)

class EnumValueLogLevel(_object):
    """Base class for objects which wrap an enumeration value from libsigrok."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnumValueLogLevel, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EnumValueLogLevel, name)

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

    def id(self):
        """The integer constant associated with this value."""
        return _classes.EnumValueLogLevel_id(self)


    def name(self):
        """The name associated with this value."""
        return _classes.EnumValueLogLevel_name(self)

    if _newclass:
        get = staticmethod(_classes.EnumValueLogLevel_get)
    else:
        get = _classes.EnumValueLogLevel_get
    if _newclass:
        values = staticmethod(_classes.EnumValueLogLevel_values)
    else:
        values = _classes.EnumValueLogLevel_values
EnumValueLogLevel_swigregister = _classes.EnumValueLogLevel_swigregister
EnumValueLogLevel_swigregister(EnumValueLogLevel)

def EnumValueLogLevel_get(id):
    return _classes.EnumValueLogLevel_get(id)
EnumValueLogLevel_get = _classes.EnumValueLogLevel_get

def EnumValueLogLevel_values():
    return _classes.EnumValueLogLevel_values()
EnumValueLogLevel_values = _classes.EnumValueLogLevel_values

class EnumValueDataType(_object):
    """Base class for objects which wrap an enumeration value from libsigrok."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnumValueDataType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EnumValueDataType, name)

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

    def id(self):
        """The integer constant associated with this value."""
        return _classes.EnumValueDataType_id(self)


    def name(self):
        """The name associated with this value."""
        return _classes.EnumValueDataType_name(self)

    if _newclass:
        get = staticmethod(_classes.EnumValueDataType_get)
    else:
        get = _classes.EnumValueDataType_get
    if _newclass:
        values = staticmethod(_classes.EnumValueDataType_values)
    else:
        values = _classes.EnumValueDataType_values
EnumValueDataType_swigregister = _classes.EnumValueDataType_swigregister
EnumValueDataType_swigregister(EnumValueDataType)

def EnumValueDataType_get(id):
    return _classes.EnumValueDataType_get(id)
EnumValueDataType_get = _classes.EnumValueDataType_get

def EnumValueDataType_values():
    return _classes.EnumValueDataType_values()
EnumValueDataType_values = _classes.EnumValueDataType_values

class EnumValuePacketType(_object):
    """Base class for objects which wrap an enumeration value from libsigrok."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnumValuePacketType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EnumValuePacketType, name)

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

    def id(self):
        """The integer constant associated with this value."""
        return _classes.EnumValuePacketType_id(self)


    def name(self):
        """The name associated with this value."""
        return _classes.EnumValuePacketType_name(self)

    if _newclass:
        get = staticmethod(_classes.EnumValuePacketType_get)
    else:
        get = _classes.EnumValuePacketType_get
    if _newclass:
        values = staticmethod(_classes.EnumValuePacketType_values)
    else:
        values = _classes.EnumValuePacketType_values
EnumValuePacketType_swigregister = _classes.EnumValuePacketType_swigregister
EnumValuePacketType_swigregister(EnumValuePacketType)

def EnumValuePacketType_get(id):
    return _classes.EnumValuePacketType_get(id)
EnumValuePacketType_get = _classes.EnumValuePacketType_get

def EnumValuePacketType_values():
    return _classes.EnumValuePacketType_values()
EnumValuePacketType_values = _classes.EnumValuePacketType_values

class EnumValueQuantity(_object):
    """Base class for objects which wrap an enumeration value from libsigrok."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnumValueQuantity, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EnumValueQuantity, name)

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

    def id(self):
        """The integer constant associated with this value."""
        return _classes.EnumValueQuantity_id(self)


    def name(self):
        """The name associated with this value."""
        return _classes.EnumValueQuantity_name(self)

    if _newclass:
        get = staticmethod(_classes.EnumValueQuantity_get)
    else:
        get = _classes.EnumValueQuantity_get
    if _newclass:
        values = staticmethod(_classes.EnumValueQuantity_values)
    else:
        values = _classes.EnumValueQuantity_values
EnumValueQuantity_swigregister = _classes.EnumValueQuantity_swigregister
EnumValueQuantity_swigregister(EnumValueQuantity)

def EnumValueQuantity_get(id):
    return _classes.EnumValueQuantity_get(id)
EnumValueQuantity_get = _classes.EnumValueQuantity_get

def EnumValueQuantity_values():
    return _classes.EnumValueQuantity_values()
EnumValueQuantity_values = _classes.EnumValueQuantity_values

class EnumValueUnit(_object):
    """Base class for objects which wrap an enumeration value from libsigrok."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnumValueUnit, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EnumValueUnit, name)

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

    def id(self):
        """The integer constant associated with this value."""
        return _classes.EnumValueUnit_id(self)


    def name(self):
        """The name associated with this value."""
        return _classes.EnumValueUnit_name(self)

    if _newclass:
        get = staticmethod(_classes.EnumValueUnit_get)
    else:
        get = _classes.EnumValueUnit_get
    if _newclass:
        values = staticmethod(_classes.EnumValueUnit_values)
    else:
        values = _classes.EnumValueUnit_values
EnumValueUnit_swigregister = _classes.EnumValueUnit_swigregister
EnumValueUnit_swigregister(EnumValueUnit)

def EnumValueUnit_get(id):
    return _classes.EnumValueUnit_get(id)
EnumValueUnit_get = _classes.EnumValueUnit_get

def EnumValueUnit_values():
    return _classes.EnumValueUnit_values()
EnumValueUnit_values = _classes.EnumValueUnit_values

class EnumValueQuantityFlag(_object):
    """Base class for objects which wrap an enumeration value from libsigrok."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnumValueQuantityFlag, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EnumValueQuantityFlag, name)

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

    def id(self):
        """The integer constant associated with this value."""
        return _classes.EnumValueQuantityFlag_id(self)


    def name(self):
        """The name associated with this value."""
        return _classes.EnumValueQuantityFlag_name(self)

    if _newclass:
        get = staticmethod(_classes.EnumValueQuantityFlag_get)
    else:
        get = _classes.EnumValueQuantityFlag_get
    if _newclass:
        values = staticmethod(_classes.EnumValueQuantityFlag_values)
    else:
        values = _classes.EnumValueQuantityFlag_values
EnumValueQuantityFlag_swigregister = _classes.EnumValueQuantityFlag_swigregister
EnumValueQuantityFlag_swigregister(EnumValueQuantityFlag)

def EnumValueQuantityFlag_get(id):
    return _classes.EnumValueQuantityFlag_get(id)
EnumValueQuantityFlag_get = _classes.EnumValueQuantityFlag_get

def EnumValueQuantityFlag_values():
    return _classes.EnumValueQuantityFlag_values()
EnumValueQuantityFlag_values = _classes.EnumValueQuantityFlag_values

class EnumValueTriggerMatchType(_object):
    """Base class for objects which wrap an enumeration value from libsigrok."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnumValueTriggerMatchType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EnumValueTriggerMatchType, name)

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

    def id(self):
        """The integer constant associated with this value."""
        return _classes.EnumValueTriggerMatchType_id(self)


    def name(self):
        """The name associated with this value."""
        return _classes.EnumValueTriggerMatchType_name(self)

    if _newclass:
        get = staticmethod(_classes.EnumValueTriggerMatchType_get)
    else:
        get = _classes.EnumValueTriggerMatchType_get
    if _newclass:
        values = staticmethod(_classes.EnumValueTriggerMatchType_values)
    else:
        values = _classes.EnumValueTriggerMatchType_values
EnumValueTriggerMatchType_swigregister = _classes.EnumValueTriggerMatchType_swigregister
EnumValueTriggerMatchType_swigregister(EnumValueTriggerMatchType)

def EnumValueTriggerMatchType_get(id):
    return _classes.EnumValueTriggerMatchType_get(id)
EnumValueTriggerMatchType_get = _classes.EnumValueTriggerMatchType_get

def EnumValueTriggerMatchType_values():
    return _classes.EnumValueTriggerMatchType_values()
EnumValueTriggerMatchType_values = _classes.EnumValueTriggerMatchType_values

class EnumValueOutputFlag(_object):
    """Base class for objects which wrap an enumeration value from libsigrok."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnumValueOutputFlag, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EnumValueOutputFlag, name)

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

    def id(self):
        """The integer constant associated with this value."""
        return _classes.EnumValueOutputFlag_id(self)


    def name(self):
        """The name associated with this value."""
        return _classes.EnumValueOutputFlag_name(self)

    if _newclass:
        get = staticmethod(_classes.EnumValueOutputFlag_get)
    else:
        get = _classes.EnumValueOutputFlag_get
    if _newclass:
        values = staticmethod(_classes.EnumValueOutputFlag_values)
    else:
        values = _classes.EnumValueOutputFlag_values
EnumValueOutputFlag_swigregister = _classes.EnumValueOutputFlag_swigregister
EnumValueOutputFlag_swigregister(EnumValueOutputFlag)

def EnumValueOutputFlag_get(id):
    return _classes.EnumValueOutputFlag_get(id)
EnumValueOutputFlag_get = _classes.EnumValueOutputFlag_get

def EnumValueOutputFlag_values():
    return _classes.EnumValueOutputFlag_values()
EnumValueOutputFlag_values = _classes.EnumValueOutputFlag_values

class EnumValueChannelType(_object):
    """Base class for objects which wrap an enumeration value from libsigrok."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnumValueChannelType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EnumValueChannelType, name)

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

    def id(self):
        """The integer constant associated with this value."""
        return _classes.EnumValueChannelType_id(self)


    def name(self):
        """The name associated with this value."""
        return _classes.EnumValueChannelType_name(self)

    if _newclass:
        get = staticmethod(_classes.EnumValueChannelType_get)
    else:
        get = _classes.EnumValueChannelType_get
    if _newclass:
        values = staticmethod(_classes.EnumValueChannelType_values)
    else:
        values = _classes.EnumValueChannelType_values
EnumValueChannelType_swigregister = _classes.EnumValueChannelType_swigregister
EnumValueChannelType_swigregister(EnumValueChannelType)

def EnumValueChannelType_get(id):
    return _classes.EnumValueChannelType_get(id)
EnumValueChannelType_get = _classes.EnumValueChannelType_get

def EnumValueChannelType_values():
    return _classes.EnumValueChannelType_values()
EnumValueChannelType_values = _classes.EnumValueChannelType_values

class EnumValueCapability(_object):
    """Base class for objects which wrap an enumeration value from libsigrok."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnumValueCapability, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EnumValueCapability, name)

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

    def id(self):
        """The integer constant associated with this value."""
        return _classes.EnumValueCapability_id(self)


    def name(self):
        """The name associated with this value."""
        return _classes.EnumValueCapability_name(self)

    if _newclass:
        get = staticmethod(_classes.EnumValueCapability_get)
    else:
        get = _classes.EnumValueCapability_get
    if _newclass:
        values = staticmethod(_classes.EnumValueCapability_values)
    else:
        values = _classes.EnumValueCapability_values
EnumValueCapability_swigregister = _classes.EnumValueCapability_swigregister
EnumValueCapability_swigregister(EnumValueCapability)

def EnumValueCapability_get(id):
    return _classes.EnumValueCapability_get(id)
EnumValueCapability_get = _classes.EnumValueCapability_get

def EnumValueCapability_values():
    return _classes.EnumValueCapability_values()
EnumValueCapability_values = _classes.EnumValueCapability_values

class EnumValueConfigKey(_object):
    """Base class for objects which wrap an enumeration value from libsigrok."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnumValueConfigKey, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EnumValueConfigKey, name)

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

    def id(self):
        """The integer constant associated with this value."""
        return _classes.EnumValueConfigKey_id(self)


    def name(self):
        """The name associated with this value."""
        return _classes.EnumValueConfigKey_name(self)

    if _newclass:
        get = staticmethod(_classes.EnumValueConfigKey_get)
    else:
        get = _classes.EnumValueConfigKey_get
    if _newclass:
        values = staticmethod(_classes.EnumValueConfigKey_values)
    else:
        values = _classes.EnumValueConfigKey_values
EnumValueConfigKey_swigregister = _classes.EnumValueConfigKey_swigregister
EnumValueConfigKey_swigregister(EnumValueConfigKey)

def EnumValueConfigKey_get(id):
    return _classes.EnumValueConfigKey_get(id)
EnumValueConfigKey_get = _classes.EnumValueConfigKey_get

def EnumValueConfigKey_values():
    return _classes.EnumValueConfigKey_values()
EnumValueConfigKey_values = _classes.EnumValueConfigKey_values

class LogLevel(EnumValueLogLevel):
    """Log verbosity level."""

    __swig_setmethods__ = {}
    for _s in [EnumValueLogLevel]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LogLevel, name, value)
    __swig_getmethods__ = {}
    for _s in [EnumValueLogLevel]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LogLevel, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")

        ## @brief Output no messages at all.
    NONE = None
    ## @brief Output error messages.
    ERR = None
    ## @brief Output warnings.
    WARN = None
    ## @brief Output informational messages.
    INFO = None
    ## @brief Output debug messages.
    DBG = None
    ## @brief Output very noisy debug messages.
    SPEW = None

    __swig_getmethods__["id"] = _classes.LogLevel_id_get
    if _newclass:
        id = _swig_property(_classes.LogLevel_id_get)
    __swig_getmethods__["name"] = _classes.LogLevel_name_get
    if _newclass:
        name = _swig_property(_classes.LogLevel_name_get)

    def __hash__(self):
        return _classes.LogLevel___hash__(self)

    def __str__(self):
        return _classes.LogLevel___str__(self)

    def __repr__(self):
        return _classes.LogLevel___repr__(self)

    def __eq__(self, other):
      return (type(self) is type(other) and hash(self) == hash(other))

    def __ne__(self, other):
      return (type(self) is not type(other) or hash(self) != hash(other))

    __swig_destroy__ = _classes.delete_LogLevel
    __del__ = lambda self: None
LogLevel_swigregister = _classes.LogLevel_swigregister
LogLevel_swigregister(LogLevel)
cvar = _classes.cvar
LogLevel.NONE = _classes.cvar.LogLevel_NONE
LogLevel.ERR = _classes.cvar.LogLevel_ERR
LogLevel.WARN = _classes.cvar.LogLevel_WARN
LogLevel.INFO = _classes.cvar.LogLevel_INFO
LogLevel.DBG = _classes.cvar.LogLevel_DBG
LogLevel.SPEW = _classes.cvar.LogLevel_SPEW

class DataType(EnumValueDataType):
    """Configuration data type."""

    __swig_setmethods__ = {}
    for _s in [EnumValueDataType]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataType, name, value)
    __swig_getmethods__ = {}
    for _s in [EnumValueDataType]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataType, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __swig_getmethods__["id"] = _classes.DataType_id_get
    if _newclass:
        id = _swig_property(_classes.DataType_id_get)
    __swig_getmethods__["name"] = _classes.DataType_name_get
    if _newclass:
        name = _swig_property(_classes.DataType_name_get)

    def __hash__(self):
        return _classes.DataType___hash__(self)

    def __str__(self):
        return _classes.DataType___str__(self)

    def __repr__(self):
        return _classes.DataType___repr__(self)

    def __eq__(self, other):
      return (type(self) is type(other) and hash(self) == hash(other))

    def __ne__(self, other):
      return (type(self) is not type(other) or hash(self) != hash(other))

    __swig_destroy__ = _classes.delete_DataType
    __del__ = lambda self: None
DataType_swigregister = _classes.DataType_swigregister
DataType_swigregister(DataType)
DataType.UINT64 = _classes.cvar.DataType_UINT64
DataType.STRING = _classes.cvar.DataType_STRING
DataType.BOOL = _classes.cvar.DataType_BOOL
DataType.FLOAT = _classes.cvar.DataType_FLOAT
DataType.RATIONAL_PERIOD = _classes.cvar.DataType_RATIONAL_PERIOD
DataType.RATIONAL_VOLT = _classes.cvar.DataType_RATIONAL_VOLT
DataType.KEYVALUE = _classes.cvar.DataType_KEYVALUE
DataType.UINT64_RANGE = _classes.cvar.DataType_UINT64_RANGE
DataType.DOUBLE_RANGE = _classes.cvar.DataType_DOUBLE_RANGE
DataType.INT32 = _classes.cvar.DataType_INT32
DataType.MQ = _classes.cvar.DataType_MQ

class PacketType(EnumValuePacketType):
    """Type of datafeed packet."""

    __swig_setmethods__ = {}
    for _s in [EnumValuePacketType]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PacketType, name, value)
    __swig_getmethods__ = {}
    for _s in [EnumValuePacketType]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PacketType, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")

        ## @brief Payload is.
    HEADER = None
    ## @brief End of stream (no further data).
    END = None
    ## @brief Payload is struct.
    META = None
    ## @brief The trigger matched at this point in the data feed.
    TRIGGER = None
    ## @brief Payload is struct.
    LOGIC = None
    ## @brief Beginning of frame.
    FRAME_BEGIN = None
    ## @brief End of frame.
    FRAME_END = None
    ## @brief Payload is struct.
    ANALOG = None

    __swig_getmethods__["id"] = _classes.PacketType_id_get
    if _newclass:
        id = _swig_property(_classes.PacketType_id_get)
    __swig_getmethods__["name"] = _classes.PacketType_name_get
    if _newclass:
        name = _swig_property(_classes.PacketType_name_get)

    def __hash__(self):
        return _classes.PacketType___hash__(self)

    def __str__(self):
        return _classes.PacketType___str__(self)

    def __repr__(self):
        return _classes.PacketType___repr__(self)

    def __eq__(self, other):
      return (type(self) is type(other) and hash(self) == hash(other))

    def __ne__(self, other):
      return (type(self) is not type(other) or hash(self) != hash(other))

    __swig_destroy__ = _classes.delete_PacketType
    __del__ = lambda self: None
PacketType_swigregister = _classes.PacketType_swigregister
PacketType_swigregister(PacketType)
PacketType.HEADER = _classes.cvar.PacketType_HEADER
PacketType.END = _classes.cvar.PacketType_END
PacketType.META = _classes.cvar.PacketType_META
PacketType.TRIGGER = _classes.cvar.PacketType_TRIGGER
PacketType.LOGIC = _classes.cvar.PacketType_LOGIC
PacketType.FRAME_BEGIN = _classes.cvar.PacketType_FRAME_BEGIN
PacketType.FRAME_END = _classes.cvar.PacketType_FRAME_END
PacketType.ANALOG = _classes.cvar.PacketType_ANALOG

class Quantity(EnumValueQuantity):
    """Measured quantity."""

    __swig_setmethods__ = {}
    for _s in [EnumValueQuantity]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Quantity, name, value)
    __swig_getmethods__ = {}
    for _s in [EnumValueQuantity]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Quantity, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")

        ## @brief Duty cycle, e.g.
    DUTY_CYCLE = None
    ## @brief Continuity test.
    CONTINUITY = None
    ## @brief Electrical power, usually in W, or dBm.
    POWER = None
    ## @brief Gain (a transistor's gain, or hFE, for example).
    GAIN = None
    ## @brief Logarithmic representation of sound pressure relative to a reference value.
    SOUND_PRESSURE_LEVEL = None
    ## @brief Carbon monoxide level.
    CARBON_MONOXIDE = None
    ## @brief Humidity.
    RELATIVE_HUMIDITY = None
    ## @brief Time.
    TIME = None
    ## @brief Wind speed.
    WIND_SPEED = None
    ## @brief Pressure.
    PRESSURE = None
    ## @brief Parallel inductance (LCR meter model).
    PARALLEL_INDUCTANCE = None
    ## @brief Parallel capacitance (LCR meter model).
    PARALLEL_CAPACITANCE = None
    ## @brief Parallel resistance (LCR meter model).
    PARALLEL_RESISTANCE = None
    ## @brief Series inductance (LCR meter model).
    SERIES_INDUCTANCE = None
    ## @brief Series capacitance (LCR meter model).
    SERIES_CAPACITANCE = None
    ## @brief Series resistance (LCR meter model).
    SERIES_RESISTANCE = None
    ## @brief Dissipation factor.
    DISSIPATION_FACTOR = None
    ## @brief Quality factor.
    QUALITY_FACTOR = None
    ## @brief Phase angle.
    PHASE_ANGLE = None
    ## @brief Difference from reference value.
    DIFFERENCE = None
    ## @brief Count.
    COUNT = None
    ## @brief Power factor.
    POWER_FACTOR = None
    ## @brief Apparent power.
    APPARENT_POWER = None
    ## @brief Mass.
    MASS = None
    ## @brief Harmonic ratio.
    HARMONIC_RATIO = None

    __swig_getmethods__["id"] = _classes.Quantity_id_get
    if _newclass:
        id = _swig_property(_classes.Quantity_id_get)
    __swig_getmethods__["name"] = _classes.Quantity_name_get
    if _newclass:
        name = _swig_property(_classes.Quantity_name_get)

    def __hash__(self):
        return _classes.Quantity___hash__(self)

    def __str__(self):
        return _classes.Quantity___str__(self)

    def __repr__(self):
        return _classes.Quantity___repr__(self)

    def __eq__(self, other):
      return (type(self) is type(other) and hash(self) == hash(other))

    def __ne__(self, other):
      return (type(self) is not type(other) or hash(self) != hash(other))

    __swig_destroy__ = _classes.delete_Quantity
    __del__ = lambda self: None
Quantity_swigregister = _classes.Quantity_swigregister
Quantity_swigregister(Quantity)
Quantity.VOLTAGE = _classes.cvar.Quantity_VOLTAGE
Quantity.CURRENT = _classes.cvar.Quantity_CURRENT
Quantity.RESISTANCE = _classes.cvar.Quantity_RESISTANCE
Quantity.CAPACITANCE = _classes.cvar.Quantity_CAPACITANCE
Quantity.TEMPERATURE = _classes.cvar.Quantity_TEMPERATURE
Quantity.FREQUENCY = _classes.cvar.Quantity_FREQUENCY
Quantity.DUTY_CYCLE = _classes.cvar.Quantity_DUTY_CYCLE
Quantity.CONTINUITY = _classes.cvar.Quantity_CONTINUITY
Quantity.PULSE_WIDTH = _classes.cvar.Quantity_PULSE_WIDTH
Quantity.CONDUCTANCE = _classes.cvar.Quantity_CONDUCTANCE
Quantity.POWER = _classes.cvar.Quantity_POWER
Quantity.GAIN = _classes.cvar.Quantity_GAIN
Quantity.SOUND_PRESSURE_LEVEL = _classes.cvar.Quantity_SOUND_PRESSURE_LEVEL
Quantity.CARBON_MONOXIDE = _classes.cvar.Quantity_CARBON_MONOXIDE
Quantity.RELATIVE_HUMIDITY = _classes.cvar.Quantity_RELATIVE_HUMIDITY
Quantity.TIME = _classes.cvar.Quantity_TIME
Quantity.WIND_SPEED = _classes.cvar.Quantity_WIND_SPEED
Quantity.PRESSURE = _classes.cvar.Quantity_PRESSURE
Quantity.PARALLEL_INDUCTANCE = _classes.cvar.Quantity_PARALLEL_INDUCTANCE
Quantity.PARALLEL_CAPACITANCE = _classes.cvar.Quantity_PARALLEL_CAPACITANCE
Quantity.PARALLEL_RESISTANCE = _classes.cvar.Quantity_PARALLEL_RESISTANCE
Quantity.SERIES_INDUCTANCE = _classes.cvar.Quantity_SERIES_INDUCTANCE
Quantity.SERIES_CAPACITANCE = _classes.cvar.Quantity_SERIES_CAPACITANCE
Quantity.SERIES_RESISTANCE = _classes.cvar.Quantity_SERIES_RESISTANCE
Quantity.DISSIPATION_FACTOR = _classes.cvar.Quantity_DISSIPATION_FACTOR
Quantity.QUALITY_FACTOR = _classes.cvar.Quantity_QUALITY_FACTOR
Quantity.PHASE_ANGLE = _classes.cvar.Quantity_PHASE_ANGLE
Quantity.DIFFERENCE = _classes.cvar.Quantity_DIFFERENCE
Quantity.COUNT = _classes.cvar.Quantity_COUNT
Quantity.POWER_FACTOR = _classes.cvar.Quantity_POWER_FACTOR
Quantity.APPARENT_POWER = _classes.cvar.Quantity_APPARENT_POWER
Quantity.MASS = _classes.cvar.Quantity_MASS
Quantity.HARMONIC_RATIO = _classes.cvar.Quantity_HARMONIC_RATIO

class Unit(EnumValueUnit):
    """Unit of measurement."""

    __swig_setmethods__ = {}
    for _s in [EnumValueUnit]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Unit, name, value)
    __swig_getmethods__ = {}
    for _s in [EnumValueUnit]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Unit, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")

        ## @brief Volt.
    VOLT = None
    ## @brief Ampere (current).
    AMPERE = None
    ## @brief Ohm (resistance).
    OHM = None
    ## @brief Farad (capacity).
    FARAD = None
    ## @brief Kelvin (temperature).
    KELVIN = None
    ## @brief Degrees Celsius (temperature).
    CELSIUS = None
    ## @brief Degrees Fahrenheit (temperature).
    FAHRENHEIT = None
    ## @brief Hertz (frequency, 1/s, [Hz]).
    HERTZ = None
    ## @brief Percent value.
    PERCENTAGE = None
    ## @brief Boolean value.
    BOOLEAN = None
    ## @brief Time in seconds.
    SECOND = None
    ## @brief Unit of conductance, the inverse of resistance.
    SIEMENS = None
    ## @brief An absolute measurement of power, in decibels, referenced to 1 milliwatt (dBm).
    DECIBEL_MW = None
    ## @brief Voltage in decibel, referenced to 1 volt (dBV).
    DECIBEL_VOLT = None
    ## @brief Measurements that intrinsically do not have units attached, such as ratios, gains, etc.
    UNITLESS = None
    ## @brief Sound pressure level, in decibels, relative to 20 micropascals.
    DECIBEL_SPL = None
    ## @brief Normalized (0 to 1) concentration of a substance or compound with 0 representing a concentration of 0%, and 1 being 100%.
    CONCENTRATION = None
    ## @brief Revolutions per minute.
    REVOLUTIONS_PER_MINUTE = None
    ## @brief Apparent power [VA].
    VOLT_AMPERE = None
    ## @brief Real power [W].
    WATT = None
    ## @brief Consumption [Wh].
    WATT_HOUR = None
    ## @brief Wind speed in meters per second.
    METER_SECOND = None
    ## @brief Pressure in hectopascal.
    HECTOPASCAL = None
    ## @brief Relative humidity assuming air temperature of 293 Kelvin (rF).
    HUMIDITY_293K = None
    ## @brief Plane angle in 1/360th of a full circle.
    DEGREE = None
    ## @brief Henry (inductance).
    HENRY = None
    ## @brief Mass in gram [g].
    GRAM = None
    ## @brief Mass in carat [ct].
    CARAT = None
    ## @brief Mass in ounce [oz].
    OUNCE = None
    ## @brief Mass in troy ounce [oz t].
    TROY_OUNCE = None
    ## @brief Mass in pound [lb].
    POUND = None
    ## @brief Mass in pennyweight [dwt].
    PENNYWEIGHT = None
    ## @brief Mass in grain [gr].
    GRAIN = None
    ## @brief Mass in tael (variants: Hong Kong, Singapore/Malaysia, Taiwan)
    TAEL = None
    ## @brief Mass in momme.
    MOMME = None
    ## @brief Mass in tola.
    TOLA = None
    ## @brief Pieces (number of items).
    PIECE = None

    __swig_getmethods__["id"] = _classes.Unit_id_get
    if _newclass:
        id = _swig_property(_classes.Unit_id_get)
    __swig_getmethods__["name"] = _classes.Unit_name_get
    if _newclass:
        name = _swig_property(_classes.Unit_name_get)

    def __hash__(self):
        return _classes.Unit___hash__(self)

    def __str__(self):
        return _classes.Unit___str__(self)

    def __repr__(self):
        return _classes.Unit___repr__(self)

    def __eq__(self, other):
      return (type(self) is type(other) and hash(self) == hash(other))

    def __ne__(self, other):
      return (type(self) is not type(other) or hash(self) != hash(other))

    __swig_destroy__ = _classes.delete_Unit
    __del__ = lambda self: None
Unit_swigregister = _classes.Unit_swigregister
Unit_swigregister(Unit)
Unit.VOLT = _classes.cvar.Unit_VOLT
Unit.AMPERE = _classes.cvar.Unit_AMPERE
Unit.OHM = _classes.cvar.Unit_OHM
Unit.FARAD = _classes.cvar.Unit_FARAD
Unit.KELVIN = _classes.cvar.Unit_KELVIN
Unit.CELSIUS = _classes.cvar.Unit_CELSIUS
Unit.FAHRENHEIT = _classes.cvar.Unit_FAHRENHEIT
Unit.HERTZ = _classes.cvar.Unit_HERTZ
Unit.PERCENTAGE = _classes.cvar.Unit_PERCENTAGE
Unit.BOOLEAN = _classes.cvar.Unit_BOOLEAN
Unit.SECOND = _classes.cvar.Unit_SECOND
Unit.SIEMENS = _classes.cvar.Unit_SIEMENS
Unit.DECIBEL_MW = _classes.cvar.Unit_DECIBEL_MW
Unit.DECIBEL_VOLT = _classes.cvar.Unit_DECIBEL_VOLT
Unit.UNITLESS = _classes.cvar.Unit_UNITLESS
Unit.DECIBEL_SPL = _classes.cvar.Unit_DECIBEL_SPL
Unit.CONCENTRATION = _classes.cvar.Unit_CONCENTRATION
Unit.REVOLUTIONS_PER_MINUTE = _classes.cvar.Unit_REVOLUTIONS_PER_MINUTE
Unit.VOLT_AMPERE = _classes.cvar.Unit_VOLT_AMPERE
Unit.WATT = _classes.cvar.Unit_WATT
Unit.WATT_HOUR = _classes.cvar.Unit_WATT_HOUR
Unit.METER_SECOND = _classes.cvar.Unit_METER_SECOND
Unit.HECTOPASCAL = _classes.cvar.Unit_HECTOPASCAL
Unit.HUMIDITY_293K = _classes.cvar.Unit_HUMIDITY_293K
Unit.DEGREE = _classes.cvar.Unit_DEGREE
Unit.HENRY = _classes.cvar.Unit_HENRY
Unit.GRAM = _classes.cvar.Unit_GRAM
Unit.CARAT = _classes.cvar.Unit_CARAT
Unit.OUNCE = _classes.cvar.Unit_OUNCE
Unit.TROY_OUNCE = _classes.cvar.Unit_TROY_OUNCE
Unit.POUND = _classes.cvar.Unit_POUND
Unit.PENNYWEIGHT = _classes.cvar.Unit_PENNYWEIGHT
Unit.GRAIN = _classes.cvar.Unit_GRAIN
Unit.TAEL = _classes.cvar.Unit_TAEL
Unit.MOMME = _classes.cvar.Unit_MOMME
Unit.TOLA = _classes.cvar.Unit_TOLA
Unit.PIECE = _classes.cvar.Unit_PIECE

class QuantityFlag(EnumValueQuantityFlag):
    """Flag applied to measured quantity."""

    __swig_setmethods__ = {}
    for _s in [EnumValueQuantityFlag]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuantityFlag, name, value)
    __swig_getmethods__ = {}
    for _s in [EnumValueQuantityFlag]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, QuantityFlag, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    if _newclass:
        flags_from_mask = staticmethod(_classes.QuantityFlag_flags_from_mask)
    else:
        flags_from_mask = _classes.QuantityFlag_flags_from_mask
    if _newclass:
        mask_from_flags = staticmethod(_classes.QuantityFlag_mask_from_flags)
    else:
        mask_from_flags = _classes.QuantityFlag_mask_from_flags

        ## @brief Voltage measurement is alternating current (AC).
    AC = None
    ## @brief Voltage measurement is direct current (DC).
    DC = None
    ## @brief This is a true RMS measurement.
    RMS = None
    ## @brief Value is voltage drop across a diode, or NAN.
    DIODE = None
    ## @brief Device is in \"hold\" mode (repeating the last measurement).
    HOLD = None
    ## @brief Device is in \"max\" mode, only updating upon a new max value.
    MAX = None
    ## @brief Device is in \"min\" mode, only updating upon a new min value.
    MIN = None
    ## @brief Device is in autoranging mode.
    AUTORANGE = None
    ## @brief Device is in relative mode.
    RELATIVE = None
    ## @brief Sound pressure level is A-weighted in the frequency domain, according to IEC 61672:2003.
    SPL_FREQ_WEIGHT_A = None
    ## @brief Sound pressure level is C-weighted in the frequency domain, according to IEC 61672:2003.
    SPL_FREQ_WEIGHT_C = None
    ## @brief Sound pressure level is Z-weighted (i.e.
    SPL_FREQ_WEIGHT_Z = None
    ## @brief Sound pressure level is not weighted in the frequency domain, albeit without standards-defined low and high frequency limits.
    SPL_FREQ_WEIGHT_FLAT = None
    ## @brief Sound pressure level measurement is S-weighted (1s) in the time domain.
    SPL_TIME_WEIGHT_S = None
    ## @brief Sound pressure level measurement is F-weighted (125ms) in the time domain.
    SPL_TIME_WEIGHT_F = None
    ## @brief Sound pressure level is time-averaged (LAT), also known as Equivalent Continuous A-weighted Sound Level (LEQ).
    SPL_LAT = None
    ## @brief Sound pressure level represented as a percentage of measurements that were over a preset alarm level.
    SPL_PCT_OVER_ALARM = None
    ## @brief Time is duration (as opposed to epoch, ...).
    DURATION = None
    ## @brief Device is in \"avg\" mode, averaging upon each new value.
    AVG = None
    ## @brief Reference value shown.
    REFERENCE = None
    ## @brief Unstable value (hasn't settled yet).
    UNSTABLE = None
    ## @brief Measurement is four wire (e.g.
    FOUR_WIRE = None

    __swig_getmethods__["id"] = _classes.QuantityFlag_id_get
    if _newclass:
        id = _swig_property(_classes.QuantityFlag_id_get)
    __swig_getmethods__["name"] = _classes.QuantityFlag_name_get
    if _newclass:
        name = _swig_property(_classes.QuantityFlag_name_get)

    def __hash__(self):
        return _classes.QuantityFlag___hash__(self)

    def __str__(self):
        return _classes.QuantityFlag___str__(self)

    def __repr__(self):
        return _classes.QuantityFlag___repr__(self)

    def __eq__(self, other):
      return (type(self) is type(other) and hash(self) == hash(other))

    def __ne__(self, other):
      return (type(self) is not type(other) or hash(self) != hash(other))

    __swig_destroy__ = _classes.delete_QuantityFlag
    __del__ = lambda self: None
QuantityFlag_swigregister = _classes.QuantityFlag_swigregister
QuantityFlag_swigregister(QuantityFlag)
QuantityFlag.AC = _classes.cvar.QuantityFlag_AC
QuantityFlag.DC = _classes.cvar.QuantityFlag_DC
QuantityFlag.RMS = _classes.cvar.QuantityFlag_RMS
QuantityFlag.DIODE = _classes.cvar.QuantityFlag_DIODE
QuantityFlag.HOLD = _classes.cvar.QuantityFlag_HOLD
QuantityFlag.MAX = _classes.cvar.QuantityFlag_MAX
QuantityFlag.MIN = _classes.cvar.QuantityFlag_MIN
QuantityFlag.AUTORANGE = _classes.cvar.QuantityFlag_AUTORANGE
QuantityFlag.RELATIVE = _classes.cvar.QuantityFlag_RELATIVE
QuantityFlag.SPL_FREQ_WEIGHT_A = _classes.cvar.QuantityFlag_SPL_FREQ_WEIGHT_A
QuantityFlag.SPL_FREQ_WEIGHT_C = _classes.cvar.QuantityFlag_SPL_FREQ_WEIGHT_C
QuantityFlag.SPL_FREQ_WEIGHT_Z = _classes.cvar.QuantityFlag_SPL_FREQ_WEIGHT_Z
QuantityFlag.SPL_FREQ_WEIGHT_FLAT = _classes.cvar.QuantityFlag_SPL_FREQ_WEIGHT_FLAT
QuantityFlag.SPL_TIME_WEIGHT_S = _classes.cvar.QuantityFlag_SPL_TIME_WEIGHT_S
QuantityFlag.SPL_TIME_WEIGHT_F = _classes.cvar.QuantityFlag_SPL_TIME_WEIGHT_F
QuantityFlag.SPL_LAT = _classes.cvar.QuantityFlag_SPL_LAT
QuantityFlag.SPL_PCT_OVER_ALARM = _classes.cvar.QuantityFlag_SPL_PCT_OVER_ALARM
QuantityFlag.DURATION = _classes.cvar.QuantityFlag_DURATION
QuantityFlag.AVG = _classes.cvar.QuantityFlag_AVG
QuantityFlag.REFERENCE = _classes.cvar.QuantityFlag_REFERENCE
QuantityFlag.UNSTABLE = _classes.cvar.QuantityFlag_UNSTABLE
QuantityFlag.FOUR_WIRE = _classes.cvar.QuantityFlag_FOUR_WIRE

def QuantityFlag_flags_from_mask(mask):
    return _classes.QuantityFlag_flags_from_mask(mask)
QuantityFlag_flags_from_mask = _classes.QuantityFlag_flags_from_mask

def QuantityFlag_mask_from_flags(flags):
    return _classes.QuantityFlag_mask_from_flags(flags)
QuantityFlag_mask_from_flags = _classes.QuantityFlag_mask_from_flags

class TriggerMatchType(EnumValueTriggerMatchType):
    """Trigger match type."""

    __swig_setmethods__ = {}
    for _s in [EnumValueTriggerMatchType]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TriggerMatchType, name, value)
    __swig_getmethods__ = {}
    for _s in [EnumValueTriggerMatchType]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TriggerMatchType, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __swig_getmethods__["id"] = _classes.TriggerMatchType_id_get
    if _newclass:
        id = _swig_property(_classes.TriggerMatchType_id_get)
    __swig_getmethods__["name"] = _classes.TriggerMatchType_name_get
    if _newclass:
        name = _swig_property(_classes.TriggerMatchType_name_get)

    def __hash__(self):
        return _classes.TriggerMatchType___hash__(self)

    def __str__(self):
        return _classes.TriggerMatchType___str__(self)

    def __repr__(self):
        return _classes.TriggerMatchType___repr__(self)

    def __eq__(self, other):
      return (type(self) is type(other) and hash(self) == hash(other))

    def __ne__(self, other):
      return (type(self) is not type(other) or hash(self) != hash(other))

    __swig_destroy__ = _classes.delete_TriggerMatchType
    __del__ = lambda self: None
TriggerMatchType_swigregister = _classes.TriggerMatchType_swigregister
TriggerMatchType_swigregister(TriggerMatchType)
TriggerMatchType.ZERO = _classes.cvar.TriggerMatchType_ZERO
TriggerMatchType.ONE = _classes.cvar.TriggerMatchType_ONE
TriggerMatchType.RISING = _classes.cvar.TriggerMatchType_RISING
TriggerMatchType.FALLING = _classes.cvar.TriggerMatchType_FALLING
TriggerMatchType.EDGE = _classes.cvar.TriggerMatchType_EDGE
TriggerMatchType.OVER = _classes.cvar.TriggerMatchType_OVER
TriggerMatchType.UNDER = _classes.cvar.TriggerMatchType_UNDER

class OutputFlag(EnumValueOutputFlag):
    """Flag applied to output modules."""

    __swig_setmethods__ = {}
    for _s in [EnumValueOutputFlag]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutputFlag, name, value)
    __swig_getmethods__ = {}
    for _s in [EnumValueOutputFlag]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutputFlag, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")

        ## @brief If set, this output module writes the output itself.
    INTERNAL_IO_HANDLING = None

    __swig_getmethods__["id"] = _classes.OutputFlag_id_get
    if _newclass:
        id = _swig_property(_classes.OutputFlag_id_get)
    __swig_getmethods__["name"] = _classes.OutputFlag_name_get
    if _newclass:
        name = _swig_property(_classes.OutputFlag_name_get)

    def __hash__(self):
        return _classes.OutputFlag___hash__(self)

    def __str__(self):
        return _classes.OutputFlag___str__(self)

    def __repr__(self):
        return _classes.OutputFlag___repr__(self)

    def __eq__(self, other):
      return (type(self) is type(other) and hash(self) == hash(other))

    def __ne__(self, other):
      return (type(self) is not type(other) or hash(self) != hash(other))

    __swig_destroy__ = _classes.delete_OutputFlag
    __del__ = lambda self: None
OutputFlag_swigregister = _classes.OutputFlag_swigregister
OutputFlag_swigregister(OutputFlag)
OutputFlag.INTERNAL_IO_HANDLING = _classes.cvar.OutputFlag_INTERNAL_IO_HANDLING

class ChannelType(EnumValueChannelType):
    """Channel type."""

    __swig_setmethods__ = {}
    for _s in [EnumValueChannelType]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChannelType, name, value)
    __swig_getmethods__ = {}
    for _s in [EnumValueChannelType]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChannelType, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")

        ## @brief Channel type is logic channel.
    LOGIC = None
    ## @brief Channel type is analog channel.
    ANALOG = None

    __swig_getmethods__["id"] = _classes.ChannelType_id_get
    if _newclass:
        id = _swig_property(_classes.ChannelType_id_get)
    __swig_getmethods__["name"] = _classes.ChannelType_name_get
    if _newclass:
        name = _swig_property(_classes.ChannelType_name_get)

    def __hash__(self):
        return _classes.ChannelType___hash__(self)

    def __str__(self):
        return _classes.ChannelType___str__(self)

    def __repr__(self):
        return _classes.ChannelType___repr__(self)

    def __eq__(self, other):
      return (type(self) is type(other) and hash(self) == hash(other))

    def __ne__(self, other):
      return (type(self) is not type(other) or hash(self) != hash(other))

    __swig_destroy__ = _classes.delete_ChannelType
    __del__ = lambda self: None
ChannelType_swigregister = _classes.ChannelType_swigregister
ChannelType_swigregister(ChannelType)
ChannelType.LOGIC = _classes.cvar.ChannelType_LOGIC
ChannelType.ANALOG = _classes.cvar.ChannelType_ANALOG

class Capability(EnumValueCapability):
    """Configuration capability."""

    __swig_setmethods__ = {}
    for _s in [EnumValueCapability]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Capability, name, value)
    __swig_getmethods__ = {}
    for _s in [EnumValueCapability]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Capability, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")

        ## @brief Value can be read.
    GET = None
    ## @brief Value can be written.
    SET = None
    ## @brief Possible values can be enumerated.
    LIST = None

    __swig_getmethods__["id"] = _classes.Capability_id_get
    if _newclass:
        id = _swig_property(_classes.Capability_id_get)
    __swig_getmethods__["name"] = _classes.Capability_name_get
    if _newclass:
        name = _swig_property(_classes.Capability_name_get)

    def __hash__(self):
        return _classes.Capability___hash__(self)

    def __str__(self):
        return _classes.Capability___str__(self)

    def __repr__(self):
        return _classes.Capability___repr__(self)

    def __eq__(self, other):
      return (type(self) is type(other) and hash(self) == hash(other))

    def __ne__(self, other):
      return (type(self) is not type(other) or hash(self) != hash(other))

    __swig_destroy__ = _classes.delete_Capability
    __del__ = lambda self: None
Capability_swigregister = _classes.Capability_swigregister
Capability_swigregister(Capability)
Capability.GET = _classes.cvar.Capability_GET
Capability.SET = _classes.cvar.Capability_SET
Capability.LIST = _classes.cvar.Capability_LIST

class ConfigKey(EnumValueConfigKey):
    """Configuration key."""

    __swig_setmethods__ = {}
    for _s in [EnumValueConfigKey]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfigKey, name, value)
    __swig_getmethods__ = {}
    for _s in [EnumValueConfigKey]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConfigKey, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")

    def data_type(self):
        """Data type used for this configuration key."""
        return _classes.ConfigKey_data_type(self)


    def description(self):
        """Description of this configuration key."""
        return _classes.ConfigKey_description(self)

    if _newclass:
        get_by_identifier = staticmethod(_classes.ConfigKey_get_by_identifier)
    else:
        get_by_identifier = _classes.ConfigKey_get_by_identifier

    def parse_string(self, *args):
        return _classes.ConfigKey_parse_string(self, *args)

        ## @brief The device can act as logic analyzer.
    LOGIC_ANALYZER = None
    ## @brief The device can act as an oscilloscope.
    OSCILLOSCOPE = None
    ## @brief The device can act as a multimeter.
    MULTIMETER = None
    ## @brief The device is a demo device.
    DEMO_DEV = None
    ## @brief The device can act as a sound level meter.
    SOUNDLEVELMETER = None
    ## @brief The device can measure temperature.
    THERMOMETER = None
    ## @brief The device can measure humidity.
    HYGROMETER = None
    ## @brief The device can measure energy consumption.
    ENERGYMETER = None
    ## @brief The device can act as a signal demodulator.
    DEMODULATOR = None
    ## @brief The device can act as a programmable power supply.
    POWER_SUPPLY = None
    ## @brief The device can act as an LCR meter.
    LCRMETER = None
    ## @brief The device can act as an electronic load.
    ELECTRONIC_LOAD = None
    ## @brief The device can act as a scale.
    SCALE = None
    ## @brief The device can act as a function generator.
    SIGNAL_GENERATOR = None
    ## @brief The device can measure power.
    POWERMETER = None
    ## @brief Specification on how to connect to a device.
    CONN = None
    ## @brief Serial communication specification, in the form:
    SERIALCOMM = None
    ## @brief Modbus slave address specification.
    MODBUSADDR = None
    ## @brief The device supports setting its samplerate, in Hz.
    SAMPLERATE = None
    ## @brief The device supports setting a pre/post-trigger capture ratio.
    CAPTURE_RATIO = None
    ## @brief The device supports setting a pattern (pattern generator mode).
    PATTERN_MODE = None
    ## @brief The device supports run-length encoding (RLE).
    RLE = None
    ## @brief The device supports setting trigger slope.
    TRIGGER_SLOPE = None
    ## @brief The device supports averaging.
    AVERAGING = None
    ## @brief The device supports setting number of samples to be averaged over.
    AVG_SAMPLES = None
    ## @brief Trigger source.
    TRIGGER_SOURCE = None
    ## @brief Horizontal trigger position.
    HORIZ_TRIGGERPOS = None
    ## @brief Buffer size.
    BUFFERSIZE = None
    ## @brief Time base.
    TIMEBASE = None
    ## @brief Filter.
    FILTER = None
    ## @brief Volts/div.
    VDIV = None
    ## @brief Coupling.
    COUPLING = None
    ## @brief Trigger matches.
    TRIGGER_MATCH = None
    ## @brief The device supports setting its sample interval, in ms.
    SAMPLE_INTERVAL = None
    ## @brief Number of horizontal divisions, as related to SR_CONF_TIMEBASE.
    NUM_HDIV = None
    ## @brief Number of vertical divisions, as related to SR_CONF_VDIV.
    NUM_VDIV = None
    ## @brief Sound pressure level frequency weighting.
    SPL_WEIGHT_FREQ = None
    ## @brief Sound pressure level time weighting.
    SPL_WEIGHT_TIME = None
    ## @brief Sound pressure level measurement range.
    SPL_MEASUREMENT_RANGE = None
    ## @brief Max hold mode.
    HOLD_MAX = None
    ## @brief Min hold mode.
    HOLD_MIN = None
    ## @brief Logic low-high threshold range.
    VOLTAGE_THRESHOLD = None
    ## @brief The device supports using an external clock.
    EXTERNAL_CLOCK = None
    ## @brief The device supports swapping channels.
    SWAP = None
    ## @brief Center frequency.
    CENTER_FREQUENCY = None
    ## @brief The device supports setting the number of logic channels.
    NUM_LOGIC_CHANNELS = None
    ## @brief The device supports setting the number of analog channels.
    NUM_ANALOG_CHANNELS = None
    ## @brief Current voltage.
    VOLTAGE = None
    ## @brief Maximum target voltage.
    VOLTAGE_TARGET = None
    ## @brief Current current.
    CURRENT = None
    ## @brief Current limit.
    CURRENT_LIMIT = None
    ## @brief Enabling/disabling channel.
    ENABLED = None
    ## @brief Channel configuration.
    CHANNEL_CONFIG = None
    ## @brief Over-voltage protection (OVP) feature.
    OVER_VOLTAGE_PROTECTION_ENABLED = None
    ## @brief Over-voltage protection (OVP) active.
    OVER_VOLTAGE_PROTECTION_ACTIVE = None
    ## @brief Over-voltage protection (OVP) threshold.
    OVER_VOLTAGE_PROTECTION_THRESHOLD = None
    ## @brief Over-current protection (OCP) feature.
    OVER_CURRENT_PROTECTION_ENABLED = None
    ## @brief Over-current protection (OCP) active.
    OVER_CURRENT_PROTECTION_ACTIVE = None
    ## @brief Over-current protection (OCP) threshold.
    OVER_CURRENT_PROTECTION_THRESHOLD = None
    ## @brief Choice of clock edge for external clock (\"r\" or \"f\").
    CLOCK_EDGE = None
    ## @brief Amplitude of a source without strictly-defined MQ.
    AMPLITUDE = None
    ## @brief Channel regulation get: \"CV\", \"CC\" or \"UR\", denoting constant voltage, constant current or unregulated.
    REGULATION = None
    ## @brief Over-temperature protection (OTP)
    OVER_TEMPERATURE_PROTECTION = None
    ## @brief Output frequency in Hz.
    OUTPUT_FREQUENCY = None
    ## @brief Output frequency target in Hz.
    OUTPUT_FREQUENCY_TARGET = None
    ## @brief Measured quantity.
    MEASURED_QUANTITY = None
    ## @brief Equivalent circuit model.
    EQUIV_CIRCUIT_MODEL = None
    ## @brief Over-temperature protection (OTP) active.
    OVER_TEMPERATURE_PROTECTION_ACTIVE = None
    ## @brief Under-voltage condition.
    UNDER_VOLTAGE_CONDITION = None
    ## @brief Under-voltage condition active.
    UNDER_VOLTAGE_CONDITION_ACTIVE = None
    ## @brief Trigger level.
    TRIGGER_LEVEL = None
    ## @brief Under-voltage condition threshold.
    UNDER_VOLTAGE_CONDITION_THRESHOLD = None
    ## @brief Which external clock source to use if the device supports multiple external clock channels.
    EXTERNAL_CLOCK_SOURCE = None
    ## @brief Session filename.
    SESSIONFILE = None
    ## @brief The device supports specifying a capturefile to inject.
    CAPTUREFILE = None
    ## @brief The device supports specifying the capturefile unit size.
    CAPTURE_UNITSIZE = None
    ## @brief Power off the device.
    POWER_OFF = None
    ## @brief Data source for acquisition.
    DATA_SOURCE = None
    ## @brief The device supports setting a probe factor.
    PROBE_FACTOR = None
    ## @brief Number of powerline cycles for ADC integration time.
    ADC_POWERLINE_CYCLES = None
    ## @brief The device supports setting a sample time limit (how long the sample acquisition should run, in ms).
    LIMIT_MSEC = None
    ## @brief The device supports setting a sample number limit (how many samples should be acquired).
    LIMIT_SAMPLES = None
    ## @brief The device supports setting a frame limit (how many frames should be acquired).
    LIMIT_FRAMES = None
    ## @brief The device supports continuous sampling.
    CONTINUOUS = None
    ## @brief The device has internal storage, into which data is logged.
    DATALOG = None
    ## @brief Device mode for multi-function devices.
    DEVICE_MODE = None
    ## @brief Self test mode.
    TEST_MODE = None

    __swig_getmethods__["id"] = _classes.ConfigKey_id_get
    if _newclass:
        id = _swig_property(_classes.ConfigKey_id_get)
    __swig_getmethods__["name"] = _classes.ConfigKey_name_get
    if _newclass:
        name = _swig_property(_classes.ConfigKey_name_get)

    def __hash__(self):
        return _classes.ConfigKey___hash__(self)

    def __str__(self):
        return _classes.ConfigKey___str__(self)

    def __repr__(self):
        return _classes.ConfigKey___repr__(self)

    def __eq__(self, other):
      return (type(self) is type(other) and hash(self) == hash(other))

    def __ne__(self, other):
      return (type(self) is not type(other) or hash(self) != hash(other))

    __swig_getmethods__["identifier"] = _classes.ConfigKey_identifier_get
    if _newclass:
        identifier = _swig_property(_classes.ConfigKey_identifier_get)
    __swig_destroy__ = _classes.delete_ConfigKey
    __del__ = lambda self: None
ConfigKey_swigregister = _classes.ConfigKey_swigregister
ConfigKey_swigregister(ConfigKey)
ConfigKey.LOGIC_ANALYZER = _classes.cvar.ConfigKey_LOGIC_ANALYZER
ConfigKey.OSCILLOSCOPE = _classes.cvar.ConfigKey_OSCILLOSCOPE
ConfigKey.MULTIMETER = _classes.cvar.ConfigKey_MULTIMETER
ConfigKey.DEMO_DEV = _classes.cvar.ConfigKey_DEMO_DEV
ConfigKey.SOUNDLEVELMETER = _classes.cvar.ConfigKey_SOUNDLEVELMETER
ConfigKey.THERMOMETER = _classes.cvar.ConfigKey_THERMOMETER
ConfigKey.HYGROMETER = _classes.cvar.ConfigKey_HYGROMETER
ConfigKey.ENERGYMETER = _classes.cvar.ConfigKey_ENERGYMETER
ConfigKey.DEMODULATOR = _classes.cvar.ConfigKey_DEMODULATOR
ConfigKey.POWER_SUPPLY = _classes.cvar.ConfigKey_POWER_SUPPLY
ConfigKey.LCRMETER = _classes.cvar.ConfigKey_LCRMETER
ConfigKey.ELECTRONIC_LOAD = _classes.cvar.ConfigKey_ELECTRONIC_LOAD
ConfigKey.SCALE = _classes.cvar.ConfigKey_SCALE
ConfigKey.SIGNAL_GENERATOR = _classes.cvar.ConfigKey_SIGNAL_GENERATOR
ConfigKey.POWERMETER = _classes.cvar.ConfigKey_POWERMETER
ConfigKey.CONN = _classes.cvar.ConfigKey_CONN
ConfigKey.SERIALCOMM = _classes.cvar.ConfigKey_SERIALCOMM
ConfigKey.MODBUSADDR = _classes.cvar.ConfigKey_MODBUSADDR
ConfigKey.SAMPLERATE = _classes.cvar.ConfigKey_SAMPLERATE
ConfigKey.CAPTURE_RATIO = _classes.cvar.ConfigKey_CAPTURE_RATIO
ConfigKey.PATTERN_MODE = _classes.cvar.ConfigKey_PATTERN_MODE
ConfigKey.RLE = _classes.cvar.ConfigKey_RLE
ConfigKey.TRIGGER_SLOPE = _classes.cvar.ConfigKey_TRIGGER_SLOPE
ConfigKey.AVERAGING = _classes.cvar.ConfigKey_AVERAGING
ConfigKey.AVG_SAMPLES = _classes.cvar.ConfigKey_AVG_SAMPLES
ConfigKey.TRIGGER_SOURCE = _classes.cvar.ConfigKey_TRIGGER_SOURCE
ConfigKey.HORIZ_TRIGGERPOS = _classes.cvar.ConfigKey_HORIZ_TRIGGERPOS
ConfigKey.BUFFERSIZE = _classes.cvar.ConfigKey_BUFFERSIZE
ConfigKey.TIMEBASE = _classes.cvar.ConfigKey_TIMEBASE
ConfigKey.FILTER = _classes.cvar.ConfigKey_FILTER
ConfigKey.VDIV = _classes.cvar.ConfigKey_VDIV
ConfigKey.COUPLING = _classes.cvar.ConfigKey_COUPLING
ConfigKey.TRIGGER_MATCH = _classes.cvar.ConfigKey_TRIGGER_MATCH
ConfigKey.SAMPLE_INTERVAL = _classes.cvar.ConfigKey_SAMPLE_INTERVAL
ConfigKey.NUM_HDIV = _classes.cvar.ConfigKey_NUM_HDIV
ConfigKey.NUM_VDIV = _classes.cvar.ConfigKey_NUM_VDIV
ConfigKey.SPL_WEIGHT_FREQ = _classes.cvar.ConfigKey_SPL_WEIGHT_FREQ
ConfigKey.SPL_WEIGHT_TIME = _classes.cvar.ConfigKey_SPL_WEIGHT_TIME
ConfigKey.SPL_MEASUREMENT_RANGE = _classes.cvar.ConfigKey_SPL_MEASUREMENT_RANGE
ConfigKey.HOLD_MAX = _classes.cvar.ConfigKey_HOLD_MAX
ConfigKey.HOLD_MIN = _classes.cvar.ConfigKey_HOLD_MIN
ConfigKey.VOLTAGE_THRESHOLD = _classes.cvar.ConfigKey_VOLTAGE_THRESHOLD
ConfigKey.EXTERNAL_CLOCK = _classes.cvar.ConfigKey_EXTERNAL_CLOCK
ConfigKey.SWAP = _classes.cvar.ConfigKey_SWAP
ConfigKey.CENTER_FREQUENCY = _classes.cvar.ConfigKey_CENTER_FREQUENCY
ConfigKey.NUM_LOGIC_CHANNELS = _classes.cvar.ConfigKey_NUM_LOGIC_CHANNELS
ConfigKey.NUM_ANALOG_CHANNELS = _classes.cvar.ConfigKey_NUM_ANALOG_CHANNELS
ConfigKey.VOLTAGE = _classes.cvar.ConfigKey_VOLTAGE
ConfigKey.VOLTAGE_TARGET = _classes.cvar.ConfigKey_VOLTAGE_TARGET
ConfigKey.CURRENT = _classes.cvar.ConfigKey_CURRENT
ConfigKey.CURRENT_LIMIT = _classes.cvar.ConfigKey_CURRENT_LIMIT
ConfigKey.ENABLED = _classes.cvar.ConfigKey_ENABLED
ConfigKey.CHANNEL_CONFIG = _classes.cvar.ConfigKey_CHANNEL_CONFIG
ConfigKey.OVER_VOLTAGE_PROTECTION_ENABLED = _classes.cvar.ConfigKey_OVER_VOLTAGE_PROTECTION_ENABLED
ConfigKey.OVER_VOLTAGE_PROTECTION_ACTIVE = _classes.cvar.ConfigKey_OVER_VOLTAGE_PROTECTION_ACTIVE
ConfigKey.OVER_VOLTAGE_PROTECTION_THRESHOLD = _classes.cvar.ConfigKey_OVER_VOLTAGE_PROTECTION_THRESHOLD
ConfigKey.OVER_CURRENT_PROTECTION_ENABLED = _classes.cvar.ConfigKey_OVER_CURRENT_PROTECTION_ENABLED
ConfigKey.OVER_CURRENT_PROTECTION_ACTIVE = _classes.cvar.ConfigKey_OVER_CURRENT_PROTECTION_ACTIVE
ConfigKey.OVER_CURRENT_PROTECTION_THRESHOLD = _classes.cvar.ConfigKey_OVER_CURRENT_PROTECTION_THRESHOLD
ConfigKey.CLOCK_EDGE = _classes.cvar.ConfigKey_CLOCK_EDGE
ConfigKey.AMPLITUDE = _classes.cvar.ConfigKey_AMPLITUDE
ConfigKey.REGULATION = _classes.cvar.ConfigKey_REGULATION
ConfigKey.OVER_TEMPERATURE_PROTECTION = _classes.cvar.ConfigKey_OVER_TEMPERATURE_PROTECTION
ConfigKey.OUTPUT_FREQUENCY = _classes.cvar.ConfigKey_OUTPUT_FREQUENCY
ConfigKey.OUTPUT_FREQUENCY_TARGET = _classes.cvar.ConfigKey_OUTPUT_FREQUENCY_TARGET
ConfigKey.MEASURED_QUANTITY = _classes.cvar.ConfigKey_MEASURED_QUANTITY
ConfigKey.EQUIV_CIRCUIT_MODEL = _classes.cvar.ConfigKey_EQUIV_CIRCUIT_MODEL
ConfigKey.OVER_TEMPERATURE_PROTECTION_ACTIVE = _classes.cvar.ConfigKey_OVER_TEMPERATURE_PROTECTION_ACTIVE
ConfigKey.UNDER_VOLTAGE_CONDITION = _classes.cvar.ConfigKey_UNDER_VOLTAGE_CONDITION
ConfigKey.UNDER_VOLTAGE_CONDITION_ACTIVE = _classes.cvar.ConfigKey_UNDER_VOLTAGE_CONDITION_ACTIVE
ConfigKey.TRIGGER_LEVEL = _classes.cvar.ConfigKey_TRIGGER_LEVEL
ConfigKey.UNDER_VOLTAGE_CONDITION_THRESHOLD = _classes.cvar.ConfigKey_UNDER_VOLTAGE_CONDITION_THRESHOLD
ConfigKey.EXTERNAL_CLOCK_SOURCE = _classes.cvar.ConfigKey_EXTERNAL_CLOCK_SOURCE
ConfigKey.SESSIONFILE = _classes.cvar.ConfigKey_SESSIONFILE
ConfigKey.CAPTUREFILE = _classes.cvar.ConfigKey_CAPTUREFILE
ConfigKey.CAPTURE_UNITSIZE = _classes.cvar.ConfigKey_CAPTURE_UNITSIZE
ConfigKey.POWER_OFF = _classes.cvar.ConfigKey_POWER_OFF
ConfigKey.DATA_SOURCE = _classes.cvar.ConfigKey_DATA_SOURCE
ConfigKey.PROBE_FACTOR = _classes.cvar.ConfigKey_PROBE_FACTOR
ConfigKey.ADC_POWERLINE_CYCLES = _classes.cvar.ConfigKey_ADC_POWERLINE_CYCLES
ConfigKey.LIMIT_MSEC = _classes.cvar.ConfigKey_LIMIT_MSEC
ConfigKey.LIMIT_SAMPLES = _classes.cvar.ConfigKey_LIMIT_SAMPLES
ConfigKey.LIMIT_FRAMES = _classes.cvar.ConfigKey_LIMIT_FRAMES
ConfigKey.CONTINUOUS = _classes.cvar.ConfigKey_CONTINUOUS
ConfigKey.DATALOG = _classes.cvar.ConfigKey_DATALOG
ConfigKey.DEVICE_MODE = _classes.cvar.ConfigKey_DEVICE_MODE
ConfigKey.TEST_MODE = _classes.cvar.ConfigKey_TEST_MODE

def ConfigKey_get_by_identifier(identifier):
    return _classes.ConfigKey_get_by_identifier(identifier)
ConfigKey_get_by_identifier = _classes.ConfigKey_get_by_identifier


def _Driver_scan(self, **kwargs):
    return self._scan_kwargs(kwargs)

Driver.scan = _Driver_scan


def _InputFormat_create_input(self, **kwargs):
    return self._create_input(kwargs)

InputFormat.create_input = _InputFormat_create_input


def _OutputFormat_create_output(self, device, **kwargs):
    return self._create_output_kwargs(device, kwargs)

OutputFormat.create_output = _OutputFormat_create_output


Capability.GET.__doc__ = """Value can be read."""
Capability.SET.__doc__ = """Value can be written."""
Capability.LIST.__doc__ = """Possible values can be enumerated."""


ChannelType.LOGIC.__doc__ = """Channel type is logic channel."""
ChannelType.ANALOG.__doc__ = """Channel type is analog channel."""


ConfigKey.LOGIC_ANALYZER.__doc__ = """The device can act as logic analyzer."""
ConfigKey.OSCILLOSCOPE.__doc__ = """The device can act as an oscilloscope."""
ConfigKey.MULTIMETER.__doc__ = """The device can act as a multimeter."""
ConfigKey.DEMO_DEV.__doc__ = """The device is a demo device."""
ConfigKey.SOUNDLEVELMETER.__doc__ = """The device can act as a sound level meter."""
ConfigKey.THERMOMETER.__doc__ = """The device can measure temperature."""
ConfigKey.HYGROMETER.__doc__ = """The device can measure humidity."""
ConfigKey.ENERGYMETER.__doc__ = """The device can measure energy consumption."""
ConfigKey.DEMODULATOR.__doc__ = """The device can act as a signal demodulator."""
ConfigKey.POWER_SUPPLY.__doc__ = """The device can act as a programmable power supply."""
ConfigKey.LCRMETER.__doc__ = """The device can act as an LCR meter."""
ConfigKey.ELECTRONIC_LOAD.__doc__ = """The device can act as an electronic load."""
ConfigKey.SCALE.__doc__ = """The device can act as a scale."""
ConfigKey.SIGNAL_GENERATOR.__doc__ = """The device can act as a function generator."""
ConfigKey.POWERMETER.__doc__ = """The device can measure power."""
ConfigKey.CONN.__doc__ = """Specification on how to connect to a device."""
ConfigKey.SERIALCOMM.__doc__ = """Serial communication specification, in the form:"""
ConfigKey.MODBUSADDR.__doc__ = """Modbus slave address specification."""
ConfigKey.SAMPLERATE.__doc__ = """The device supports setting its samplerate, in Hz."""
ConfigKey.CAPTURE_RATIO.__doc__ = """The device supports setting a pre/post-trigger capture ratio."""
ConfigKey.PATTERN_MODE.__doc__ = """The device supports setting a pattern (pattern generator mode)."""
ConfigKey.RLE.__doc__ = """The device supports run-length encoding (RLE)."""
ConfigKey.TRIGGER_SLOPE.__doc__ = """The device supports setting trigger slope."""
ConfigKey.AVERAGING.__doc__ = """The device supports averaging."""
ConfigKey.AVG_SAMPLES.__doc__ = """The device supports setting number of samples to be averaged over."""
ConfigKey.TRIGGER_SOURCE.__doc__ = """Trigger source."""
ConfigKey.HORIZ_TRIGGERPOS.__doc__ = """Horizontal trigger position."""
ConfigKey.BUFFERSIZE.__doc__ = """Buffer size."""
ConfigKey.TIMEBASE.__doc__ = """Time base."""
ConfigKey.FILTER.__doc__ = """Filter."""
ConfigKey.VDIV.__doc__ = """Volts/div."""
ConfigKey.COUPLING.__doc__ = """Coupling."""
ConfigKey.TRIGGER_MATCH.__doc__ = """Trigger matches."""
ConfigKey.SAMPLE_INTERVAL.__doc__ = """The device supports setting its sample interval, in ms."""
ConfigKey.NUM_HDIV.__doc__ = """Number of horizontal divisions, as related to SR_CONF_TIMEBASE."""
ConfigKey.NUM_VDIV.__doc__ = """Number of vertical divisions, as related to SR_CONF_VDIV."""
ConfigKey.SPL_WEIGHT_FREQ.__doc__ = """Sound pressure level frequency weighting."""
ConfigKey.SPL_WEIGHT_TIME.__doc__ = """Sound pressure level time weighting."""
ConfigKey.SPL_MEASUREMENT_RANGE.__doc__ = """Sound pressure level measurement range."""
ConfigKey.HOLD_MAX.__doc__ = """Max hold mode."""
ConfigKey.HOLD_MIN.__doc__ = """Min hold mode."""
ConfigKey.VOLTAGE_THRESHOLD.__doc__ = """Logic low-high threshold range."""
ConfigKey.EXTERNAL_CLOCK.__doc__ = """The device supports using an external clock."""
ConfigKey.SWAP.__doc__ = """The device supports swapping channels."""
ConfigKey.CENTER_FREQUENCY.__doc__ = """Center frequency."""
ConfigKey.NUM_LOGIC_CHANNELS.__doc__ = """The device supports setting the number of logic channels."""
ConfigKey.NUM_ANALOG_CHANNELS.__doc__ = """The device supports setting the number of analog channels."""
ConfigKey.VOLTAGE.__doc__ = """Current voltage."""
ConfigKey.VOLTAGE_TARGET.__doc__ = """Maximum target voltage."""
ConfigKey.CURRENT.__doc__ = """Current current."""
ConfigKey.CURRENT_LIMIT.__doc__ = """Current limit."""
ConfigKey.ENABLED.__doc__ = """Enabling/disabling channel."""
ConfigKey.CHANNEL_CONFIG.__doc__ = """Channel configuration."""
ConfigKey.OVER_VOLTAGE_PROTECTION_ENABLED.__doc__ = """Over-voltage protection (OVP) feature."""
ConfigKey.OVER_VOLTAGE_PROTECTION_ACTIVE.__doc__ = """Over-voltage protection (OVP) active."""
ConfigKey.OVER_VOLTAGE_PROTECTION_THRESHOLD.__doc__ = """Over-voltage protection (OVP) threshold."""
ConfigKey.OVER_CURRENT_PROTECTION_ENABLED.__doc__ = """Over-current protection (OCP) feature."""
ConfigKey.OVER_CURRENT_PROTECTION_ACTIVE.__doc__ = """Over-current protection (OCP) active."""
ConfigKey.OVER_CURRENT_PROTECTION_THRESHOLD.__doc__ = """Over-current protection (OCP) threshold."""
ConfigKey.CLOCK_EDGE.__doc__ = """Choice of clock edge for external clock (\"r\" or \"f\")."""
ConfigKey.AMPLITUDE.__doc__ = """Amplitude of a source without strictly-defined MQ."""
ConfigKey.REGULATION.__doc__ = """Channel regulation get: \"CV\", \"CC\" or \"UR\", denoting constant voltage, constant current or unregulated."""
ConfigKey.OVER_TEMPERATURE_PROTECTION.__doc__ = """Over-temperature protection (OTP)"""
ConfigKey.OUTPUT_FREQUENCY.__doc__ = """Output frequency in Hz."""
ConfigKey.OUTPUT_FREQUENCY_TARGET.__doc__ = """Output frequency target in Hz."""
ConfigKey.MEASURED_QUANTITY.__doc__ = """Measured quantity."""
ConfigKey.EQUIV_CIRCUIT_MODEL.__doc__ = """Equivalent circuit model."""
ConfigKey.OVER_TEMPERATURE_PROTECTION_ACTIVE.__doc__ = """Over-temperature protection (OTP) active."""
ConfigKey.UNDER_VOLTAGE_CONDITION.__doc__ = """Under-voltage condition."""
ConfigKey.UNDER_VOLTAGE_CONDITION_ACTIVE.__doc__ = """Under-voltage condition active."""
ConfigKey.TRIGGER_LEVEL.__doc__ = """Trigger level."""
ConfigKey.UNDER_VOLTAGE_CONDITION_THRESHOLD.__doc__ = """Under-voltage condition threshold."""
ConfigKey.EXTERNAL_CLOCK_SOURCE.__doc__ = """Which external clock source to use if the device supports multiple external clock channels."""
ConfigKey.SESSIONFILE.__doc__ = """Session filename."""
ConfigKey.CAPTUREFILE.__doc__ = """The device supports specifying a capturefile to inject."""
ConfigKey.CAPTURE_UNITSIZE.__doc__ = """The device supports specifying the capturefile unit size."""
ConfigKey.POWER_OFF.__doc__ = """Power off the device."""
ConfigKey.DATA_SOURCE.__doc__ = """Data source for acquisition."""
ConfigKey.PROBE_FACTOR.__doc__ = """The device supports setting a probe factor."""
ConfigKey.ADC_POWERLINE_CYCLES.__doc__ = """Number of powerline cycles for ADC integration time."""
ConfigKey.LIMIT_MSEC.__doc__ = """The device supports setting a sample time limit (how long the sample acquisition should run, in ms)."""
ConfigKey.LIMIT_SAMPLES.__doc__ = """The device supports setting a sample number limit (how many samples should be acquired)."""
ConfigKey.LIMIT_FRAMES.__doc__ = """The device supports setting a frame limit (how many frames should be acquired)."""
ConfigKey.CONTINUOUS.__doc__ = """The device supports continuous sampling."""
ConfigKey.DATALOG.__doc__ = """The device has internal storage, into which data is logged."""
ConfigKey.DEVICE_MODE.__doc__ = """Device mode for multi-function devices."""
ConfigKey.TEST_MODE.__doc__ = """Self test mode."""


LogLevel.NONE.__doc__ = """Output no messages at all."""
LogLevel.ERR.__doc__ = """Output error messages."""
LogLevel.WARN.__doc__ = """Output warnings."""
LogLevel.INFO.__doc__ = """Output informational messages."""
LogLevel.DBG.__doc__ = """Output debug messages."""
LogLevel.SPEW.__doc__ = """Output very noisy debug messages."""


OutputFlag.INTERNAL_IO_HANDLING.__doc__ = """If set, this output module writes the output itself."""


PacketType.HEADER.__doc__ = """Payload is."""
PacketType.END.__doc__ = """End of stream (no further data)."""
PacketType.META.__doc__ = """Payload is struct."""
PacketType.TRIGGER.__doc__ = """The trigger matched at this point in the data feed."""
PacketType.LOGIC.__doc__ = """Payload is struct."""
PacketType.FRAME_BEGIN.__doc__ = """Beginning of frame."""
PacketType.FRAME_END.__doc__ = """End of frame."""
PacketType.ANALOG.__doc__ = """Payload is struct."""


Quantity.DUTY_CYCLE.__doc__ = """Duty cycle, e.g."""
Quantity.CONTINUITY.__doc__ = """Continuity test."""
Quantity.POWER.__doc__ = """Electrical power, usually in W, or dBm."""
Quantity.GAIN.__doc__ = """Gain (a transistor's gain, or hFE, for example)."""
Quantity.SOUND_PRESSURE_LEVEL.__doc__ = """Logarithmic representation of sound pressure relative to a reference value."""
Quantity.CARBON_MONOXIDE.__doc__ = """Carbon monoxide level."""
Quantity.RELATIVE_HUMIDITY.__doc__ = """Humidity."""
Quantity.TIME.__doc__ = """Time."""
Quantity.WIND_SPEED.__doc__ = """Wind speed."""
Quantity.PRESSURE.__doc__ = """Pressure."""
Quantity.PARALLEL_INDUCTANCE.__doc__ = """Parallel inductance (LCR meter model)."""
Quantity.PARALLEL_CAPACITANCE.__doc__ = """Parallel capacitance (LCR meter model)."""
Quantity.PARALLEL_RESISTANCE.__doc__ = """Parallel resistance (LCR meter model)."""
Quantity.SERIES_INDUCTANCE.__doc__ = """Series inductance (LCR meter model)."""
Quantity.SERIES_CAPACITANCE.__doc__ = """Series capacitance (LCR meter model)."""
Quantity.SERIES_RESISTANCE.__doc__ = """Series resistance (LCR meter model)."""
Quantity.DISSIPATION_FACTOR.__doc__ = """Dissipation factor."""
Quantity.QUALITY_FACTOR.__doc__ = """Quality factor."""
Quantity.PHASE_ANGLE.__doc__ = """Phase angle."""
Quantity.DIFFERENCE.__doc__ = """Difference from reference value."""
Quantity.COUNT.__doc__ = """Count."""
Quantity.POWER_FACTOR.__doc__ = """Power factor."""
Quantity.APPARENT_POWER.__doc__ = """Apparent power."""
Quantity.MASS.__doc__ = """Mass."""
Quantity.HARMONIC_RATIO.__doc__ = """Harmonic ratio."""


QuantityFlag.AC.__doc__ = """Voltage measurement is alternating current (AC)."""
QuantityFlag.DC.__doc__ = """Voltage measurement is direct current (DC)."""
QuantityFlag.RMS.__doc__ = """This is a true RMS measurement."""
QuantityFlag.DIODE.__doc__ = """Value is voltage drop across a diode, or NAN."""
QuantityFlag.HOLD.__doc__ = """Device is in \"hold\" mode (repeating the last measurement)."""
QuantityFlag.MAX.__doc__ = """Device is in \"max\" mode, only updating upon a new max value."""
QuantityFlag.MIN.__doc__ = """Device is in \"min\" mode, only updating upon a new min value."""
QuantityFlag.AUTORANGE.__doc__ = """Device is in autoranging mode."""
QuantityFlag.RELATIVE.__doc__ = """Device is in relative mode."""
QuantityFlag.SPL_FREQ_WEIGHT_A.__doc__ = """Sound pressure level is A-weighted in the frequency domain, according to IEC 61672:2003."""
QuantityFlag.SPL_FREQ_WEIGHT_C.__doc__ = """Sound pressure level is C-weighted in the frequency domain, according to IEC 61672:2003."""
QuantityFlag.SPL_FREQ_WEIGHT_Z.__doc__ = """Sound pressure level is Z-weighted (i.e."""
QuantityFlag.SPL_FREQ_WEIGHT_FLAT.__doc__ = """Sound pressure level is not weighted in the frequency domain, albeit without standards-defined low and high frequency limits."""
QuantityFlag.SPL_TIME_WEIGHT_S.__doc__ = """Sound pressure level measurement is S-weighted (1s) in the time domain."""
QuantityFlag.SPL_TIME_WEIGHT_F.__doc__ = """Sound pressure level measurement is F-weighted (125ms) in the time domain."""
QuantityFlag.SPL_LAT.__doc__ = """Sound pressure level is time-averaged (LAT), also known as Equivalent Continuous A-weighted Sound Level (LEQ)."""
QuantityFlag.SPL_PCT_OVER_ALARM.__doc__ = """Sound pressure level represented as a percentage of measurements that were over a preset alarm level."""
QuantityFlag.DURATION.__doc__ = """Time is duration (as opposed to epoch, ...)."""
QuantityFlag.AVG.__doc__ = """Device is in \"avg\" mode, averaging upon each new value."""
QuantityFlag.REFERENCE.__doc__ = """Reference value shown."""
QuantityFlag.UNSTABLE.__doc__ = """Unstable value (hasn't settled yet)."""
QuantityFlag.FOUR_WIRE.__doc__ = """Measurement is four wire (e.g."""


Unit.VOLT.__doc__ = """Volt."""
Unit.AMPERE.__doc__ = """Ampere (current)."""
Unit.OHM.__doc__ = """Ohm (resistance)."""
Unit.FARAD.__doc__ = """Farad (capacity)."""
Unit.KELVIN.__doc__ = """Kelvin (temperature)."""
Unit.CELSIUS.__doc__ = """Degrees Celsius (temperature)."""
Unit.FAHRENHEIT.__doc__ = """Degrees Fahrenheit (temperature)."""
Unit.HERTZ.__doc__ = """Hertz (frequency, 1/s, [Hz])."""
Unit.PERCENTAGE.__doc__ = """Percent value."""
Unit.BOOLEAN.__doc__ = """Boolean value."""
Unit.SECOND.__doc__ = """Time in seconds."""
Unit.SIEMENS.__doc__ = """Unit of conductance, the inverse of resistance."""
Unit.DECIBEL_MW.__doc__ = """An absolute measurement of power, in decibels, referenced to 1 milliwatt (dBm)."""
Unit.DECIBEL_VOLT.__doc__ = """Voltage in decibel, referenced to 1 volt (dBV)."""
Unit.UNITLESS.__doc__ = """Measurements that intrinsically do not have units attached, such as ratios, gains, etc."""
Unit.DECIBEL_SPL.__doc__ = """Sound pressure level, in decibels, relative to 20 micropascals."""
Unit.CONCENTRATION.__doc__ = """Normalized (0 to 1) concentration of a substance or compound with 0 representing a concentration of 0%, and 1 being 100%."""
Unit.REVOLUTIONS_PER_MINUTE.__doc__ = """Revolutions per minute."""
Unit.VOLT_AMPERE.__doc__ = """Apparent power [VA]."""
Unit.WATT.__doc__ = """Real power [W]."""
Unit.WATT_HOUR.__doc__ = """Consumption [Wh]."""
Unit.METER_SECOND.__doc__ = """Wind speed in meters per second."""
Unit.HECTOPASCAL.__doc__ = """Pressure in hectopascal."""
Unit.HUMIDITY_293K.__doc__ = """Relative humidity assuming air temperature of 293 Kelvin (rF)."""
Unit.DEGREE.__doc__ = """Plane angle in 1/360th of a full circle."""
Unit.HENRY.__doc__ = """Henry (inductance)."""
Unit.GRAM.__doc__ = """Mass in gram [g]."""
Unit.CARAT.__doc__ = """Mass in carat [ct]."""
Unit.OUNCE.__doc__ = """Mass in ounce [oz]."""
Unit.TROY_OUNCE.__doc__ = """Mass in troy ounce [oz t]."""
Unit.POUND.__doc__ = """Mass in pound [lb]."""
Unit.PENNYWEIGHT.__doc__ = """Mass in pennyweight [dwt]."""
Unit.GRAIN.__doc__ = """Mass in grain [gr]."""
Unit.TAEL.__doc__ = """Mass in tael (variants: Hong Kong, Singapore/Malaysia, Taiwan)"""
Unit.MOMME.__doc__ = """Mass in momme."""
Unit.TOLA.__doc__ = """Mass in tola."""
Unit.PIECE.__doc__ = """Pieces (number of items)."""

# This file is compatible with both classic and new-style classes.


