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

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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class VectorI(object):
    r"""Proxy of C++ std::vector< int > class."""

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

    def iterator(self):
        r"""iterator(VectorI self) -> SwigPyIterator"""
        return _libm2k.VectorI_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorI self) -> bool"""
        return _libm2k.VectorI___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorI self) -> bool"""
        return _libm2k.VectorI___bool__(self)

    def __len__(self):
        r"""__len__(VectorI self) -> std::vector< int >::size_type"""
        return _libm2k.VectorI___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(VectorI self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> VectorI

        Parameters
        ----------
        i: std::vector< int >::difference_type
        j: std::vector< int >::difference_type

        """
        return _libm2k.VectorI___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorI self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)

        Parameters
        ----------
        i: std::vector< int >::difference_type
        j: std::vector< int >::difference_type

        __setslice__(VectorI self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, VectorI v)

        Parameters
        ----------
        i: std::vector< int >::difference_type
        j: std::vector< int >::difference_type
        v: std::vector< int,std::allocator< int > > const &

        """
        return _libm2k.VectorI___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(VectorI self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)

        Parameters
        ----------
        i: std::vector< int >::difference_type
        j: std::vector< int >::difference_type

        """
        return _libm2k.VectorI___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorI self, std::vector< int >::difference_type i)

        Parameters
        ----------
        i: std::vector< int >::difference_type

        __delitem__(VectorI self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.VectorI___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorI self, PySliceObject * slice) -> VectorI

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(VectorI self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &

        Parameters
        ----------
        i: std::vector< int >::difference_type

        """
        return _libm2k.VectorI___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorI self, PySliceObject * slice, VectorI v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< int,std::allocator< int > > const &

        __setitem__(VectorI self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(VectorI self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)

        Parameters
        ----------
        i: std::vector< int >::difference_type
        x: std::vector< int >::value_type const &

        """
        return _libm2k.VectorI___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorI self) -> std::vector< int >::value_type"""
        return _libm2k.VectorI_pop(self)

    def append(self, x):
        r"""
        append(VectorI self, std::vector< int >::value_type const & x)

        Parameters
        ----------
        x: std::vector< int >::value_type const &

        """
        return _libm2k.VectorI_append(self, x)

    def empty(self):
        r"""empty(VectorI self) -> bool"""
        return _libm2k.VectorI_empty(self)

    def size(self):
        r"""size(VectorI self) -> std::vector< int >::size_type"""
        return _libm2k.VectorI_size(self)

    def swap(self, v):
        r"""
        swap(VectorI self, VectorI v)

        Parameters
        ----------
        v: std::vector< int > &

        """
        return _libm2k.VectorI_swap(self, v)

    def begin(self):
        r"""begin(VectorI self) -> std::vector< int >::iterator"""
        return _libm2k.VectorI_begin(self)

    def end(self):
        r"""end(VectorI self) -> std::vector< int >::iterator"""
        return _libm2k.VectorI_end(self)

    def rbegin(self):
        r"""rbegin(VectorI self) -> std::vector< int >::reverse_iterator"""
        return _libm2k.VectorI_rbegin(self)

    def rend(self):
        r"""rend(VectorI self) -> std::vector< int >::reverse_iterator"""
        return _libm2k.VectorI_rend(self)

    def clear(self):
        r"""clear(VectorI self)"""
        return _libm2k.VectorI_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorI self) -> std::vector< int >::allocator_type"""
        return _libm2k.VectorI_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorI self)"""
        return _libm2k.VectorI_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorI self, std::vector< int >::iterator pos) -> std::vector< int >::iterator

        Parameters
        ----------
        pos: std::vector< int >::iterator

        erase(VectorI self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator

        Parameters
        ----------
        first: std::vector< int >::iterator
        last: std::vector< int >::iterator

        """
        return _libm2k.VectorI_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorI self) -> VectorI
        __init__(VectorI self, VectorI other) -> VectorI

        Parameters
        ----------
        other: std::vector< int > const &

        __init__(VectorI self, std::vector< int >::size_type size) -> VectorI

        Parameters
        ----------
        size: std::vector< int >::size_type

        __init__(VectorI self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> VectorI

        Parameters
        ----------
        size: std::vector< int >::size_type
        value: std::vector< int >::value_type const &

        """
        _libm2k.VectorI_swiginit(self, _libm2k.new_VectorI(*args))

    def push_back(self, x):
        r"""
        push_back(VectorI self, std::vector< int >::value_type const & x)

        Parameters
        ----------
        x: std::vector< int >::value_type const &

        """
        return _libm2k.VectorI_push_back(self, x)

    def front(self):
        r"""front(VectorI self) -> std::vector< int >::value_type const &"""
        return _libm2k.VectorI_front(self)

    def back(self):
        r"""back(VectorI self) -> std::vector< int >::value_type const &"""
        return _libm2k.VectorI_back(self)

    def assign(self, n, x):
        r"""
        assign(VectorI self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)

        Parameters
        ----------
        n: std::vector< int >::size_type
        x: std::vector< int >::value_type const &

        """
        return _libm2k.VectorI_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorI self, std::vector< int >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< int >::size_type

        resize(VectorI self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< int >::size_type
        x: std::vector< int >::value_type const &

        """
        return _libm2k.VectorI_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorI self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator

        Parameters
        ----------
        pos: std::vector< int >::iterator
        x: std::vector< int >::value_type const &

        insert(VectorI self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< int >::iterator
        n: std::vector< int >::size_type
        x: std::vector< int >::value_type const &

        """
        return _libm2k.VectorI_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(VectorI self, std::vector< int >::size_type n)

        Parameters
        ----------
        n: std::vector< int >::size_type

        """
        return _libm2k.VectorI_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorI self) -> std::vector< int >::size_type"""
        return _libm2k.VectorI_capacity(self)
    __swig_destroy__ = _libm2k.delete_VectorI

# Register VectorI in _libm2k:
_libm2k.VectorI_swigregister(VectorI)

class VectorS(object):
    r"""Proxy of C++ std::vector< short > class."""

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

    def iterator(self):
        r"""iterator(VectorS self) -> SwigPyIterator"""
        return _libm2k.VectorS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorS self) -> bool"""
        return _libm2k.VectorS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorS self) -> bool"""
        return _libm2k.VectorS___bool__(self)

    def __len__(self):
        r"""__len__(VectorS self) -> std::vector< short >::size_type"""
        return _libm2k.VectorS___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(VectorS self, std::vector< short >::difference_type i, std::vector< short >::difference_type j) -> VectorS

        Parameters
        ----------
        i: std::vector< short >::difference_type
        j: std::vector< short >::difference_type

        """
        return _libm2k.VectorS___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorS self, std::vector< short >::difference_type i, std::vector< short >::difference_type j)

        Parameters
        ----------
        i: std::vector< short >::difference_type
        j: std::vector< short >::difference_type

        __setslice__(VectorS self, std::vector< short >::difference_type i, std::vector< short >::difference_type j, VectorS v)

        Parameters
        ----------
        i: std::vector< short >::difference_type
        j: std::vector< short >::difference_type
        v: std::vector< short,std::allocator< short > > const &

        """
        return _libm2k.VectorS___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(VectorS self, std::vector< short >::difference_type i, std::vector< short >::difference_type j)

        Parameters
        ----------
        i: std::vector< short >::difference_type
        j: std::vector< short >::difference_type

        """
        return _libm2k.VectorS___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorS self, std::vector< short >::difference_type i)

        Parameters
        ----------
        i: std::vector< short >::difference_type

        __delitem__(VectorS self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.VectorS___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorS self, PySliceObject * slice) -> VectorS

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(VectorS self, std::vector< short >::difference_type i) -> std::vector< short >::value_type const &

        Parameters
        ----------
        i: std::vector< short >::difference_type

        """
        return _libm2k.VectorS___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorS self, PySliceObject * slice, VectorS v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< short,std::allocator< short > > const &

        __setitem__(VectorS self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(VectorS self, std::vector< short >::difference_type i, std::vector< short >::value_type const & x)

        Parameters
        ----------
        i: std::vector< short >::difference_type
        x: std::vector< short >::value_type const &

        """
        return _libm2k.VectorS___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorS self) -> std::vector< short >::value_type"""
        return _libm2k.VectorS_pop(self)

    def append(self, x):
        r"""
        append(VectorS self, std::vector< short >::value_type const & x)

        Parameters
        ----------
        x: std::vector< short >::value_type const &

        """
        return _libm2k.VectorS_append(self, x)

    def empty(self):
        r"""empty(VectorS self) -> bool"""
        return _libm2k.VectorS_empty(self)

    def size(self):
        r"""size(VectorS self) -> std::vector< short >::size_type"""
        return _libm2k.VectorS_size(self)

    def swap(self, v):
        r"""
        swap(VectorS self, VectorS v)

        Parameters
        ----------
        v: std::vector< short > &

        """
        return _libm2k.VectorS_swap(self, v)

    def begin(self):
        r"""begin(VectorS self) -> std::vector< short >::iterator"""
        return _libm2k.VectorS_begin(self)

    def end(self):
        r"""end(VectorS self) -> std::vector< short >::iterator"""
        return _libm2k.VectorS_end(self)

    def rbegin(self):
        r"""rbegin(VectorS self) -> std::vector< short >::reverse_iterator"""
        return _libm2k.VectorS_rbegin(self)

    def rend(self):
        r"""rend(VectorS self) -> std::vector< short >::reverse_iterator"""
        return _libm2k.VectorS_rend(self)

    def clear(self):
        r"""clear(VectorS self)"""
        return _libm2k.VectorS_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorS self) -> std::vector< short >::allocator_type"""
        return _libm2k.VectorS_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorS self)"""
        return _libm2k.VectorS_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorS self, std::vector< short >::iterator pos) -> std::vector< short >::iterator

        Parameters
        ----------
        pos: std::vector< short >::iterator

        erase(VectorS self, std::vector< short >::iterator first, std::vector< short >::iterator last) -> std::vector< short >::iterator

        Parameters
        ----------
        first: std::vector< short >::iterator
        last: std::vector< short >::iterator

        """
        return _libm2k.VectorS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorS self) -> VectorS
        __init__(VectorS self, VectorS other) -> VectorS

        Parameters
        ----------
        other: std::vector< short > const &

        __init__(VectorS self, std::vector< short >::size_type size) -> VectorS

        Parameters
        ----------
        size: std::vector< short >::size_type

        __init__(VectorS self, std::vector< short >::size_type size, std::vector< short >::value_type const & value) -> VectorS

        Parameters
        ----------
        size: std::vector< short >::size_type
        value: std::vector< short >::value_type const &

        """
        _libm2k.VectorS_swiginit(self, _libm2k.new_VectorS(*args))

    def push_back(self, x):
        r"""
        push_back(VectorS self, std::vector< short >::value_type const & x)

        Parameters
        ----------
        x: std::vector< short >::value_type const &

        """
        return _libm2k.VectorS_push_back(self, x)

    def front(self):
        r"""front(VectorS self) -> std::vector< short >::value_type const &"""
        return _libm2k.VectorS_front(self)

    def back(self):
        r"""back(VectorS self) -> std::vector< short >::value_type const &"""
        return _libm2k.VectorS_back(self)

    def assign(self, n, x):
        r"""
        assign(VectorS self, std::vector< short >::size_type n, std::vector< short >::value_type const & x)

        Parameters
        ----------
        n: std::vector< short >::size_type
        x: std::vector< short >::value_type const &

        """
        return _libm2k.VectorS_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorS self, std::vector< short >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< short >::size_type

        resize(VectorS self, std::vector< short >::size_type new_size, std::vector< short >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< short >::size_type
        x: std::vector< short >::value_type const &

        """
        return _libm2k.VectorS_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorS self, std::vector< short >::iterator pos, std::vector< short >::value_type const & x) -> std::vector< short >::iterator

        Parameters
        ----------
        pos: std::vector< short >::iterator
        x: std::vector< short >::value_type const &

        insert(VectorS self, std::vector< short >::iterator pos, std::vector< short >::size_type n, std::vector< short >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< short >::iterator
        n: std::vector< short >::size_type
        x: std::vector< short >::value_type const &

        """
        return _libm2k.VectorS_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(VectorS self, std::vector< short >::size_type n)

        Parameters
        ----------
        n: std::vector< short >::size_type

        """
        return _libm2k.VectorS_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorS self) -> std::vector< short >::size_type"""
        return _libm2k.VectorS_capacity(self)
    __swig_destroy__ = _libm2k.delete_VectorS

# Register VectorS in _libm2k:
_libm2k.VectorS_swigregister(VectorS)

class VectorUS(object):
    r"""Proxy of C++ std::vector< unsigned short > class."""

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

    def iterator(self):
        r"""iterator(VectorUS self) -> SwigPyIterator"""
        return _libm2k.VectorUS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorUS self) -> bool"""
        return _libm2k.VectorUS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorUS self) -> bool"""
        return _libm2k.VectorUS___bool__(self)

    def __len__(self):
        r"""__len__(VectorUS self) -> std::vector< unsigned short >::size_type"""
        return _libm2k.VectorUS___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(VectorUS self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j) -> VectorUS

        Parameters
        ----------
        i: std::vector< unsigned short >::difference_type
        j: std::vector< unsigned short >::difference_type

        """
        return _libm2k.VectorUS___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorUS self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j)

        Parameters
        ----------
        i: std::vector< unsigned short >::difference_type
        j: std::vector< unsigned short >::difference_type

        __setslice__(VectorUS self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j, VectorUS v)

        Parameters
        ----------
        i: std::vector< unsigned short >::difference_type
        j: std::vector< unsigned short >::difference_type
        v: std::vector< unsigned short,std::allocator< unsigned short > > const &

        """
        return _libm2k.VectorUS___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(VectorUS self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::difference_type j)

        Parameters
        ----------
        i: std::vector< unsigned short >::difference_type
        j: std::vector< unsigned short >::difference_type

        """
        return _libm2k.VectorUS___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorUS self, std::vector< unsigned short >::difference_type i)

        Parameters
        ----------
        i: std::vector< unsigned short >::difference_type

        __delitem__(VectorUS self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.VectorUS___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorUS self, PySliceObject * slice) -> VectorUS

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(VectorUS self, std::vector< unsigned short >::difference_type i) -> std::vector< unsigned short >::value_type const &

        Parameters
        ----------
        i: std::vector< unsigned short >::difference_type

        """
        return _libm2k.VectorUS___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorUS self, PySliceObject * slice, VectorUS v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< unsigned short,std::allocator< unsigned short > > const &

        __setitem__(VectorUS self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(VectorUS self, std::vector< unsigned short >::difference_type i, std::vector< unsigned short >::value_type const & x)

        Parameters
        ----------
        i: std::vector< unsigned short >::difference_type
        x: std::vector< unsigned short >::value_type const &

        """
        return _libm2k.VectorUS___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorUS self) -> std::vector< unsigned short >::value_type"""
        return _libm2k.VectorUS_pop(self)

    def append(self, x):
        r"""
        append(VectorUS self, std::vector< unsigned short >::value_type const & x)

        Parameters
        ----------
        x: std::vector< unsigned short >::value_type const &

        """
        return _libm2k.VectorUS_append(self, x)

    def empty(self):
        r"""empty(VectorUS self) -> bool"""
        return _libm2k.VectorUS_empty(self)

    def size(self):
        r"""size(VectorUS self) -> std::vector< unsigned short >::size_type"""
        return _libm2k.VectorUS_size(self)

    def swap(self, v):
        r"""
        swap(VectorUS self, VectorUS v)

        Parameters
        ----------
        v: std::vector< unsigned short > &

        """
        return _libm2k.VectorUS_swap(self, v)

    def begin(self):
        r"""begin(VectorUS self) -> std::vector< unsigned short >::iterator"""
        return _libm2k.VectorUS_begin(self)

    def end(self):
        r"""end(VectorUS self) -> std::vector< unsigned short >::iterator"""
        return _libm2k.VectorUS_end(self)

    def rbegin(self):
        r"""rbegin(VectorUS self) -> std::vector< unsigned short >::reverse_iterator"""
        return _libm2k.VectorUS_rbegin(self)

    def rend(self):
        r"""rend(VectorUS self) -> std::vector< unsigned short >::reverse_iterator"""
        return _libm2k.VectorUS_rend(self)

    def clear(self):
        r"""clear(VectorUS self)"""
        return _libm2k.VectorUS_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorUS self) -> std::vector< unsigned short >::allocator_type"""
        return _libm2k.VectorUS_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorUS self)"""
        return _libm2k.VectorUS_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorUS self, std::vector< unsigned short >::iterator pos) -> std::vector< unsigned short >::iterator

        Parameters
        ----------
        pos: std::vector< unsigned short >::iterator

        erase(VectorUS self, std::vector< unsigned short >::iterator first, std::vector< unsigned short >::iterator last) -> std::vector< unsigned short >::iterator

        Parameters
        ----------
        first: std::vector< unsigned short >::iterator
        last: std::vector< unsigned short >::iterator

        """
        return _libm2k.VectorUS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorUS self) -> VectorUS
        __init__(VectorUS self, VectorUS other) -> VectorUS

        Parameters
        ----------
        other: std::vector< unsigned short > const &

        __init__(VectorUS self, std::vector< unsigned short >::size_type size) -> VectorUS

        Parameters
        ----------
        size: std::vector< unsigned short >::size_type

        __init__(VectorUS self, std::vector< unsigned short >::size_type size, std::vector< unsigned short >::value_type const & value) -> VectorUS

        Parameters
        ----------
        size: std::vector< unsigned short >::size_type
        value: std::vector< unsigned short >::value_type const &

        """
        _libm2k.VectorUS_swiginit(self, _libm2k.new_VectorUS(*args))

    def push_back(self, x):
        r"""
        push_back(VectorUS self, std::vector< unsigned short >::value_type const & x)

        Parameters
        ----------
        x: std::vector< unsigned short >::value_type const &

        """
        return _libm2k.VectorUS_push_back(self, x)

    def front(self):
        r"""front(VectorUS self) -> std::vector< unsigned short >::value_type const &"""
        return _libm2k.VectorUS_front(self)

    def back(self):
        r"""back(VectorUS self) -> std::vector< unsigned short >::value_type const &"""
        return _libm2k.VectorUS_back(self)

    def assign(self, n, x):
        r"""
        assign(VectorUS self, std::vector< unsigned short >::size_type n, std::vector< unsigned short >::value_type const & x)

        Parameters
        ----------
        n: std::vector< unsigned short >::size_type
        x: std::vector< unsigned short >::value_type const &

        """
        return _libm2k.VectorUS_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorUS self, std::vector< unsigned short >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< unsigned short >::size_type

        resize(VectorUS self, std::vector< unsigned short >::size_type new_size, std::vector< unsigned short >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< unsigned short >::size_type
        x: std::vector< unsigned short >::value_type const &

        """
        return _libm2k.VectorUS_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorUS self, std::vector< unsigned short >::iterator pos, std::vector< unsigned short >::value_type const & x) -> std::vector< unsigned short >::iterator

        Parameters
        ----------
        pos: std::vector< unsigned short >::iterator
        x: std::vector< unsigned short >::value_type const &

        insert(VectorUS self, std::vector< unsigned short >::iterator pos, std::vector< unsigned short >::size_type n, std::vector< unsigned short >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< unsigned short >::iterator
        n: std::vector< unsigned short >::size_type
        x: std::vector< unsigned short >::value_type const &

        """
        return _libm2k.VectorUS_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(VectorUS self, std::vector< unsigned short >::size_type n)

        Parameters
        ----------
        n: std::vector< unsigned short >::size_type

        """
        return _libm2k.VectorUS_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorUS self) -> std::vector< unsigned short >::size_type"""
        return _libm2k.VectorUS_capacity(self)
    __swig_destroy__ = _libm2k.delete_VectorUS

# Register VectorUS in _libm2k:
_libm2k.VectorUS_swigregister(VectorUS)

class VectorD(object):
    r"""Proxy of C++ std::vector< double > class."""

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

    def iterator(self):
        r"""iterator(VectorD self) -> SwigPyIterator"""
        return _libm2k.VectorD_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorD self) -> bool"""
        return _libm2k.VectorD___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorD self) -> bool"""
        return _libm2k.VectorD___bool__(self)

    def __len__(self):
        r"""__len__(VectorD self) -> std::vector< double >::size_type"""
        return _libm2k.VectorD___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(VectorD self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> VectorD

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type

        """
        return _libm2k.VectorD___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorD self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type

        __setslice__(VectorD self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, VectorD v)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type
        v: std::vector< double,std::allocator< double > > const &

        """
        return _libm2k.VectorD___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(VectorD self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type

        """
        return _libm2k.VectorD___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorD self, std::vector< double >::difference_type i)

        Parameters
        ----------
        i: std::vector< double >::difference_type

        __delitem__(VectorD self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.VectorD___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorD self, PySliceObject * slice) -> VectorD

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(VectorD self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &

        Parameters
        ----------
        i: std::vector< double >::difference_type

        """
        return _libm2k.VectorD___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorD self, PySliceObject * slice, VectorD v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< double,std::allocator< double > > const &

        __setitem__(VectorD self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(VectorD self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        x: std::vector< double >::value_type const &

        """
        return _libm2k.VectorD___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorD self) -> std::vector< double >::value_type"""
        return _libm2k.VectorD_pop(self)

    def append(self, x):
        r"""
        append(VectorD self, std::vector< double >::value_type const & x)

        Parameters
        ----------
        x: std::vector< double >::value_type const &

        """
        return _libm2k.VectorD_append(self, x)

    def empty(self):
        r"""empty(VectorD self) -> bool"""
        return _libm2k.VectorD_empty(self)

    def size(self):
        r"""size(VectorD self) -> std::vector< double >::size_type"""
        return _libm2k.VectorD_size(self)

    def swap(self, v):
        r"""
        swap(VectorD self, VectorD v)

        Parameters
        ----------
        v: std::vector< double > &

        """
        return _libm2k.VectorD_swap(self, v)

    def begin(self):
        r"""begin(VectorD self) -> std::vector< double >::iterator"""
        return _libm2k.VectorD_begin(self)

    def end(self):
        r"""end(VectorD self) -> std::vector< double >::iterator"""
        return _libm2k.VectorD_end(self)

    def rbegin(self):
        r"""rbegin(VectorD self) -> std::vector< double >::reverse_iterator"""
        return _libm2k.VectorD_rbegin(self)

    def rend(self):
        r"""rend(VectorD self) -> std::vector< double >::reverse_iterator"""
        return _libm2k.VectorD_rend(self)

    def clear(self):
        r"""clear(VectorD self)"""
        return _libm2k.VectorD_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorD self) -> std::vector< double >::allocator_type"""
        return _libm2k.VectorD_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorD self)"""
        return _libm2k.VectorD_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorD self, std::vector< double >::iterator pos) -> std::vector< double >::iterator

        Parameters
        ----------
        pos: std::vector< double >::iterator

        erase(VectorD self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator

        Parameters
        ----------
        first: std::vector< double >::iterator
        last: std::vector< double >::iterator

        """
        return _libm2k.VectorD_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorD self) -> VectorD
        __init__(VectorD self, VectorD other) -> VectorD

        Parameters
        ----------
        other: std::vector< double > const &

        __init__(VectorD self, std::vector< double >::size_type size) -> VectorD

        Parameters
        ----------
        size: std::vector< double >::size_type

        __init__(VectorD self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> VectorD

        Parameters
        ----------
        size: std::vector< double >::size_type
        value: std::vector< double >::value_type const &

        """
        _libm2k.VectorD_swiginit(self, _libm2k.new_VectorD(*args))

    def push_back(self, x):
        r"""
        push_back(VectorD self, std::vector< double >::value_type const & x)

        Parameters
        ----------
        x: std::vector< double >::value_type const &

        """
        return _libm2k.VectorD_push_back(self, x)

    def front(self):
        r"""front(VectorD self) -> std::vector< double >::value_type const &"""
        return _libm2k.VectorD_front(self)

    def back(self):
        r"""back(VectorD self) -> std::vector< double >::value_type const &"""
        return _libm2k.VectorD_back(self)

    def assign(self, n, x):
        r"""
        assign(VectorD self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)

        Parameters
        ----------
        n: std::vector< double >::size_type
        x: std::vector< double >::value_type const &

        """
        return _libm2k.VectorD_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorD self, std::vector< double >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< double >::size_type

        resize(VectorD self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< double >::size_type
        x: std::vector< double >::value_type const &

        """
        return _libm2k.VectorD_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorD self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator

        Parameters
        ----------
        pos: std::vector< double >::iterator
        x: std::vector< double >::value_type const &

        insert(VectorD self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< double >::iterator
        n: std::vector< double >::size_type
        x: std::vector< double >::value_type const &

        """
        return _libm2k.VectorD_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(VectorD self, std::vector< double >::size_type n)

        Parameters
        ----------
        n: std::vector< double >::size_type

        """
        return _libm2k.VectorD_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorD self) -> std::vector< double >::size_type"""
        return _libm2k.VectorD_capacity(self)
    __swig_destroy__ = _libm2k.delete_VectorD

# Register VectorD in _libm2k:
_libm2k.VectorD_swigregister(VectorD)

class VectorStr(object):
    r"""Proxy of C++ std::vector< std::string > class."""

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

    def iterator(self):
        r"""iterator(VectorStr self) -> SwigPyIterator"""
        return _libm2k.VectorStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorStr self) -> bool"""
        return _libm2k.VectorStr___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorStr self) -> bool"""
        return _libm2k.VectorStr___bool__(self)

    def __len__(self):
        r"""__len__(VectorStr self) -> std::vector< std::string >::size_type"""
        return _libm2k.VectorStr___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(VectorStr self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> VectorStr

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        """
        return _libm2k.VectorStr___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorStr self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        __setslice__(VectorStr self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, VectorStr v)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type
        v: std::vector< std::string,std::allocator< std::string > > const &

        """
        return _libm2k.VectorStr___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(VectorStr self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        """
        return _libm2k.VectorStr___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorStr self, std::vector< std::string >::difference_type i)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type

        __delitem__(VectorStr self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.VectorStr___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorStr self, PySliceObject * slice) -> VectorStr

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(VectorStr self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &

        Parameters
        ----------
        i: std::vector< std::string >::difference_type

        """
        return _libm2k.VectorStr___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorStr self, PySliceObject * slice, VectorStr v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< std::string,std::allocator< std::string > > const &

        __setitem__(VectorStr self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(VectorStr self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        x: std::vector< std::string >::value_type const &

        """
        return _libm2k.VectorStr___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorStr self) -> std::vector< std::string >::value_type"""
        return _libm2k.VectorStr_pop(self)

    def append(self, x):
        r"""
        append(VectorStr self, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        x: std::vector< std::string >::value_type const &

        """
        return _libm2k.VectorStr_append(self, x)

    def empty(self):
        r"""empty(VectorStr self) -> bool"""
        return _libm2k.VectorStr_empty(self)

    def size(self):
        r"""size(VectorStr self) -> std::vector< std::string >::size_type"""
        return _libm2k.VectorStr_size(self)

    def swap(self, v):
        r"""
        swap(VectorStr self, VectorStr v)

        Parameters
        ----------
        v: std::vector< std::string > &

        """
        return _libm2k.VectorStr_swap(self, v)

    def begin(self):
        r"""begin(VectorStr self) -> std::vector< std::string >::iterator"""
        return _libm2k.VectorStr_begin(self)

    def end(self):
        r"""end(VectorStr self) -> std::vector< std::string >::iterator"""
        return _libm2k.VectorStr_end(self)

    def rbegin(self):
        r"""rbegin(VectorStr self) -> std::vector< std::string >::reverse_iterator"""
        return _libm2k.VectorStr_rbegin(self)

    def rend(self):
        r"""rend(VectorStr self) -> std::vector< std::string >::reverse_iterator"""
        return _libm2k.VectorStr_rend(self)

    def clear(self):
        r"""clear(VectorStr self)"""
        return _libm2k.VectorStr_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorStr self) -> std::vector< std::string >::allocator_type"""
        return _libm2k.VectorStr_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorStr self)"""
        return _libm2k.VectorStr_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorStr self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator

        Parameters
        ----------
        pos: std::vector< std::string >::iterator

        erase(VectorStr self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator

        Parameters
        ----------
        first: std::vector< std::string >::iterator
        last: std::vector< std::string >::iterator

        """
        return _libm2k.VectorStr_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorStr self) -> VectorStr
        __init__(VectorStr self, VectorStr other) -> VectorStr

        Parameters
        ----------
        other: std::vector< std::string > const &

        __init__(VectorStr self, std::vector< std::string >::size_type size) -> VectorStr

        Parameters
        ----------
        size: std::vector< std::string >::size_type

        __init__(VectorStr self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> VectorStr

        Parameters
        ----------
        size: std::vector< std::string >::size_type
        value: std::vector< std::string >::value_type const &

        """
        _libm2k.VectorStr_swiginit(self, _libm2k.new_VectorStr(*args))

    def push_back(self, x):
        r"""
        push_back(VectorStr self, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        x: std::vector< std::string >::value_type const &

        """
        return _libm2k.VectorStr_push_back(self, x)

    def front(self):
        r"""front(VectorStr self) -> std::vector< std::string >::value_type const &"""
        return _libm2k.VectorStr_front(self)

    def back(self):
        r"""back(VectorStr self) -> std::vector< std::string >::value_type const &"""
        return _libm2k.VectorStr_back(self)

    def assign(self, n, x):
        r"""
        assign(VectorStr self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        n: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _libm2k.VectorStr_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorStr self, std::vector< std::string >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< std::string >::size_type

        resize(VectorStr self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _libm2k.VectorStr_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorStr self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator

        Parameters
        ----------
        pos: std::vector< std::string >::iterator
        x: std::vector< std::string >::value_type const &

        insert(VectorStr self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< std::string >::iterator
        n: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _libm2k.VectorStr_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(VectorStr self, std::vector< std::string >::size_type n)

        Parameters
        ----------
        n: std::vector< std::string >::size_type

        """
        return _libm2k.VectorStr_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorStr self) -> std::vector< std::string >::size_type"""
        return _libm2k.VectorStr_capacity(self)
    __swig_destroy__ = _libm2k.delete_VectorStr

# Register VectorStr in _libm2k:
_libm2k.VectorStr_swigregister(VectorStr)

class VectorVectorD(object):
    r"""Proxy of C++ std::vector< std::vector< double > > class."""

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

    def iterator(self):
        r"""iterator(VectorVectorD self) -> SwigPyIterator"""
        return _libm2k.VectorVectorD_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorVectorD self) -> bool"""
        return _libm2k.VectorVectorD___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorVectorD self) -> bool"""
        return _libm2k.VectorVectorD___bool__(self)

    def __len__(self):
        r"""__len__(VectorVectorD self) -> std::vector< std::vector< double > >::size_type"""
        return _libm2k.VectorVectorD___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(VectorVectorD self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> VectorVectorD

        Parameters
        ----------
        i: std::vector< std::vector< double > >::difference_type
        j: std::vector< std::vector< double > >::difference_type

        """
        return _libm2k.VectorVectorD___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorVectorD self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::vector< double > >::difference_type
        j: std::vector< std::vector< double > >::difference_type

        __setslice__(VectorVectorD self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, VectorVectorD v)

        Parameters
        ----------
        i: std::vector< std::vector< double > >::difference_type
        j: std::vector< std::vector< double > >::difference_type
        v: std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &

        """
        return _libm2k.VectorVectorD___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(VectorVectorD self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::vector< double > >::difference_type
        j: std::vector< std::vector< double > >::difference_type

        """
        return _libm2k.VectorVectorD___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorVectorD self, std::vector< std::vector< double > >::difference_type i)

        Parameters
        ----------
        i: std::vector< std::vector< double > >::difference_type

        __delitem__(VectorVectorD self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.VectorVectorD___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorVectorD self, PySliceObject * slice) -> VectorVectorD

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(VectorVectorD self, std::vector< std::vector< double > >::difference_type i) -> VectorD

        Parameters
        ----------
        i: std::vector< std::vector< double > >::difference_type

        """
        return _libm2k.VectorVectorD___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorVectorD self, PySliceObject * slice, VectorVectorD v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &

        __setitem__(VectorVectorD self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(VectorVectorD self, std::vector< std::vector< double > >::difference_type i, VectorD x)

        Parameters
        ----------
        i: std::vector< std::vector< double > >::difference_type
        x: std::vector< std::vector< double > >::value_type const &

        """
        return _libm2k.VectorVectorD___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorVectorD self) -> VectorD"""
        return _libm2k.VectorVectorD_pop(self)

    def append(self, x):
        r"""
        append(VectorVectorD self, VectorD x)

        Parameters
        ----------
        x: std::vector< std::vector< double > >::value_type const &

        """
        return _libm2k.VectorVectorD_append(self, x)

    def empty(self):
        r"""empty(VectorVectorD self) -> bool"""
        return _libm2k.VectorVectorD_empty(self)

    def size(self):
        r"""size(VectorVectorD self) -> std::vector< std::vector< double > >::size_type"""
        return _libm2k.VectorVectorD_size(self)

    def swap(self, v):
        r"""
        swap(VectorVectorD self, VectorVectorD v)

        Parameters
        ----------
        v: std::vector< std::vector< double,std::allocator< double > > > &

        """
        return _libm2k.VectorVectorD_swap(self, v)

    def begin(self):
        r"""begin(VectorVectorD self) -> std::vector< std::vector< double > >::iterator"""
        return _libm2k.VectorVectorD_begin(self)

    def end(self):
        r"""end(VectorVectorD self) -> std::vector< std::vector< double > >::iterator"""
        return _libm2k.VectorVectorD_end(self)

    def rbegin(self):
        r"""rbegin(VectorVectorD self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _libm2k.VectorVectorD_rbegin(self)

    def rend(self):
        r"""rend(VectorVectorD self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _libm2k.VectorVectorD_rend(self)

    def clear(self):
        r"""clear(VectorVectorD self)"""
        return _libm2k.VectorVectorD_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorVectorD self) -> std::vector< std::vector< double > >::allocator_type"""
        return _libm2k.VectorVectorD_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorVectorD self)"""
        return _libm2k.VectorVectorD_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorVectorD self, std::vector< std::vector< double > >::iterator pos) -> std::vector< std::vector< double > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< double > >::iterator

        erase(VectorVectorD self, std::vector< std::vector< double > >::iterator first, std::vector< std::vector< double > >::iterator last) -> std::vector< std::vector< double > >::iterator

        Parameters
        ----------
        first: std::vector< std::vector< double > >::iterator
        last: std::vector< std::vector< double > >::iterator

        """
        return _libm2k.VectorVectorD_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorVectorD self) -> VectorVectorD
        __init__(VectorVectorD self, VectorVectorD other) -> VectorVectorD

        Parameters
        ----------
        other: std::vector< std::vector< double,std::allocator< double > > > const &

        __init__(VectorVectorD self, std::vector< std::vector< double > >::size_type size) -> VectorVectorD

        Parameters
        ----------
        size: std::vector< std::vector< double > >::size_type

        __init__(VectorVectorD self, std::vector< std::vector< double > >::size_type size, VectorD value) -> VectorVectorD

        Parameters
        ----------
        size: std::vector< std::vector< double > >::size_type
        value: std::vector< std::vector< double > >::value_type const &

        """
        _libm2k.VectorVectorD_swiginit(self, _libm2k.new_VectorVectorD(*args))

    def push_back(self, x):
        r"""
        push_back(VectorVectorD self, VectorD x)

        Parameters
        ----------
        x: std::vector< std::vector< double > >::value_type const &

        """
        return _libm2k.VectorVectorD_push_back(self, x)

    def front(self):
        r"""front(VectorVectorD self) -> VectorD"""
        return _libm2k.VectorVectorD_front(self)

    def back(self):
        r"""back(VectorVectorD self) -> VectorD"""
        return _libm2k.VectorVectorD_back(self)

    def assign(self, n, x):
        r"""
        assign(VectorVectorD self, std::vector< std::vector< double > >::size_type n, VectorD x)

        Parameters
        ----------
        n: std::vector< std::vector< double > >::size_type
        x: std::vector< std::vector< double > >::value_type const &

        """
        return _libm2k.VectorVectorD_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorVectorD self, std::vector< std::vector< double > >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< std::vector< double > >::size_type

        resize(VectorVectorD self, std::vector< std::vector< double > >::size_type new_size, VectorD x)

        Parameters
        ----------
        new_size: std::vector< std::vector< double > >::size_type
        x: std::vector< std::vector< double > >::value_type const &

        """
        return _libm2k.VectorVectorD_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorVectorD self, std::vector< std::vector< double > >::iterator pos, VectorD x) -> std::vector< std::vector< double > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< double > >::iterator
        x: std::vector< std::vector< double > >::value_type const &

        insert(VectorVectorD self, std::vector< std::vector< double > >::iterator pos, std::vector< std::vector< double > >::size_type n, VectorD x)

        Parameters
        ----------
        pos: std::vector< std::vector< double > >::iterator
        n: std::vector< std::vector< double > >::size_type
        x: std::vector< std::vector< double > >::value_type const &

        """
        return _libm2k.VectorVectorD_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(VectorVectorD self, std::vector< std::vector< double > >::size_type n)

        Parameters
        ----------
        n: std::vector< std::vector< double > >::size_type

        """
        return _libm2k.VectorVectorD_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorVectorD self) -> std::vector< std::vector< double > >::size_type"""
        return _libm2k.VectorVectorD_capacity(self)
    __swig_destroy__ = _libm2k.delete_VectorVectorD

# Register VectorVectorD in _libm2k:
_libm2k.VectorVectorD_swigregister(VectorVectorD)

class VectorVectorS(object):
    r"""Proxy of C++ std::vector< std::vector< int > > class."""

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

    def iterator(self):
        r"""iterator(VectorVectorS self) -> SwigPyIterator"""
        return _libm2k.VectorVectorS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorVectorS self) -> bool"""
        return _libm2k.VectorVectorS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorVectorS self) -> bool"""
        return _libm2k.VectorVectorS___bool__(self)

    def __len__(self):
        r"""__len__(VectorVectorS self) -> std::vector< std::vector< int > >::size_type"""
        return _libm2k.VectorVectorS___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(VectorVectorS self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j) -> VectorVectorS

        Parameters
        ----------
        i: std::vector< std::vector< int > >::difference_type
        j: std::vector< std::vector< int > >::difference_type

        """
        return _libm2k.VectorVectorS___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorVectorS self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::vector< int > >::difference_type
        j: std::vector< std::vector< int > >::difference_type

        __setslice__(VectorVectorS self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j, VectorVectorS v)

        Parameters
        ----------
        i: std::vector< std::vector< int > >::difference_type
        j: std::vector< std::vector< int > >::difference_type
        v: std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &

        """
        return _libm2k.VectorVectorS___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(VectorVectorS self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::vector< int > >::difference_type
        j: std::vector< std::vector< int > >::difference_type

        """
        return _libm2k.VectorVectorS___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorVectorS self, std::vector< std::vector< int > >::difference_type i)

        Parameters
        ----------
        i: std::vector< std::vector< int > >::difference_type

        __delitem__(VectorVectorS self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.VectorVectorS___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorVectorS self, PySliceObject * slice) -> VectorVectorS

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(VectorVectorS self, std::vector< std::vector< int > >::difference_type i) -> VectorI

        Parameters
        ----------
        i: std::vector< std::vector< int > >::difference_type

        """
        return _libm2k.VectorVectorS___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorVectorS self, PySliceObject * slice, VectorVectorS v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &

        __setitem__(VectorVectorS self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(VectorVectorS self, std::vector< std::vector< int > >::difference_type i, VectorI x)

        Parameters
        ----------
        i: std::vector< std::vector< int > >::difference_type
        x: std::vector< std::vector< int > >::value_type const &

        """
        return _libm2k.VectorVectorS___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorVectorS self) -> VectorI"""
        return _libm2k.VectorVectorS_pop(self)

    def append(self, x):
        r"""
        append(VectorVectorS self, VectorI x)

        Parameters
        ----------
        x: std::vector< std::vector< int > >::value_type const &

        """
        return _libm2k.VectorVectorS_append(self, x)

    def empty(self):
        r"""empty(VectorVectorS self) -> bool"""
        return _libm2k.VectorVectorS_empty(self)

    def size(self):
        r"""size(VectorVectorS self) -> std::vector< std::vector< int > >::size_type"""
        return _libm2k.VectorVectorS_size(self)

    def swap(self, v):
        r"""
        swap(VectorVectorS self, VectorVectorS v)

        Parameters
        ----------
        v: std::vector< std::vector< int,std::allocator< int > > > &

        """
        return _libm2k.VectorVectorS_swap(self, v)

    def begin(self):
        r"""begin(VectorVectorS self) -> std::vector< std::vector< int > >::iterator"""
        return _libm2k.VectorVectorS_begin(self)

    def end(self):
        r"""end(VectorVectorS self) -> std::vector< std::vector< int > >::iterator"""
        return _libm2k.VectorVectorS_end(self)

    def rbegin(self):
        r"""rbegin(VectorVectorS self) -> std::vector< std::vector< int > >::reverse_iterator"""
        return _libm2k.VectorVectorS_rbegin(self)

    def rend(self):
        r"""rend(VectorVectorS self) -> std::vector< std::vector< int > >::reverse_iterator"""
        return _libm2k.VectorVectorS_rend(self)

    def clear(self):
        r"""clear(VectorVectorS self)"""
        return _libm2k.VectorVectorS_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorVectorS self) -> std::vector< std::vector< int > >::allocator_type"""
        return _libm2k.VectorVectorS_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorVectorS self)"""
        return _libm2k.VectorVectorS_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorVectorS self, std::vector< std::vector< int > >::iterator pos) -> std::vector< std::vector< int > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< int > >::iterator

        erase(VectorVectorS self, std::vector< std::vector< int > >::iterator first, std::vector< std::vector< int > >::iterator last) -> std::vector< std::vector< int > >::iterator

        Parameters
        ----------
        first: std::vector< std::vector< int > >::iterator
        last: std::vector< std::vector< int > >::iterator

        """
        return _libm2k.VectorVectorS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorVectorS self) -> VectorVectorS
        __init__(VectorVectorS self, VectorVectorS other) -> VectorVectorS

        Parameters
        ----------
        other: std::vector< std::vector< int,std::allocator< int > > > const &

        __init__(VectorVectorS self, std::vector< std::vector< int > >::size_type size) -> VectorVectorS

        Parameters
        ----------
        size: std::vector< std::vector< int > >::size_type

        __init__(VectorVectorS self, std::vector< std::vector< int > >::size_type size, VectorI value) -> VectorVectorS

        Parameters
        ----------
        size: std::vector< std::vector< int > >::size_type
        value: std::vector< std::vector< int > >::value_type const &

        """
        _libm2k.VectorVectorS_swiginit(self, _libm2k.new_VectorVectorS(*args))

    def push_back(self, x):
        r"""
        push_back(VectorVectorS self, VectorI x)

        Parameters
        ----------
        x: std::vector< std::vector< int > >::value_type const &

        """
        return _libm2k.VectorVectorS_push_back(self, x)

    def front(self):
        r"""front(VectorVectorS self) -> VectorI"""
        return _libm2k.VectorVectorS_front(self)

    def back(self):
        r"""back(VectorVectorS self) -> VectorI"""
        return _libm2k.VectorVectorS_back(self)

    def assign(self, n, x):
        r"""
        assign(VectorVectorS self, std::vector< std::vector< int > >::size_type n, VectorI x)

        Parameters
        ----------
        n: std::vector< std::vector< int > >::size_type
        x: std::vector< std::vector< int > >::value_type const &

        """
        return _libm2k.VectorVectorS_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorVectorS self, std::vector< std::vector< int > >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< std::vector< int > >::size_type

        resize(VectorVectorS self, std::vector< std::vector< int > >::size_type new_size, VectorI x)

        Parameters
        ----------
        new_size: std::vector< std::vector< int > >::size_type
        x: std::vector< std::vector< int > >::value_type const &

        """
        return _libm2k.VectorVectorS_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorVectorS self, std::vector< std::vector< int > >::iterator pos, VectorI x) -> std::vector< std::vector< int > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< int > >::iterator
        x: std::vector< std::vector< int > >::value_type const &

        insert(VectorVectorS self, std::vector< std::vector< int > >::iterator pos, std::vector< std::vector< int > >::size_type n, VectorI x)

        Parameters
        ----------
        pos: std::vector< std::vector< int > >::iterator
        n: std::vector< std::vector< int > >::size_type
        x: std::vector< std::vector< int > >::value_type const &

        """
        return _libm2k.VectorVectorS_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(VectorVectorS self, std::vector< std::vector< int > >::size_type n)

        Parameters
        ----------
        n: std::vector< std::vector< int > >::size_type

        """
        return _libm2k.VectorVectorS_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorVectorS self) -> std::vector< std::vector< int > >::size_type"""
        return _libm2k.VectorVectorS_capacity(self)
    __swig_destroy__ = _libm2k.delete_VectorVectorS

# Register VectorVectorS in _libm2k:
_libm2k.VectorVectorS_swigregister(VectorVectorS)

class VectorVectorUS(object):
    r"""Proxy of C++ std::vector< std::vector< unsigned short > > class."""

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

    def iterator(self):
        r"""iterator(VectorVectorUS self) -> SwigPyIterator"""
        return _libm2k.VectorVectorUS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorVectorUS self) -> bool"""
        return _libm2k.VectorVectorUS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorVectorUS self) -> bool"""
        return _libm2k.VectorVectorUS___bool__(self)

    def __len__(self):
        r"""__len__(VectorVectorUS self) -> std::vector< std::vector< unsigned short > >::size_type"""
        return _libm2k.VectorVectorUS___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(VectorVectorUS self, std::vector< std::vector< unsigned short > >::difference_type i, std::vector< std::vector< unsigned short > >::difference_type j) -> VectorVectorUS

        Parameters
        ----------
        i: std::vector< std::vector< unsigned short > >::difference_type
        j: std::vector< std::vector< unsigned short > >::difference_type

        """
        return _libm2k.VectorVectorUS___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorVectorUS self, std::vector< std::vector< unsigned short > >::difference_type i, std::vector< std::vector< unsigned short > >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned short > >::difference_type
        j: std::vector< std::vector< unsigned short > >::difference_type

        __setslice__(VectorVectorUS self, std::vector< std::vector< unsigned short > >::difference_type i, std::vector< std::vector< unsigned short > >::difference_type j, VectorVectorUS v)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned short > >::difference_type
        j: std::vector< std::vector< unsigned short > >::difference_type
        v: std::vector< std::vector< unsigned short,std::allocator< unsigned short > >,std::allocator< std::vector< unsigned short,std::allocator< unsigned short > > > > const &

        """
        return _libm2k.VectorVectorUS___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(VectorVectorUS self, std::vector< std::vector< unsigned short > >::difference_type i, std::vector< std::vector< unsigned short > >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned short > >::difference_type
        j: std::vector< std::vector< unsigned short > >::difference_type

        """
        return _libm2k.VectorVectorUS___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorVectorUS self, std::vector< std::vector< unsigned short > >::difference_type i)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned short > >::difference_type

        __delitem__(VectorVectorUS self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.VectorVectorUS___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorVectorUS self, PySliceObject * slice) -> VectorVectorUS

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(VectorVectorUS self, std::vector< std::vector< unsigned short > >::difference_type i) -> VectorUS

        Parameters
        ----------
        i: std::vector< std::vector< unsigned short > >::difference_type

        """
        return _libm2k.VectorVectorUS___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorVectorUS self, PySliceObject * slice, VectorVectorUS v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< std::vector< unsigned short,std::allocator< unsigned short > >,std::allocator< std::vector< unsigned short,std::allocator< unsigned short > > > > const &

        __setitem__(VectorVectorUS self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(VectorVectorUS self, std::vector< std::vector< unsigned short > >::difference_type i, VectorUS x)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned short > >::difference_type
        x: std::vector< std::vector< unsigned short > >::value_type const &

        """
        return _libm2k.VectorVectorUS___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorVectorUS self) -> VectorUS"""
        return _libm2k.VectorVectorUS_pop(self)

    def append(self, x):
        r"""
        append(VectorVectorUS self, VectorUS x)

        Parameters
        ----------
        x: std::vector< std::vector< unsigned short > >::value_type const &

        """
        return _libm2k.VectorVectorUS_append(self, x)

    def empty(self):
        r"""empty(VectorVectorUS self) -> bool"""
        return _libm2k.VectorVectorUS_empty(self)

    def size(self):
        r"""size(VectorVectorUS self) -> std::vector< std::vector< unsigned short > >::size_type"""
        return _libm2k.VectorVectorUS_size(self)

    def swap(self, v):
        r"""
        swap(VectorVectorUS self, VectorVectorUS v)

        Parameters
        ----------
        v: std::vector< std::vector< unsigned short,std::allocator< unsigned short > > > &

        """
        return _libm2k.VectorVectorUS_swap(self, v)

    def begin(self):
        r"""begin(VectorVectorUS self) -> std::vector< std::vector< unsigned short > >::iterator"""
        return _libm2k.VectorVectorUS_begin(self)

    def end(self):
        r"""end(VectorVectorUS self) -> std::vector< std::vector< unsigned short > >::iterator"""
        return _libm2k.VectorVectorUS_end(self)

    def rbegin(self):
        r"""rbegin(VectorVectorUS self) -> std::vector< std::vector< unsigned short > >::reverse_iterator"""
        return _libm2k.VectorVectorUS_rbegin(self)

    def rend(self):
        r"""rend(VectorVectorUS self) -> std::vector< std::vector< unsigned short > >::reverse_iterator"""
        return _libm2k.VectorVectorUS_rend(self)

    def clear(self):
        r"""clear(VectorVectorUS self)"""
        return _libm2k.VectorVectorUS_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorVectorUS self) -> std::vector< std::vector< unsigned short > >::allocator_type"""
        return _libm2k.VectorVectorUS_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorVectorUS self)"""
        return _libm2k.VectorVectorUS_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorVectorUS self, std::vector< std::vector< unsigned short > >::iterator pos) -> std::vector< std::vector< unsigned short > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned short > >::iterator

        erase(VectorVectorUS self, std::vector< std::vector< unsigned short > >::iterator first, std::vector< std::vector< unsigned short > >::iterator last) -> std::vector< std::vector< unsigned short > >::iterator

        Parameters
        ----------
        first: std::vector< std::vector< unsigned short > >::iterator
        last: std::vector< std::vector< unsigned short > >::iterator

        """
        return _libm2k.VectorVectorUS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorVectorUS self) -> VectorVectorUS
        __init__(VectorVectorUS self, VectorVectorUS other) -> VectorVectorUS

        Parameters
        ----------
        other: std::vector< std::vector< unsigned short,std::allocator< unsigned short > > > const &

        __init__(VectorVectorUS self, std::vector< std::vector< unsigned short > >::size_type size) -> VectorVectorUS

        Parameters
        ----------
        size: std::vector< std::vector< unsigned short > >::size_type

        __init__(VectorVectorUS self, std::vector< std::vector< unsigned short > >::size_type size, VectorUS value) -> VectorVectorUS

        Parameters
        ----------
        size: std::vector< std::vector< unsigned short > >::size_type
        value: std::vector< std::vector< unsigned short > >::value_type const &

        """
        _libm2k.VectorVectorUS_swiginit(self, _libm2k.new_VectorVectorUS(*args))

    def push_back(self, x):
        r"""
        push_back(VectorVectorUS self, VectorUS x)

        Parameters
        ----------
        x: std::vector< std::vector< unsigned short > >::value_type const &

        """
        return _libm2k.VectorVectorUS_push_back(self, x)

    def front(self):
        r"""front(VectorVectorUS self) -> VectorUS"""
        return _libm2k.VectorVectorUS_front(self)

    def back(self):
        r"""back(VectorVectorUS self) -> VectorUS"""
        return _libm2k.VectorVectorUS_back(self)

    def assign(self, n, x):
        r"""
        assign(VectorVectorUS self, std::vector< std::vector< unsigned short > >::size_type n, VectorUS x)

        Parameters
        ----------
        n: std::vector< std::vector< unsigned short > >::size_type
        x: std::vector< std::vector< unsigned short > >::value_type const &

        """
        return _libm2k.VectorVectorUS_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorVectorUS self, std::vector< std::vector< unsigned short > >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< std::vector< unsigned short > >::size_type

        resize(VectorVectorUS self, std::vector< std::vector< unsigned short > >::size_type new_size, VectorUS x)

        Parameters
        ----------
        new_size: std::vector< std::vector< unsigned short > >::size_type
        x: std::vector< std::vector< unsigned short > >::value_type const &

        """
        return _libm2k.VectorVectorUS_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorVectorUS self, std::vector< std::vector< unsigned short > >::iterator pos, VectorUS x) -> std::vector< std::vector< unsigned short > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned short > >::iterator
        x: std::vector< std::vector< unsigned short > >::value_type const &

        insert(VectorVectorUS self, std::vector< std::vector< unsigned short > >::iterator pos, std::vector< std::vector< unsigned short > >::size_type n, VectorUS x)

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned short > >::iterator
        n: std::vector< std::vector< unsigned short > >::size_type
        x: std::vector< std::vector< unsigned short > >::value_type const &

        """
        return _libm2k.VectorVectorUS_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(VectorVectorUS self, std::vector< std::vector< unsigned short > >::size_type n)

        Parameters
        ----------
        n: std::vector< std::vector< unsigned short > >::size_type

        """
        return _libm2k.VectorVectorUS_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorVectorUS self) -> std::vector< std::vector< unsigned short > >::size_type"""
        return _libm2k.VectorVectorUS_capacity(self)
    __swig_destroy__ = _libm2k.delete_VectorVectorUS

# Register VectorVectorUS in _libm2k:
_libm2k.VectorVectorUS_swigregister(VectorVectorUS)

class PairDD(object):
    r"""Proxy of C++ std::pair< double,double > class."""

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

    def __init__(self, *args):
        r"""
        __init__(PairDD self) -> PairDD
        __init__(PairDD self, double first, double second) -> PairDD

        Parameters
        ----------
        first: double
        second: double

        __init__(PairDD self, PairDD other) -> PairDD

        Parameters
        ----------
        other: std::pair< double,double > const &

        """
        _libm2k.PairDD_swiginit(self, _libm2k.new_PairDD(*args))
    first = property(_libm2k.PairDD_first_get, _libm2k.PairDD_first_set, doc=r"""first : double""")
    second = property(_libm2k.PairDD_second_get, _libm2k.PairDD_second_set, doc=r"""second : double""")
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _libm2k.delete_PairDD

# Register PairDD in _libm2k:
_libm2k.PairDD_swigregister(PairDD)

class VectorPairDD(object):
    r"""Proxy of C++ std::vector< std::pair< std::string,std::pair< double,double > > > class."""

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

    def iterator(self):
        r"""iterator(VectorPairDD self) -> SwigPyIterator"""
        return _libm2k.VectorPairDD_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VectorPairDD self) -> bool"""
        return _libm2k.VectorPairDD___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VectorPairDD self) -> bool"""
        return _libm2k.VectorPairDD___bool__(self)

    def __len__(self):
        r"""__len__(VectorPairDD self) -> std::vector< std::pair< std::string,std::pair< double,double > > >::size_type"""
        return _libm2k.VectorPairDD___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type i, std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type j) -> VectorPairDD

        Parameters
        ----------
        i: std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type
        j: std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type

        """
        return _libm2k.VectorPairDD___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type i, std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type
        j: std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type

        __setslice__(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type i, std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type j, VectorPairDD v)

        Parameters
        ----------
        i: std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type
        j: std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type
        v: std::vector< std::pair< std::string,std::pair< double,double > >,std::allocator< std::pair< std::string,std::pair< double,double > > > > const &

        """
        return _libm2k.VectorPairDD___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type i, std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type j)

        Parameters
        ----------
        i: std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type
        j: std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type

        """
        return _libm2k.VectorPairDD___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type i)

        Parameters
        ----------
        i: std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type

        __delitem__(VectorPairDD self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.VectorPairDD___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VectorPairDD self, PySliceObject * slice) -> VectorPairDD

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type i) -> std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const &

        Parameters
        ----------
        i: std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type

        """
        return _libm2k.VectorPairDD___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VectorPairDD self, PySliceObject * slice, VectorPairDD v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< std::pair< std::string,std::pair< double,double > >,std::allocator< std::pair< std::string,std::pair< double,double > > > > const &

        __setitem__(VectorPairDD self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type i, std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const & x)

        Parameters
        ----------
        i: std::vector< std::pair< std::string,std::pair< double,double > > >::difference_type
        x: std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const &

        """
        return _libm2k.VectorPairDD___setitem__(self, *args)

    def pop(self):
        r"""pop(VectorPairDD self) -> std::vector< std::pair< std::string,std::pair< double,double > > >::value_type"""
        return _libm2k.VectorPairDD_pop(self)

    def append(self, x):
        r"""
        append(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const & x)

        Parameters
        ----------
        x: std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const &

        """
        return _libm2k.VectorPairDD_append(self, x)

    def empty(self):
        r"""empty(VectorPairDD self) -> bool"""
        return _libm2k.VectorPairDD_empty(self)

    def size(self):
        r"""size(VectorPairDD self) -> std::vector< std::pair< std::string,std::pair< double,double > > >::size_type"""
        return _libm2k.VectorPairDD_size(self)

    def swap(self, v):
        r"""
        swap(VectorPairDD self, VectorPairDD v)

        Parameters
        ----------
        v: std::vector< std::pair< std::string,std::pair< double,double > > > &

        """
        return _libm2k.VectorPairDD_swap(self, v)

    def begin(self):
        r"""begin(VectorPairDD self) -> std::vector< std::pair< std::string,std::pair< double,double > > >::iterator"""
        return _libm2k.VectorPairDD_begin(self)

    def end(self):
        r"""end(VectorPairDD self) -> std::vector< std::pair< std::string,std::pair< double,double > > >::iterator"""
        return _libm2k.VectorPairDD_end(self)

    def rbegin(self):
        r"""rbegin(VectorPairDD self) -> std::vector< std::pair< std::string,std::pair< double,double > > >::reverse_iterator"""
        return _libm2k.VectorPairDD_rbegin(self)

    def rend(self):
        r"""rend(VectorPairDD self) -> std::vector< std::pair< std::string,std::pair< double,double > > >::reverse_iterator"""
        return _libm2k.VectorPairDD_rend(self)

    def clear(self):
        r"""clear(VectorPairDD self)"""
        return _libm2k.VectorPairDD_clear(self)

    def get_allocator(self):
        r"""get_allocator(VectorPairDD self) -> std::vector< std::pair< std::string,std::pair< double,double > > >::allocator_type"""
        return _libm2k.VectorPairDD_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VectorPairDD self)"""
        return _libm2k.VectorPairDD_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::iterator pos) -> std::vector< std::pair< std::string,std::pair< double,double > > >::iterator

        Parameters
        ----------
        pos: std::vector< std::pair< std::string,std::pair< double,double > > >::iterator

        erase(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::iterator first, std::vector< std::pair< std::string,std::pair< double,double > > >::iterator last) -> std::vector< std::pair< std::string,std::pair< double,double > > >::iterator

        Parameters
        ----------
        first: std::vector< std::pair< std::string,std::pair< double,double > > >::iterator
        last: std::vector< std::pair< std::string,std::pair< double,double > > >::iterator

        """
        return _libm2k.VectorPairDD_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VectorPairDD self) -> VectorPairDD
        __init__(VectorPairDD self, VectorPairDD other) -> VectorPairDD

        Parameters
        ----------
        other: std::vector< std::pair< std::string,std::pair< double,double > > > const &

        __init__(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::size_type size) -> VectorPairDD

        Parameters
        ----------
        size: std::vector< std::pair< std::string,std::pair< double,double > > >::size_type

        __init__(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::size_type size, std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const & value) -> VectorPairDD

        Parameters
        ----------
        size: std::vector< std::pair< std::string,std::pair< double,double > > >::size_type
        value: std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const &

        """
        _libm2k.VectorPairDD_swiginit(self, _libm2k.new_VectorPairDD(*args))

    def push_back(self, x):
        r"""
        push_back(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const & x)

        Parameters
        ----------
        x: std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const &

        """
        return _libm2k.VectorPairDD_push_back(self, x)

    def front(self):
        r"""front(VectorPairDD self) -> std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const &"""
        return _libm2k.VectorPairDD_front(self)

    def back(self):
        r"""back(VectorPairDD self) -> std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const &"""
        return _libm2k.VectorPairDD_back(self)

    def assign(self, n, x):
        r"""
        assign(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::size_type n, std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const & x)

        Parameters
        ----------
        n: std::vector< std::pair< std::string,std::pair< double,double > > >::size_type
        x: std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const &

        """
        return _libm2k.VectorPairDD_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< std::pair< std::string,std::pair< double,double > > >::size_type

        resize(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::size_type new_size, std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< std::pair< std::string,std::pair< double,double > > >::size_type
        x: std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const &

        """
        return _libm2k.VectorPairDD_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::iterator pos, std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const & x) -> std::vector< std::pair< std::string,std::pair< double,double > > >::iterator

        Parameters
        ----------
        pos: std::vector< std::pair< std::string,std::pair< double,double > > >::iterator
        x: std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const &

        insert(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::iterator pos, std::vector< std::pair< std::string,std::pair< double,double > > >::size_type n, std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< std::pair< std::string,std::pair< double,double > > >::iterator
        n: std::vector< std::pair< std::string,std::pair< double,double > > >::size_type
        x: std::vector< std::pair< std::string,std::pair< double,double > > >::value_type const &

        """
        return _libm2k.VectorPairDD_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(VectorPairDD self, std::vector< std::pair< std::string,std::pair< double,double > > >::size_type n)

        Parameters
        ----------
        n: std::vector< std::pair< std::string,std::pair< double,double > > >::size_type

        """
        return _libm2k.VectorPairDD_reserve(self, n)

    def capacity(self):
        r"""capacity(VectorPairDD self) -> std::vector< std::pair< std::string,std::pair< double,double > > >::size_type"""
        return _libm2k.VectorPairDD_capacity(self)
    __swig_destroy__ = _libm2k.delete_VectorPairDD

# Register VectorPairDD in _libm2k:
_libm2k.VectorPairDD_swigregister(VectorPairDD)


def spi_init(param):
    r"""
    spi_init(spi_init_param param) -> spi_desc

    Parameters
    ----------
    param: spi_init_param const *

    """
    return _libm2k.spi_init(param)

def i2c_init(param):
    r"""
    i2c_init(i2c_init_param param) -> i2c_desc

    Parameters
    ----------
    param: i2c_init_param const *

    """
    return _libm2k.i2c_init(param)

def uart_init(param):
    r"""
    uart_init(uart_init_param param) -> uart_desc

    Parameters
    ----------
    param: uart_init_param const *

    """
    return _libm2k.uart_init(param)
SHARED_PTR_DISOWN = _libm2k.SHARED_PTR_DISOWN

ADC_REF1 = _libm2k.ADC_REF1

ADC_REF2 = _libm2k.ADC_REF2

ADC_GND = _libm2k.ADC_GND

DAC = _libm2k.DAC

NONE = _libm2k.NONE

LOW_GAIN = _libm2k.LOW_GAIN

HIGH_GAIN = _libm2k.HIGH_GAIN

EXC_OUT_OF_RANGE = _libm2k.EXC_OUT_OF_RANGE

EXC_RUNTIME_ERROR = _libm2k.EXC_RUNTIME_ERROR

EXC_INVALID_PARAMETER = _libm2k.EXC_INVALID_PARAMETER

EXC_TIMEOUT = _libm2k.EXC_TIMEOUT

EXC_INVALID_FIRMWARE_VERSION = _libm2k.EXC_INVALID_FIRMWARE_VERSION

RISING_EDGE_ANALOG = _libm2k.RISING_EDGE_ANALOG

FALLING_EDGE_ANALOG = _libm2k.FALLING_EDGE_ANALOG

LOW_LEVEL_ANALOG = _libm2k.LOW_LEVEL_ANALOG

HIGH_LEVEL_ANALOG = _libm2k.HIGH_LEVEL_ANALOG

RISING_EDGE_DIGITAL = _libm2k.RISING_EDGE_DIGITAL

FALLING_EDGE_DIGITAL = _libm2k.FALLING_EDGE_DIGITAL

LOW_LEVEL_DIGITAL = _libm2k.LOW_LEVEL_DIGITAL

HIGH_LEVEL_DIGITAL = _libm2k.HIGH_LEVEL_DIGITAL

ANY_EDGE_DIGITAL = _libm2k.ANY_EDGE_DIGITAL

NO_TRIGGER_DIGITAL = _libm2k.NO_TRIGGER_DIGITAL

ALWAYS = _libm2k.ALWAYS

ANALOG = _libm2k.ANALOG

EXTERNAL = _libm2k.EXTERNAL

DIGITAL_OR_ANALOG = _libm2k.DIGITAL_OR_ANALOG

DIGITAL_AND_ANALOG = _libm2k.DIGITAL_AND_ANALOG

DIGITAL_XOR_ANALOG = _libm2k.DIGITAL_XOR_ANALOG

N_DIGITAL_OR_ANALOG = _libm2k.N_DIGITAL_OR_ANALOG

N_DIGITAL_AND_ANALOG = _libm2k.N_DIGITAL_AND_ANALOG

N_DIGITAL_XOR_ANALOG = _libm2k.N_DIGITAL_XOR_ANALOG

CHANNEL_1 = _libm2k.CHANNEL_1

CHANNEL_2 = _libm2k.CHANNEL_2

CHANNEL_1_OR_CHANNEL_2 = _libm2k.CHANNEL_1_OR_CHANNEL_2

CHANNEL_1_AND_CHANNEL_2 = _libm2k.CHANNEL_1_AND_CHANNEL_2

CHANNEL_1_XOR_CHANNEL_2 = _libm2k.CHANNEL_1_XOR_CHANNEL_2

SRC_DIGITAL_IN = _libm2k.SRC_DIGITAL_IN

CHANNEL_1_OR_SRC_LOGIC_ANALYZER = _libm2k.CHANNEL_1_OR_SRC_LOGIC_ANALYZER

CHANNEL_2_OR_SRC_LOGIC_ANALYZER = _libm2k.CHANNEL_2_OR_SRC_LOGIC_ANALYZER

CHANNEL_1_OR_CHANNEL_2_OR_SRC_LOGIC_ANALYZER = _libm2k.CHANNEL_1_OR_CHANNEL_2_OR_SRC_LOGIC_ANALYZER

NO_SOURCE = _libm2k.NO_SOURCE

SRC_TRIGGER_IN = _libm2k.SRC_TRIGGER_IN

SRC_ANALOG_IN = _libm2k.SRC_ANALOG_IN

SRC_NONE = _libm2k.SRC_NONE

SRC_DISABLED = _libm2k.SRC_DISABLED

SELECT_NONE = _libm2k.SELECT_NONE

SELECT_TRIGGER_I_SAME_CHAN = _libm2k.SELECT_TRIGGER_I_SAME_CHAN

SELECT_TRIGGER_IN = _libm2k.SELECT_TRIGGER_IN

SELECT_ANALOG_IN = _libm2k.SELECT_ANALOG_IN

SELECT_DIGITAL_IN = _libm2k.SELECT_DIGITAL_IN

class SETTINGS(object):
    r"""Proxy of C++ libm2k::SETTINGS class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    analog_condition = property(_libm2k.SETTINGS_analog_condition_get, _libm2k.SETTINGS_analog_condition_set, doc=r"""analog_condition : std::vector<(libm2k::M2K_TRIGGER_CONDITION_ANALOG,std::allocator<(libm2k::M2K_TRIGGER_CONDITION_ANALOG)>)>""")
    digital_condition = property(_libm2k.SETTINGS_digital_condition_get, _libm2k.SETTINGS_digital_condition_set, doc=r"""digital_condition : std::vector<(libm2k::M2K_TRIGGER_CONDITION_DIGITAL,std::allocator<(libm2k::M2K_TRIGGER_CONDITION_DIGITAL)>)>""")
    raw_level = property(_libm2k.SETTINGS_raw_level_get, _libm2k.SETTINGS_raw_level_set, doc=r"""raw_level : std::vector<(int,std::allocator<(int)>)>""")
    level = property(_libm2k.SETTINGS_level_get, _libm2k.SETTINGS_level_set, doc=r"""level : std::vector<(double,std::allocator<(double)>)>""")
    hysteresis = property(_libm2k.SETTINGS_hysteresis_get, _libm2k.SETTINGS_hysteresis_set, doc=r"""hysteresis : std::vector<(double,std::allocator<(double)>)>""")
    mode = property(_libm2k.SETTINGS_mode_get, _libm2k.SETTINGS_mode_set, doc=r"""mode : std::vector<(libm2k::M2K_TRIGGER_MODE,std::allocator<(libm2k::M2K_TRIGGER_MODE)>)>""")
    trigger_source = property(_libm2k.SETTINGS_trigger_source_get, _libm2k.SETTINGS_trigger_source_set, doc=r"""trigger_source : libm2k::M2K_TRIGGER_SOURCE_ANALOG""")
    delay = property(_libm2k.SETTINGS_delay_get, _libm2k.SETTINGS_delay_set, doc=r"""delay : int""")

    def __init__(self):
        r"""__init__(SETTINGS self) -> SETTINGS"""
        _libm2k.SETTINGS_swiginit(self, _libm2k.new_SETTINGS())
    __swig_destroy__ = _libm2k.delete_SETTINGS

# Register SETTINGS in _libm2k:
_libm2k.SETTINGS_swigregister(SETTINGS)

class CONTEXT_INFO(object):
    r"""Proxy of C++ libm2k::CONTEXT_INFO class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    id_vendor = property(_libm2k.CONTEXT_INFO_id_vendor_get, _libm2k.CONTEXT_INFO_id_vendor_set, doc=r"""id_vendor : std::string""")
    id_product = property(_libm2k.CONTEXT_INFO_id_product_get, _libm2k.CONTEXT_INFO_id_product_set, doc=r"""id_product : std::string""")
    manufacturer = property(_libm2k.CONTEXT_INFO_manufacturer_get, _libm2k.CONTEXT_INFO_manufacturer_set, doc=r"""manufacturer : std::string""")
    product = property(_libm2k.CONTEXT_INFO_product_get, _libm2k.CONTEXT_INFO_product_set, doc=r"""product : std::string""")
    serial = property(_libm2k.CONTEXT_INFO_serial_get, _libm2k.CONTEXT_INFO_serial_set, doc=r"""serial : std::string""")
    uri = property(_libm2k.CONTEXT_INFO_uri_get, _libm2k.CONTEXT_INFO_uri_set, doc=r"""uri : std::string""")

    def __init__(self):
        r"""__init__(CONTEXT_INFO self) -> CONTEXT_INFO"""
        _libm2k.CONTEXT_INFO_swiginit(self, _libm2k.new_CONTEXT_INFO())
    __swig_destroy__ = _libm2k.delete_CONTEXT_INFO

# Register CONTEXT_INFO in _libm2k:
_libm2k.CONTEXT_INFO_swigregister(CONTEXT_INFO)

class IIO_OBJECTS(object):
    r"""Proxy of C++ libm2k::IIO_OBJECTS class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    channels_in = property(_libm2k.IIO_OBJECTS_channels_in_get, _libm2k.IIO_OBJECTS_channels_in_set, doc=r"""channels_in : std::vector<(p.iio_channel,std::allocator<(p.iio_channel)>)>""")
    channels_out = property(_libm2k.IIO_OBJECTS_channels_out_get, _libm2k.IIO_OBJECTS_channels_out_set, doc=r"""channels_out : std::vector<(p.iio_channel,std::allocator<(p.iio_channel)>)>""")
    devices = property(_libm2k.IIO_OBJECTS_devices_get, _libm2k.IIO_OBJECTS_devices_set, doc=r"""devices : std::vector<(p.iio_device,std::allocator<(p.iio_device)>)>""")
    buffers_rx = property(_libm2k.IIO_OBJECTS_buffers_rx_get, _libm2k.IIO_OBJECTS_buffers_rx_set, doc=r"""buffers_rx : std::vector<(p.iio_buffer,std::allocator<(p.iio_buffer)>)>""")
    buffers_tx = property(_libm2k.IIO_OBJECTS_buffers_tx_get, _libm2k.IIO_OBJECTS_buffers_tx_set, doc=r"""buffers_tx : std::vector<(p.iio_buffer,std::allocator<(p.iio_buffer)>)>""")
    context = property(_libm2k.IIO_OBJECTS_context_get, _libm2k.IIO_OBJECTS_context_set, doc=r"""context : p.iio_context""")

    def __init__(self):
        r"""__init__(IIO_OBJECTS self) -> IIO_OBJECTS"""
        _libm2k.IIO_OBJECTS_swiginit(self, _libm2k.new_IIO_OBJECTS())
    __swig_destroy__ = _libm2k.delete_IIO_OBJECTS

# Register IIO_OBJECTS in _libm2k:
_libm2k.IIO_OBJECTS_swigregister(IIO_OBJECTS)

ANALOG_DEV = _libm2k.ANALOG_DEV

DIGITAL_DEV = _libm2k.DIGITAL_DEV

NO_DEV = _libm2k.NO_DEV

INPUT = _libm2k.INPUT

OUTPUT = _libm2k.OUTPUT

BOTH = _libm2k.BOTH

NO_DIRECTION = _libm2k.NO_DIRECTION

class ini_device_struct(object):
    r"""Proxy of C++ libm2k::utils::ini_device_struct class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    hw_name = property(_libm2k.ini_device_struct_hw_name_get, _libm2k.ini_device_struct_hw_name_set, doc=r"""hw_name : std::string""")
    key_val_pairs = property(_libm2k.ini_device_struct_key_val_pairs_get, _libm2k.ini_device_struct_key_val_pairs_set, doc=r"""key_val_pairs : std::vector<(std::pair<(std::string,std::vector<(std::string,std::allocator<(std::string)>)>)>,std::allocator<(std::pair<(std::string,std::vector<(std::string,std::allocator<(std::string)>)>)>)>)>""")

    def __init__(self):
        r"""__init__(ini_device_struct self) -> ini_device_struct"""
        _libm2k.ini_device_struct_swiginit(self, _libm2k.new_ini_device_struct())
    __swig_destroy__ = _libm2k.delete_ini_device_struct

# Register ini_device_struct in _libm2k:
_libm2k.ini_device_struct_swigregister(ini_device_struct)

class DMM(object):
    r"""Proxy of C++ libm2k::analog::DMM class."""

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

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

    def reset(self):
        r"""reset(DMM self)"""
        return _libm2k.DMM_reset(self)

    def getAllChannels(self):
        r"""getAllChannels(DMM self) -> VectorStr"""
        return _libm2k.DMM_getAllChannels(self)

    def readChannel(self, *args):
        r"""
        readChannel(DMM self, unsigned int index) -> DMM_READING

        Parameters
        ----------
        index: unsigned int

        readChannel(DMM self, std::string chn_name) -> DMM_READING

        Parameters
        ----------
        chn_name: std::string

        """
        return _libm2k.DMM_readChannel(self, *args)

    def readAll(self):
        r"""readAll(DMM self) -> DMMReading"""
        return _libm2k.DMM_readAll(self)

    def getName(self):
        r"""getName(DMM self) -> std::string"""
        return _libm2k.DMM_getName(self)

# Register DMM in _libm2k:
_libm2k.DMM_swigregister(DMM)

class DMM_READING(object):
    r"""Proxy of C++ libm2k::analog::DMM_READING class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    name = property(_libm2k.DMM_READING_name_get, _libm2k.DMM_READING_name_set, doc=r"""name : std::string""")
    id = property(_libm2k.DMM_READING_id_get, _libm2k.DMM_READING_id_set, doc=r"""id : std::string""")
    value = property(_libm2k.DMM_READING_value_get, _libm2k.DMM_READING_value_set, doc=r"""value : double""")
    unit = property(_libm2k.DMM_READING_unit_get, _libm2k.DMM_READING_unit_set, doc=r"""unit : std::string""")

    def __init__(self):
        r"""__init__(DMM_READING self) -> DMM_READING"""
        _libm2k.DMM_READING_swiginit(self, _libm2k.new_DMM_READING())
    __swig_destroy__ = _libm2k.delete_DMM_READING

# Register DMM_READING in _libm2k:
_libm2k.DMM_READING_swigregister(DMM_READING)

ANALOG_IN_CHANNEL_1 = _libm2k.ANALOG_IN_CHANNEL_1

ANALOG_IN_CHANNEL_2 = _libm2k.ANALOG_IN_CHANNEL_2

PLUS_MINUS_25V = _libm2k.PLUS_MINUS_25V

PLUS_MINUS_2_5V = _libm2k.PLUS_MINUS_2_5V

class GenericAnalogIn(object):
    r"""Proxy of C++ libm2k::analog::GenericAnalogIn class."""

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

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

    def getSamplesInterleaved(self, nb_samples):
        r"""
        getSamplesInterleaved(GenericAnalogIn self, unsigned int nb_samples) -> double const *

        Parameters
        ----------
        nb_samples: unsigned int

        """
        return _libm2k.GenericAnalogIn_getSamplesInterleaved(self, nb_samples)

    def getSamplesRawInterleaved(self, nb_samples):
        r"""
        getSamplesRawInterleaved(GenericAnalogIn self, unsigned int nb_samples) -> short const *

        Parameters
        ----------
        nb_samples: unsigned int

        """
        return _libm2k.GenericAnalogIn_getSamplesRawInterleaved(self, nb_samples)

    def getSampleRate(self, *args):
        r"""
        getSampleRate(GenericAnalogIn self) -> double
        getSampleRate(GenericAnalogIn self, unsigned int arg2) -> double

        Parameters
        ----------
        arg2: unsigned int

        """
        return _libm2k.GenericAnalogIn_getSampleRate(self, *args)

    def setSampleRate(self, *args):
        r"""
        setSampleRate(GenericAnalogIn self, double sampleRate) -> double

        Parameters
        ----------
        sampleRate: double

        setSampleRate(GenericAnalogIn self, unsigned int chn_idx, double sampleRate) -> double

        Parameters
        ----------
        chn_idx: unsigned int
        sampleRate: double

        """
        return _libm2k.GenericAnalogIn_setSampleRate(self, *args)

    def getAvailableSampleRates(self, *args):
        r"""
        getAvailableSampleRates(GenericAnalogIn self) -> VectorD
        getAvailableSampleRates(GenericAnalogIn self, unsigned int chn_idx) -> VectorD

        Parameters
        ----------
        chn_idx: unsigned int

        """
        return _libm2k.GenericAnalogIn_getAvailableSampleRates(self, *args)

    def getMaximumSamplerate(self, *args):
        r"""
        getMaximumSamplerate(GenericAnalogIn self) -> double
        getMaximumSamplerate(GenericAnalogIn self, unsigned int chn_idx) -> double

        Parameters
        ----------
        chn_idx: unsigned int

        """
        return _libm2k.GenericAnalogIn_getMaximumSamplerate(self, *args)

    def enableChannel(self, index, enable):
        r"""
        enableChannel(GenericAnalogIn self, unsigned int index, bool enable)

        Parameters
        ----------
        index: unsigned int
        enable: bool

        """
        return _libm2k.GenericAnalogIn_enableChannel(self, index, enable)

    def setKernelBuffersCount(self, count):
        r"""
        setKernelBuffersCount(GenericAnalogIn self, unsigned int count)

        Parameters
        ----------
        count: unsigned int

        """
        return _libm2k.GenericAnalogIn_setKernelBuffersCount(self, count)

    def getDeviceName(self):
        r"""getDeviceName(GenericAnalogIn self) -> std::string"""
        return _libm2k.GenericAnalogIn_getDeviceName(self)

    def getIioObjects(self):
        r"""getIioObjects(GenericAnalogIn self) -> IIO_OBJECTS"""
        return _libm2k.GenericAnalogIn_getIioObjects(self)

    def getNbChannels(self):
        r"""getNbChannels(GenericAnalogIn self) -> unsigned int"""
        return _libm2k.GenericAnalogIn_getNbChannels(self)

# Register GenericAnalogIn in _libm2k:
_libm2k.GenericAnalogIn_swigregister(GenericAnalogIn)

class GenericAnalogOut(object):
    r"""Proxy of C++ libm2k::analog::GenericAnalogOut class."""

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

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

    def getSampleRate(self, *args):
        r"""
        getSampleRate(GenericAnalogOut self) -> double
        getSampleRate(GenericAnalogOut self, unsigned int arg2) -> double

        Parameters
        ----------
        arg2: unsigned int

        """
        return _libm2k.GenericAnalogOut_getSampleRate(self, *args)

    def setSampleRate(self, *args):
        r"""
        setSampleRate(GenericAnalogOut self, double sampleRate) -> double

        Parameters
        ----------
        sampleRate: double

        setSampleRate(GenericAnalogOut self, unsigned int chn_idx, double sampleRate) -> double

        Parameters
        ----------
        chn_idx: unsigned int
        sampleRate: double

        """
        return _libm2k.GenericAnalogOut_setSampleRate(self, *args)

    def getAvailableSampleRates(self):
        r"""getAvailableSampleRates(GenericAnalogOut self) -> VectorD"""
        return _libm2k.GenericAnalogOut_getAvailableSampleRates(self)

    def setCyclic(self, *args):
        r"""
        setCyclic(GenericAnalogOut self, bool en)

        Parameters
        ----------
        en: bool

        setCyclic(GenericAnalogOut self, unsigned int chn, bool en)

        Parameters
        ----------
        chn: unsigned int
        en: bool

        """
        return _libm2k.GenericAnalogOut_setCyclic(self, *args)

    def getCyclic(self, chn):
        r"""
        getCyclic(GenericAnalogOut self, unsigned int chn) -> bool

        Parameters
        ----------
        chn: unsigned int

        """
        return _libm2k.GenericAnalogOut_getCyclic(self, chn)

    def push(self, *args):
        r"""
        push(GenericAnalogOut self, unsigned int chn_idx, VectorD data)

        Parameters
        ----------
        chn_idx: unsigned int
        data: std::vector< double,std::allocator< double > > const &

        push(GenericAnalogOut self, unsigned int chn_idx, double * data, unsigned int nb_samples)

        Parameters
        ----------
        chn_idx: unsigned int
        data: double *
        nb_samples: unsigned int

        """
        return _libm2k.GenericAnalogOut_push(self, *args)

    def pushRaw(self, *args):
        r"""
        pushRaw(GenericAnalogOut self, unsigned int chn_idx, VectorS data)

        Parameters
        ----------
        chn_idx: unsigned int
        data: std::vector< short,std::allocator< short > > const &

        pushRaw(GenericAnalogOut self, unsigned int chn_idx, short * data, unsigned int nb_samples)

        Parameters
        ----------
        chn_idx: unsigned int
        data: short *
        nb_samples: unsigned int

        """
        return _libm2k.GenericAnalogOut_pushRaw(self, *args)

    def stop(self):
        r"""stop(GenericAnalogOut self)"""
        return _libm2k.GenericAnalogOut_stop(self)

    def getName(self):
        r"""getName(GenericAnalogOut self) -> std::string"""
        return _libm2k.GenericAnalogOut_getName(self)

    def enableChannel(self, chnIdx, enable):
        r"""
        enableChannel(GenericAnalogOut self, unsigned int chnIdx, bool enable)

        Parameters
        ----------
        chnIdx: unsigned int
        enable: bool

        """
        return _libm2k.GenericAnalogOut_enableChannel(self, chnIdx, enable)

    def isChannelEnabled(self, chnIdx):
        r"""
        isChannelEnabled(GenericAnalogOut self, unsigned int chnIdx) -> bool

        Parameters
        ----------
        chnIdx: unsigned int

        """
        return _libm2k.GenericAnalogOut_isChannelEnabled(self, chnIdx)

# Register GenericAnalogOut in _libm2k:
_libm2k.GenericAnalogOut_swigregister(GenericAnalogOut)

class M2kHardwareTrigger(object):
    r"""Proxy of C++ libm2k::M2kHardwareTrigger class."""

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

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

    def reset(self):
        r"""reset(M2kHardwareTrigger self)"""
        return _libm2k.M2kHardwareTrigger_reset(self)

    def getAnalogLevelRaw(self, chnIdx):
        r"""
        getAnalogLevelRaw(M2kHardwareTrigger self, unsigned int chnIdx) -> int

        Parameters
        ----------
        chnIdx: unsigned int

        """
        return _libm2k.M2kHardwareTrigger_getAnalogLevelRaw(self, chnIdx)

    def setAnalogLevelRaw(self, chnIdx, level):
        r"""
        setAnalogLevelRaw(M2kHardwareTrigger self, unsigned int chnIdx, int level)

        Parameters
        ----------
        chnIdx: unsigned int
        level: int

        """
        return _libm2k.M2kHardwareTrigger_setAnalogLevelRaw(self, chnIdx, level)

    def setAnalogLevel(self, chnIdx, v_level):
        r"""
        setAnalogLevel(M2kHardwareTrigger self, unsigned int chnIdx, double v_level)

        Parameters
        ----------
        chnIdx: unsigned int
        v_level: double

        """
        return _libm2k.M2kHardwareTrigger_setAnalogLevel(self, chnIdx, v_level)

    def getAnalogLevel(self, chnIdx):
        r"""
        getAnalogLevel(M2kHardwareTrigger self, unsigned int chnIdx) -> double

        Parameters
        ----------
        chnIdx: unsigned int

        """
        return _libm2k.M2kHardwareTrigger_getAnalogLevel(self, chnIdx)

    def getAnalogHysteresis(self, chnIdx):
        r"""
        getAnalogHysteresis(M2kHardwareTrigger self, unsigned int chnIdx) -> double

        Parameters
        ----------
        chnIdx: unsigned int

        """
        return _libm2k.M2kHardwareTrigger_getAnalogHysteresis(self, chnIdx)

    def setAnalogHysteresis(self, chnIdx, hysteresis):
        r"""
        setAnalogHysteresis(M2kHardwareTrigger self, unsigned int chnIdx, double hysteresis)

        Parameters
        ----------
        chnIdx: unsigned int
        hysteresis: double

        """
        return _libm2k.M2kHardwareTrigger_setAnalogHysteresis(self, chnIdx, hysteresis)

    def getAnalogCondition(self, chnIdx):
        r"""
        getAnalogCondition(M2kHardwareTrigger self, unsigned int chnIdx) -> libm2k::M2K_TRIGGER_CONDITION_ANALOG

        Parameters
        ----------
        chnIdx: unsigned int

        """
        return _libm2k.M2kHardwareTrigger_getAnalogCondition(self, chnIdx)

    def setAnalogCondition(self, chnIdx, cond):
        r"""
        setAnalogCondition(M2kHardwareTrigger self, unsigned int chnIdx, libm2k::M2K_TRIGGER_CONDITION_ANALOG cond)

        Parameters
        ----------
        chnIdx: unsigned int
        cond: enum libm2k::M2K_TRIGGER_CONDITION_ANALOG

        """
        return _libm2k.M2kHardwareTrigger_setAnalogCondition(self, chnIdx, cond)

    def getDigitalCondition(self, chnIdx):
        r"""
        getDigitalCondition(M2kHardwareTrigger self, unsigned int chnIdx) -> libm2k::M2K_TRIGGER_CONDITION_DIGITAL

        Parameters
        ----------
        chnIdx: unsigned int

        """
        return _libm2k.M2kHardwareTrigger_getDigitalCondition(self, chnIdx)

    def setDigitalCondition(self, chnIdx, cond):
        r"""
        setDigitalCondition(M2kHardwareTrigger self, unsigned int chnIdx, libm2k::M2K_TRIGGER_CONDITION_DIGITAL cond)

        Parameters
        ----------
        chnIdx: unsigned int
        cond: enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL

        """
        return _libm2k.M2kHardwareTrigger_setDigitalCondition(self, chnIdx, cond)

    def getAnalogMode(self, chnIdx):
        r"""
        getAnalogMode(M2kHardwareTrigger self, unsigned int chnIdx) -> libm2k::M2K_TRIGGER_MODE

        Parameters
        ----------
        chnIdx: unsigned int

        """
        return _libm2k.M2kHardwareTrigger_getAnalogMode(self, chnIdx)

    def setAnalogMode(self, chnIdx, mode):
        r"""
        setAnalogMode(M2kHardwareTrigger self, unsigned int chnIdx, libm2k::M2K_TRIGGER_MODE mode)

        Parameters
        ----------
        chnIdx: unsigned int
        mode: enum libm2k::M2K_TRIGGER_MODE

        """
        return _libm2k.M2kHardwareTrigger_setAnalogMode(self, chnIdx, mode)

    def getDigitalMode(self):
        r"""getDigitalMode(M2kHardwareTrigger self) -> libm2k::digital::DIO_TRIGGER_MODE"""
        return _libm2k.M2kHardwareTrigger_getDigitalMode(self)

    def setDigitalMode(self, mode):
        r"""
        setDigitalMode(M2kHardwareTrigger self, libm2k::digital::DIO_TRIGGER_MODE mode)

        Parameters
        ----------
        mode: enum libm2k::digital::DIO_TRIGGER_MODE

        """
        return _libm2k.M2kHardwareTrigger_setDigitalMode(self, mode)

    def getAnalogSource(self):
        r"""getAnalogSource(M2kHardwareTrigger self) -> libm2k::M2K_TRIGGER_SOURCE_ANALOG"""
        return _libm2k.M2kHardwareTrigger_getAnalogSource(self)

    def setAnalogSource(self, src):
        r"""
        setAnalogSource(M2kHardwareTrigger self, libm2k::M2K_TRIGGER_SOURCE_ANALOG src)

        Parameters
        ----------
        src: enum libm2k::M2K_TRIGGER_SOURCE_ANALOG

        """
        return _libm2k.M2kHardwareTrigger_setAnalogSource(self, src)

    def getAnalogSourceChannel(self):
        r"""getAnalogSourceChannel(M2kHardwareTrigger self) -> int"""
        return _libm2k.M2kHardwareTrigger_getAnalogSourceChannel(self)

    def setAnalogSourceChannel(self, chnIdx):
        r"""
        setAnalogSourceChannel(M2kHardwareTrigger self, unsigned int chnIdx)

        Parameters
        ----------
        chnIdx: unsigned int

        """
        return _libm2k.M2kHardwareTrigger_setAnalogSourceChannel(self, chnIdx)

    def getAnalogDelay(self):
        r"""getAnalogDelay(M2kHardwareTrigger self) -> int"""
        return _libm2k.M2kHardwareTrigger_getAnalogDelay(self)

    def setAnalogDelay(self, delay):
        r"""
        setAnalogDelay(M2kHardwareTrigger self, int delay)

        Parameters
        ----------
        delay: int

        """
        return _libm2k.M2kHardwareTrigger_setAnalogDelay(self, delay)

    def getDigitalDelay(self):
        r"""getDigitalDelay(M2kHardwareTrigger self) -> int"""
        return _libm2k.M2kHardwareTrigger_getDigitalDelay(self)

    def setDigitalDelay(self, delay):
        r"""
        setDigitalDelay(M2kHardwareTrigger self, int delay)

        Parameters
        ----------
        delay: int

        """
        return _libm2k.M2kHardwareTrigger_setDigitalDelay(self, delay)

    def getCurrentHwSettings(self):
        r"""getCurrentHwSettings(M2kHardwareTrigger self) -> SETTINGS"""
        return _libm2k.M2kHardwareTrigger_getCurrentHwSettings(self)

    def setHwTriggerSettings(self, settings):
        r"""
        setHwTriggerSettings(M2kHardwareTrigger self, SETTINGS settings)

        Parameters
        ----------
        settings: libm2k::SETTINGS *

        """
        return _libm2k.M2kHardwareTrigger_setHwTriggerSettings(self, settings)

    def setAnalogStreamingFlag(self, enable):
        r"""
        setAnalogStreamingFlag(M2kHardwareTrigger self, bool enable)

        Parameters
        ----------
        enable: bool

        """
        return _libm2k.M2kHardwareTrigger_setAnalogStreamingFlag(self, enable)

    def getAnalogStreamingFlag(self):
        r"""getAnalogStreamingFlag(M2kHardwareTrigger self) -> bool"""
        return _libm2k.M2kHardwareTrigger_getAnalogStreamingFlag(self)

    def setDigitalStreamingFlag(self, enable):
        r"""
        setDigitalStreamingFlag(M2kHardwareTrigger self, bool enable)

        Parameters
        ----------
        enable: bool

        """
        return _libm2k.M2kHardwareTrigger_setDigitalStreamingFlag(self, enable)

    def getDigitalStreamingFlag(self):
        r"""getDigitalStreamingFlag(M2kHardwareTrigger self) -> bool"""
        return _libm2k.M2kHardwareTrigger_getDigitalStreamingFlag(self)

    def setCalibParameters(self, chnIdx, scaling, vert_offset):
        r"""
        setCalibParameters(M2kHardwareTrigger self, unsigned int chnIdx, double scaling, double vert_offset)

        Parameters
        ----------
        chnIdx: unsigned int
        scaling: double
        vert_offset: double

        """
        return _libm2k.M2kHardwareTrigger_setCalibParameters(self, chnIdx, scaling, vert_offset)

    def getAnalogExternalCondition(self, chnIdx):
        r"""
        getAnalogExternalCondition(M2kHardwareTrigger self, unsigned int chnIdx) -> libm2k::M2K_TRIGGER_CONDITION_DIGITAL

        Parameters
        ----------
        chnIdx: unsigned int

        """
        return _libm2k.M2kHardwareTrigger_getAnalogExternalCondition(self, chnIdx)

    def setAnalogExternalCondition(self, chnIdx, cond):
        r"""
        setAnalogExternalCondition(M2kHardwareTrigger self, unsigned int chnIdx, libm2k::M2K_TRIGGER_CONDITION_DIGITAL cond)

        Parameters
        ----------
        chnIdx: unsigned int
        cond: enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL

        """
        return _libm2k.M2kHardwareTrigger_setAnalogExternalCondition(self, chnIdx, cond)

    def getDigitalExternalCondition(self):
        r"""getDigitalExternalCondition(M2kHardwareTrigger self) -> libm2k::M2K_TRIGGER_CONDITION_DIGITAL"""
        return _libm2k.M2kHardwareTrigger_getDigitalExternalCondition(self)

    def setDigitalExternalCondition(self, cond):
        r"""
        setDigitalExternalCondition(M2kHardwareTrigger self, libm2k::M2K_TRIGGER_CONDITION_DIGITAL cond)

        Parameters
        ----------
        cond: enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL

        """
        return _libm2k.M2kHardwareTrigger_setDigitalExternalCondition(self, cond)

    def setAnalogExternalOutSelect(self, output_select):
        r"""
        setAnalogExternalOutSelect(M2kHardwareTrigger self, libm2k::M2K_TRIGGER_OUT_SELECT output_select)

        Parameters
        ----------
        output_select: enum libm2k::M2K_TRIGGER_OUT_SELECT

        """
        return _libm2k.M2kHardwareTrigger_setAnalogExternalOutSelect(self, output_select)

    def getAnalogExternalOutSelect(self):
        r"""getAnalogExternalOutSelect(M2kHardwareTrigger self) -> libm2k::M2K_TRIGGER_OUT_SELECT"""
        return _libm2k.M2kHardwareTrigger_getAnalogExternalOutSelect(self)

    def hasExternalTriggerIn(self):
        r"""hasExternalTriggerIn(M2kHardwareTrigger self) -> bool"""
        return _libm2k.M2kHardwareTrigger_hasExternalTriggerIn(self)

    def hasExternalTriggerOut(self):
        r"""hasExternalTriggerOut(M2kHardwareTrigger self) -> bool"""
        return _libm2k.M2kHardwareTrigger_hasExternalTriggerOut(self)

    def hasCrossInstrumentTrigger(self):
        r"""hasCrossInstrumentTrigger(M2kHardwareTrigger self) -> bool"""
        return _libm2k.M2kHardwareTrigger_hasCrossInstrumentTrigger(self)

    def setDigitalSource(self, external_src):
        r"""
        setDigitalSource(M2kHardwareTrigger self, libm2k::M2K_TRIGGER_SOURCE_DIGITAL external_src)

        Parameters
        ----------
        external_src: enum libm2k::M2K_TRIGGER_SOURCE_DIGITAL

        """
        return _libm2k.M2kHardwareTrigger_setDigitalSource(self, external_src)

    def getDigitalSource(self):
        r"""getDigitalSource(M2kHardwareTrigger self) -> libm2k::M2K_TRIGGER_SOURCE_DIGITAL"""
        return _libm2k.M2kHardwareTrigger_getDigitalSource(self)

# Register M2kHardwareTrigger in _libm2k:
_libm2k.M2kHardwareTrigger_swigregister(M2kHardwareTrigger)

class M2kAnalogIn(object):
    r"""Proxy of C++ libm2k::analog::M2kAnalogIn class."""

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

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

    def reset(self):
        r"""reset(M2kAnalogIn self)"""
        return _libm2k.M2kAnalogIn_reset(self)

    def startAcquisition(self, nb_samples):
        r"""
        startAcquisition(M2kAnalogIn self, unsigned int nb_samples)

        Parameters
        ----------
        nb_samples: unsigned int

        """
        return _libm2k.M2kAnalogIn_startAcquisition(self, nb_samples)

    def stopAcquisition(self):
        r"""stopAcquisition(M2kAnalogIn self)"""
        return _libm2k.M2kAnalogIn_stopAcquisition(self)

    def getSamplesRaw(self, nb_samples):
        r"""
        getSamplesRaw(M2kAnalogIn self, unsigned int nb_samples) -> VectorVectorD

        Parameters
        ----------
        nb_samples: unsigned int

        """
        return _libm2k.M2kAnalogIn_getSamplesRaw(self, nb_samples)

    def getSamplesInterleaved(self, nb_samples):
        r"""
        getSamplesInterleaved(M2kAnalogIn self, unsigned int nb_samples) -> double const *

        Parameters
        ----------
        nb_samples: unsigned int

        """
        return _libm2k.M2kAnalogIn_getSamplesInterleaved(self, nb_samples)

    def getSamplesRawInterleaved(self, nb_samples):
        r"""
        getSamplesRawInterleaved(M2kAnalogIn self, unsigned int nb_samples) -> short const *

        Parameters
        ----------
        nb_samples: unsigned int

        """
        return _libm2k.M2kAnalogIn_getSamplesRawInterleaved(self, nb_samples)

    def getVoltageRaw(self, *args):
        r"""
        getVoltageRaw(M2kAnalogIn self, unsigned int ch) -> short

        Parameters
        ----------
        ch: unsigned int

        getVoltageRaw(M2kAnalogIn self, libm2k::analog::ANALOG_IN_CHANNEL ch) -> short

        Parameters
        ----------
        ch: enum libm2k::analog::ANALOG_IN_CHANNEL

        getVoltageRaw(M2kAnalogIn self) -> VectorS
        """
        return _libm2k.M2kAnalogIn_getVoltageRaw(self, *args)

    def getVoltage(self, *args):
        r"""
        getVoltage(M2kAnalogIn self, unsigned int ch) -> double

        Parameters
        ----------
        ch: unsigned int

        getVoltage(M2kAnalogIn self, libm2k::analog::ANALOG_IN_CHANNEL ch) -> double

        Parameters
        ----------
        ch: enum libm2k::analog::ANALOG_IN_CHANNEL

        getVoltage(M2kAnalogIn self) -> VectorD
        """
        return _libm2k.M2kAnalogIn_getVoltage(self, *args)

    def setVerticalOffset(self, channel, vertOffset):
        r"""
        setVerticalOffset(M2kAnalogIn self, libm2k::analog::ANALOG_IN_CHANNEL channel, double vertOffset)

        Parameters
        ----------
        channel: enum libm2k::analog::ANALOG_IN_CHANNEL
        vertOffset: double

        """
        return _libm2k.M2kAnalogIn_setVerticalOffset(self, channel, vertOffset)

    def getVerticalOffset(self, channel):
        r"""
        getVerticalOffset(M2kAnalogIn self, libm2k::analog::ANALOG_IN_CHANNEL channel) -> double

        Parameters
        ----------
        channel: enum libm2k::analog::ANALOG_IN_CHANNEL

        """
        return _libm2k.M2kAnalogIn_getVerticalOffset(self, channel)

    def getScalingFactor(self, ch):
        r"""
        getScalingFactor(M2kAnalogIn self, libm2k::analog::ANALOG_IN_CHANNEL ch) -> double

        Parameters
        ----------
        ch: enum libm2k::analog::ANALOG_IN_CHANNEL

        """
        return _libm2k.M2kAnalogIn_getScalingFactor(self, ch)

    def setRange(self, *args):
        r"""
        setRange(M2kAnalogIn self, libm2k::analog::ANALOG_IN_CHANNEL channel, libm2k::analog::M2K_RANGE range)

        Parameters
        ----------
        channel: enum libm2k::analog::ANALOG_IN_CHANNEL
        range: enum libm2k::analog::M2K_RANGE

        setRange(M2kAnalogIn self, libm2k::analog::ANALOG_IN_CHANNEL channel, double min, double max)

        Parameters
        ----------
        channel: enum libm2k::analog::ANALOG_IN_CHANNEL
        min: double
        max: double

        """
        return _libm2k.M2kAnalogIn_setRange(self, *args)

    def getRange(self, channel):
        r"""
        getRange(M2kAnalogIn self, libm2k::analog::ANALOG_IN_CHANNEL channel) -> libm2k::analog::M2K_RANGE

        Parameters
        ----------
        channel: enum libm2k::analog::ANALOG_IN_CHANNEL

        """
        return _libm2k.M2kAnalogIn_getRange(self, channel)

    def getRangeLimits(self, range):
        r"""
        getRangeLimits(M2kAnalogIn self, libm2k::analog::M2K_RANGE range) -> PairDD

        Parameters
        ----------
        range: enum libm2k::analog::M2K_RANGE

        """
        return _libm2k.M2kAnalogIn_getRangeLimits(self, range)

    def getAvailableRanges(self):
        r"""getAvailableRanges(M2kAnalogIn self) -> VectorPairDD"""
        return _libm2k.M2kAnalogIn_getAvailableRanges(self)

    def getOversamplingRatio(self, *args):
        r"""
        getOversamplingRatio(M2kAnalogIn self) -> int
        getOversamplingRatio(M2kAnalogIn self, unsigned int chn_idx) -> int

        Parameters
        ----------
        chn_idx: unsigned int

        """
        return _libm2k.M2kAnalogIn_getOversamplingRatio(self, *args)

    def setOversamplingRatio(self, *args):
        r"""
        setOversamplingRatio(M2kAnalogIn self, int oversampling) -> int

        Parameters
        ----------
        oversampling: int

        setOversamplingRatio(M2kAnalogIn self, unsigned int chn_idx, int oversampling) -> int

        Parameters
        ----------
        chn_idx: unsigned int
        oversampling: int

        """
        return _libm2k.M2kAnalogIn_setOversamplingRatio(self, *args)

    def getSampleRate(self, *args):
        r"""
        getSampleRate(M2kAnalogIn self) -> double
        getSampleRate(M2kAnalogIn self, unsigned int chn_idx) -> double

        Parameters
        ----------
        chn_idx: unsigned int

        """
        return _libm2k.M2kAnalogIn_getSampleRate(self, *args)

    def getAvailableSampleRates(self):
        r"""getAvailableSampleRates(M2kAnalogIn self) -> VectorD"""
        return _libm2k.M2kAnalogIn_getAvailableSampleRates(self)

    def setSampleRate(self, *args):
        r"""
        setSampleRate(M2kAnalogIn self, double samplerate) -> double

        Parameters
        ----------
        samplerate: double

        setSampleRate(M2kAnalogIn self, unsigned int chn_idx, double samplerate) -> double

        Parameters
        ----------
        chn_idx: unsigned int
        samplerate: double

        """
        return _libm2k.M2kAnalogIn_setSampleRate(self, *args)

    def getHysteresisRange(self, chn):
        r"""
        getHysteresisRange(M2kAnalogIn self, libm2k::analog::ANALOG_IN_CHANNEL chn) -> PairDD

        Parameters
        ----------
        chn: enum libm2k::analog::ANALOG_IN_CHANNEL

        """
        return _libm2k.M2kAnalogIn_getHysteresisRange(self, chn)

    def getFilterCompensation(self, samplerate):
        r"""
        getFilterCompensation(M2kAnalogIn self, double samplerate) -> double

        Parameters
        ----------
        samplerate: double

        """
        return _libm2k.M2kAnalogIn_getFilterCompensation(self, samplerate)

    def getValueForRange(self, range):
        r"""
        getValueForRange(M2kAnalogIn self, libm2k::analog::M2K_RANGE range) -> double

        Parameters
        ----------
        range: enum libm2k::analog::M2K_RANGE

        """
        return _libm2k.M2kAnalogIn_getValueForRange(self, range)

    def convertRawToVolts(self, channel, raw):
        r"""
        convertRawToVolts(M2kAnalogIn self, unsigned int channel, short raw) -> double

        Parameters
        ----------
        channel: unsigned int
        raw: short

        """
        return _libm2k.M2kAnalogIn_convertRawToVolts(self, channel, raw)

    def convertVoltsToRaw(self, channel, voltage):
        r"""
        convertVoltsToRaw(M2kAnalogIn self, unsigned int channel, double voltage) -> short

        Parameters
        ----------
        channel: unsigned int
        voltage: double

        """
        return _libm2k.M2kAnalogIn_convertVoltsToRaw(self, channel, voltage)

    def getNbChannels(self):
        r"""getNbChannels(M2kAnalogIn self) -> unsigned int"""
        return _libm2k.M2kAnalogIn_getNbChannels(self)

    def getName(self):
        r"""getName(M2kAnalogIn self) -> std::string"""
        return _libm2k.M2kAnalogIn_getName(self)

    def enableChannel(self, chnIdx, enable):
        r"""
        enableChannel(M2kAnalogIn self, unsigned int chnIdx, bool enable)

        Parameters
        ----------
        chnIdx: unsigned int
        enable: bool

        """
        return _libm2k.M2kAnalogIn_enableChannel(self, chnIdx, enable)

    def isChannelEnabled(self, chnIdx):
        r"""
        isChannelEnabled(M2kAnalogIn self, unsigned int chnIdx) -> bool

        Parameters
        ----------
        chnIdx: unsigned int

        """
        return _libm2k.M2kAnalogIn_isChannelEnabled(self, chnIdx)

    def cancelAcquisition(self):
        r"""cancelAcquisition(M2kAnalogIn self)"""
        return _libm2k.M2kAnalogIn_cancelAcquisition(self)

    def setKernelBuffersCount(self, count):
        r"""
        setKernelBuffersCount(M2kAnalogIn self, unsigned int count)

        Parameters
        ----------
        count: unsigned int

        """
        return _libm2k.M2kAnalogIn_setKernelBuffersCount(self, count)

    def getTrigger(self):
        r"""getTrigger(M2kAnalogIn self) -> M2kHardwareTrigger"""
        return _libm2k.M2kAnalogIn_getTrigger(self)

    def getIioObjects(self):
        r"""getIioObjects(M2kAnalogIn self) -> IIO_OBJECTS"""
        return _libm2k.M2kAnalogIn_getIioObjects(self)

    def getSamples(self, *args):
        r"""
        getSamples(M2kAnalogIn self, unsigned int nb_samples) -> VectorVectorD

        Parameters
        ----------
        nb_samples: unsigned int

        getSamples(M2kAnalogIn self, VectorVectorD data, unsigned int nb_samples)

        Parameters
        ----------
        data: std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > &
        nb_samples: unsigned int

        """
        return _libm2k.M2kAnalogIn_getSamples(self, *args)

    def getChannelName(self, channel):
        r"""
        getChannelName(M2kAnalogIn self, unsigned int channel) -> std::string

        Parameters
        ----------
        channel: unsigned int

        """
        return _libm2k.M2kAnalogIn_getChannelName(self, channel)

    def getMaximumSamplerate(self):
        r"""getMaximumSamplerate(M2kAnalogIn self) -> double"""
        return _libm2k.M2kAnalogIn_getMaximumSamplerate(self)

# Register M2kAnalogIn in _libm2k:
_libm2k.M2kAnalogIn_swigregister(M2kAnalogIn)

class M2kAnalogOut(object):
    r"""Proxy of C++ libm2k::analog::M2kAnalogOut class."""

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

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

    def reset(self):
        r"""reset(M2kAnalogOut self)"""
        return _libm2k.M2kAnalogOut_reset(self)

    def getOversamplingRatio(self, *args):
        r"""
        getOversamplingRatio(M2kAnalogOut self) -> VectorI
        getOversamplingRatio(M2kAnalogOut self, unsigned int chn) -> int

        Parameters
        ----------
        chn: unsigned int

        """
        return _libm2k.M2kAnalogOut_getOversamplingRatio(self, *args)

    def setOversamplingRatio(self, *args):
        r"""
        setOversamplingRatio(M2kAnalogOut self, VectorI oversampling_ratio) -> VectorI

        Parameters
        ----------
        oversampling_ratio: std::vector< int,std::allocator< int > >

        setOversamplingRatio(M2kAnalogOut self, unsigned int chn, int oversampling_ratio) -> int

        Parameters
        ----------
        chn: unsigned int
        oversampling_ratio: int

        """
        return _libm2k.M2kAnalogOut_setOversamplingRatio(self, *args)

    def getSampleRate(self, *args):
        r"""
        getSampleRate(M2kAnalogOut self) -> VectorD
        getSampleRate(M2kAnalogOut self, unsigned int chn) -> double

        Parameters
        ----------
        chn: unsigned int

        """
        return _libm2k.M2kAnalogOut_getSampleRate(self, *args)

    def getAvailableSampleRates(self, chn):
        r"""
        getAvailableSampleRates(M2kAnalogOut self, unsigned int chn) -> VectorD

        Parameters
        ----------
        chn: unsigned int

        """
        return _libm2k.M2kAnalogOut_getAvailableSampleRates(self, chn)

    def setSampleRate(self, *args):
        r"""
        setSampleRate(M2kAnalogOut self, VectorD samplerates) -> VectorD

        Parameters
        ----------
        samplerates: std::vector< double,std::allocator< double > >

        setSampleRate(M2kAnalogOut self, unsigned int chn, double samplerate) -> double

        Parameters
        ----------
        chn: unsigned int
        samplerate: double

        """
        return _libm2k.M2kAnalogOut_setSampleRate(self, *args)

    def setSyncedDma(self, en, chn=-1):
        r"""
        setSyncedDma(M2kAnalogOut self, bool en, int chn=-1)

        Parameters
        ----------
        en: bool
        chn: int

        """
        return _libm2k.M2kAnalogOut_setSyncedDma(self, en, chn)

    def getSyncedDma(self, chn=-1):
        r"""
        getSyncedDma(M2kAnalogOut self, int chn=-1) -> bool

        Parameters
        ----------
        chn: int

        """
        return _libm2k.M2kAnalogOut_getSyncedDma(self, chn)

    def setSyncedStartDma(self, en, chn=-1):
        r"""
        setSyncedStartDma(M2kAnalogOut self, bool en, int chn=-1)

        Parameters
        ----------
        en: bool
        chn: int

        """
        return _libm2k.M2kAnalogOut_setSyncedStartDma(self, en, chn)

    def getSyncedStartDma(self, chn=-1):
        r"""
        getSyncedStartDma(M2kAnalogOut self, int chn=-1) -> bool

        Parameters
        ----------
        chn: int

        """
        return _libm2k.M2kAnalogOut_getSyncedStartDma(self, chn)

    def setCyclic(self, *args):
        r"""
        setCyclic(M2kAnalogOut self, bool en)

        Parameters
        ----------
        en: bool

        setCyclic(M2kAnalogOut self, unsigned int chn, bool en)

        Parameters
        ----------
        chn: unsigned int
        en: bool

        """
        return _libm2k.M2kAnalogOut_setCyclic(self, *args)

    def getCyclic(self, chn):
        r"""
        getCyclic(M2kAnalogOut self, unsigned int chn) -> bool

        Parameters
        ----------
        chn: unsigned int

        """
        return _libm2k.M2kAnalogOut_getCyclic(self, chn)

    def getScalingFactor(self, chn):
        r"""
        getScalingFactor(M2kAnalogOut self, unsigned int chn) -> double

        Parameters
        ----------
        chn: unsigned int

        """
        return _libm2k.M2kAnalogOut_getScalingFactor(self, chn)

    def getFilterCompensation(self, samplerate):
        r"""
        getFilterCompensation(M2kAnalogOut self, double samplerate) -> double

        Parameters
        ----------
        samplerate: double

        """
        return _libm2k.M2kAnalogOut_getFilterCompensation(self, samplerate)

    def pushRawBytes(self, chnIdx, data, nb_samples):
        r"""
        pushRawBytes(M2kAnalogOut self, unsigned int chnIdx, short * data, unsigned int nb_samples)

        Parameters
        ----------
        chnIdx: unsigned int
        data: short *
        nb_samples: unsigned int

        """
        return _libm2k.M2kAnalogOut_pushRawBytes(self, chnIdx, data, nb_samples)

    def push(self, *args):
        r"""
        push(M2kAnalogOut self, unsigned int chnIdx, VectorD data)

        Parameters
        ----------
        chnIdx: unsigned int
        data: std::vector< double,std::allocator< double > > const &

        push(M2kAnalogOut self, VectorVectorD data)

        Parameters
        ----------
        data: std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &

        """
        return _libm2k.M2kAnalogOut_push(self, *args)

    def pushRaw(self, *args):
        r"""
        pushRaw(M2kAnalogOut self, unsigned int chnIdx, VectorS data)

        Parameters
        ----------
        chnIdx: unsigned int
        data: std::vector< short,std::allocator< short > > const &

        pushRaw(M2kAnalogOut self, std::vector< std::vector< short,std::allocator< short > >,std::allocator< std::vector< short,std::allocator< short > > > > const & data)

        Parameters
        ----------
        data: std::vector< std::vector< short,std::allocator< short > >,std::allocator< std::vector< short,std::allocator< short > > > > const &

        """
        return _libm2k.M2kAnalogOut_pushRaw(self, *args)

    def stop(self, *args):
        r"""
        stop(M2kAnalogOut self)
        stop(M2kAnalogOut self, unsigned int chn)

        Parameters
        ----------
        chn: unsigned int

        """
        return _libm2k.M2kAnalogOut_stop(self, *args)

    def cancelBuffer(self, *args):
        r"""
        cancelBuffer(M2kAnalogOut self)
        cancelBuffer(M2kAnalogOut self, unsigned int chn)

        Parameters
        ----------
        chn: unsigned int

        """
        return _libm2k.M2kAnalogOut_cancelBuffer(self, *args)

    def enableChannel(self, chnIdx, enable):
        r"""
        enableChannel(M2kAnalogOut self, unsigned int chnIdx, bool enable)

        Parameters
        ----------
        chnIdx: unsigned int
        enable: bool

        """
        return _libm2k.M2kAnalogOut_enableChannel(self, chnIdx, enable)

    def isChannelEnabled(self, chnIdx):
        r"""
        isChannelEnabled(M2kAnalogOut self, unsigned int chnIdx) -> bool

        Parameters
        ----------
        chnIdx: unsigned int

        """
        return _libm2k.M2kAnalogOut_isChannelEnabled(self, chnIdx)

    def setKernelBuffersCount(self, chnIdx, count):
        r"""
        setKernelBuffersCount(M2kAnalogOut self, unsigned int chnIdx, unsigned int count)

        Parameters
        ----------
        chnIdx: unsigned int
        count: unsigned int

        """
        return _libm2k.M2kAnalogOut_setKernelBuffersCount(self, chnIdx, count)

    def convertVoltsToRaw(self, channel, voltage):
        r"""
        convertVoltsToRaw(M2kAnalogOut self, unsigned int channel, double voltage) -> short

        Parameters
        ----------
        channel: unsigned int
        voltage: double

        """
        return _libm2k.M2kAnalogOut_convertVoltsToRaw(self, channel, voltage)

    def convertRawToVolts(self, channel, raw):
        r"""
        convertRawToVolts(M2kAnalogOut self, unsigned int channel, short raw) -> double

        Parameters
        ----------
        channel: unsigned int
        raw: short

        """
        return _libm2k.M2kAnalogOut_convertRawToVolts(self, channel, raw)

    def getIioObjects(self):
        r"""getIioObjects(M2kAnalogOut self) -> IIO_OBJECTS"""
        return _libm2k.M2kAnalogOut_getIioObjects(self)

    def getNbChannels(self):
        r"""getNbChannels(M2kAnalogOut self) -> unsigned int"""
        return _libm2k.M2kAnalogOut_getNbChannels(self)

    def getChannelName(self, channel):
        r"""
        getChannelName(M2kAnalogOut self, unsigned int channel) -> std::string

        Parameters
        ----------
        channel: unsigned int

        """
        return _libm2k.M2kAnalogOut_getChannelName(self, channel)

    def getMaximumSamplerate(self, chn_idx):
        r"""
        getMaximumSamplerate(M2kAnalogOut self, unsigned int chn_idx) -> double

        Parameters
        ----------
        chn_idx: unsigned int

        """
        return _libm2k.M2kAnalogOut_getMaximumSamplerate(self, chn_idx)

# Register M2kAnalogOut in _libm2k:
_libm2k.M2kAnalogOut_swigregister(M2kAnalogOut)

class M2kPowerSupply(object):
    r"""Proxy of C++ libm2k::analog::M2kPowerSupply class."""

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

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

    def reset(self):
        r"""reset(M2kPowerSupply self)"""
        return _libm2k.M2kPowerSupply_reset(self)

    def enableChannel(self, chn, en):
        r"""
        enableChannel(M2kPowerSupply self, unsigned int chn, bool en)

        Parameters
        ----------
        chn: unsigned int
        en: bool

        """
        return _libm2k.M2kPowerSupply_enableChannel(self, chn, en)

    def enableAll(self, en):
        r"""
        enableAll(M2kPowerSupply self, bool en)

        Parameters
        ----------
        en: bool

        """
        return _libm2k.M2kPowerSupply_enableAll(self, en)

    def readChannel(self, chn):
        r"""
        readChannel(M2kPowerSupply self, unsigned int chn) -> double

        Parameters
        ----------
        chn: unsigned int

        """
        return _libm2k.M2kPowerSupply_readChannel(self, chn)

    def pushChannel(self, chn, value):
        r"""
        pushChannel(M2kPowerSupply self, unsigned int chn, double value)

        Parameters
        ----------
        chn: unsigned int
        value: double

        """
        return _libm2k.M2kPowerSupply_pushChannel(self, chn, value)

    def powerDownDacs(self, powerdown):
        r"""
        powerDownDacs(M2kPowerSupply self, bool powerdown)

        Parameters
        ----------
        powerdown: bool

        """
        return _libm2k.M2kPowerSupply_powerDownDacs(self, powerdown)

    def anyChannelEnabled(self):
        r"""anyChannelEnabled(M2kPowerSupply self) -> bool"""
        return _libm2k.M2kPowerSupply_anyChannelEnabled(self)

# Register M2kPowerSupply in _libm2k:
_libm2k.M2kPowerSupply_swigregister(M2kPowerSupply)

DIO_INPUT = _libm2k.DIO_INPUT

DIO_OUTPUT = _libm2k.DIO_OUTPUT

LOW = _libm2k.LOW

HIGH = _libm2k.HIGH

DIO_CHANNEL_0 = _libm2k.DIO_CHANNEL_0

DIO_CHANNEL_1 = _libm2k.DIO_CHANNEL_1

DIO_CHANNEL_2 = _libm2k.DIO_CHANNEL_2

DIO_CHANNEL_3 = _libm2k.DIO_CHANNEL_3

DIO_CHANNEL_4 = _libm2k.DIO_CHANNEL_4

DIO_CHANNEL_5 = _libm2k.DIO_CHANNEL_5

DIO_CHANNEL_6 = _libm2k.DIO_CHANNEL_6

DIO_CHANNEL_7 = _libm2k.DIO_CHANNEL_7

DIO_CHANNEL_8 = _libm2k.DIO_CHANNEL_8

DIO_CHANNEL_9 = _libm2k.DIO_CHANNEL_9

DIO_CHANNEL_10 = _libm2k.DIO_CHANNEL_10

DIO_CHANNEL_11 = _libm2k.DIO_CHANNEL_11

DIO_CHANNEL_12 = _libm2k.DIO_CHANNEL_12

DIO_CHANNEL_13 = _libm2k.DIO_CHANNEL_13

DIO_CHANNEL_14 = _libm2k.DIO_CHANNEL_14

DIO_CHANNEL_15 = _libm2k.DIO_CHANNEL_15

DIO_OPENDRAIN = _libm2k.DIO_OPENDRAIN

DIO_PUSHPULL = _libm2k.DIO_PUSHPULL

DIO_OR = _libm2k.DIO_OR

DIO_AND = _libm2k.DIO_AND

class channel(object):
    r"""Proxy of C++ libm2k::digital::channel class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    m_channel = property(_libm2k.channel_m_channel_get, _libm2k.channel_m_channel_set, doc=r"""m_channel : p.iio_channel""")
    m_direction = property(_libm2k.channel_m_direction_get, _libm2k.channel_m_direction_set, doc=r"""m_direction : libm2k::digital::DIO_DIRECTION""")

    def __init__(self):
        r"""__init__(channel self) -> channel"""
        _libm2k.channel_swiginit(self, _libm2k.new_channel())
    __swig_destroy__ = _libm2k.delete_channel

# Register channel in _libm2k:
_libm2k.channel_swigregister(channel)

class M2kDigital(object):
    r"""Proxy of C++ libm2k::digital::M2kDigital class."""

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

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

    def reset(self):
        r"""reset(M2kDigital self)"""
        return _libm2k.M2kDigital_reset(self)

    def setDirection(self, *args):
        r"""
        setDirection(M2kDigital self, unsigned short mask)

        Parameters
        ----------
        mask: unsigned short

        setDirection(M2kDigital self, unsigned int index, libm2k::digital::DIO_DIRECTION dir)

        Parameters
        ----------
        index: unsigned int
        dir: enum libm2k::digital::DIO_DIRECTION

        setDirection(M2kDigital self, unsigned int index, bool dir)

        Parameters
        ----------
        index: unsigned int
        dir: bool

        setDirection(M2kDigital self, libm2k::digital::DIO_CHANNEL index, bool dir)

        Parameters
        ----------
        index: enum libm2k::digital::DIO_CHANNEL
        dir: bool

        setDirection(M2kDigital self, libm2k::digital::DIO_CHANNEL index, libm2k::digital::DIO_DIRECTION dir)

        Parameters
        ----------
        index: enum libm2k::digital::DIO_CHANNEL
        dir: enum libm2k::digital::DIO_DIRECTION

        """
        return _libm2k.M2kDigital_setDirection(self, *args)

    def getDirection(self, index):
        r"""
        getDirection(M2kDigital self, libm2k::digital::DIO_CHANNEL index) -> libm2k::digital::DIO_DIRECTION

        Parameters
        ----------
        index: enum libm2k::digital::DIO_CHANNEL

        """
        return _libm2k.M2kDigital_getDirection(self, index)

    def push(self, data):
        r"""
        push(M2kDigital self, VectorUS data)

        Parameters
        ----------
        data: std::vector< unsigned short,std::allocator< unsigned short > > const &

        """
        return _libm2k.M2kDigital_push(self, data)

    def pushBytes(self, data, nb_samples):
        r"""
        pushBytes(M2kDigital self, unsigned short * data, unsigned int nb_samples)

        Parameters
        ----------
        data: unsigned short *
        nb_samples: unsigned int

        """
        return _libm2k.M2kDigital_pushBytes(self, data, nb_samples)

    def setValueRaw(self, *args):
        r"""
        setValueRaw(M2kDigital self, libm2k::digital::DIO_CHANNEL index, libm2k::digital::DIO_LEVEL level)

        Parameters
        ----------
        index: enum libm2k::digital::DIO_CHANNEL
        level: enum libm2k::digital::DIO_LEVEL

        setValueRaw(M2kDigital self, unsigned int index, libm2k::digital::DIO_LEVEL level)

        Parameters
        ----------
        index: unsigned int
        level: enum libm2k::digital::DIO_LEVEL

        setValueRaw(M2kDigital self, libm2k::digital::DIO_CHANNEL index, bool level)

        Parameters
        ----------
        index: enum libm2k::digital::DIO_CHANNEL
        level: bool

        """
        return _libm2k.M2kDigital_setValueRaw(self, *args)

    def getValueRaw(self, *args):
        r"""
        getValueRaw(M2kDigital self, libm2k::digital::DIO_CHANNEL index) -> libm2k::digital::DIO_LEVEL

        Parameters
        ----------
        index: enum libm2k::digital::DIO_CHANNEL

        getValueRaw(M2kDigital self, unsigned int index) -> libm2k::digital::DIO_LEVEL

        Parameters
        ----------
        index: unsigned int

        """
        return _libm2k.M2kDigital_getValueRaw(self, *args)

    def stopBufferOut(self):
        r"""stopBufferOut(M2kDigital self)"""
        return _libm2k.M2kDigital_stopBufferOut(self)

    def startAcquisition(self, nb_samples):
        r"""
        startAcquisition(M2kDigital self, unsigned int nb_samples)

        Parameters
        ----------
        nb_samples: unsigned int

        """
        return _libm2k.M2kDigital_startAcquisition(self, nb_samples)

    def stopAcquisition(self):
        r"""stopAcquisition(M2kDigital self)"""
        return _libm2k.M2kDigital_stopAcquisition(self)

    def cancelAcquisition(self):
        r"""cancelAcquisition(M2kDigital self)"""
        return _libm2k.M2kDigital_cancelAcquisition(self)

    def cancelBufferOut(self):
        r"""cancelBufferOut(M2kDigital self)"""
        return _libm2k.M2kDigital_cancelBufferOut(self)

    def getSamplesP(self, nb_samples):
        r"""
        getSamplesP(M2kDigital self, unsigned int nb_samples) -> unsigned short const *

        Parameters
        ----------
        nb_samples: unsigned int

        """
        return _libm2k.M2kDigital_getSamplesP(self, nb_samples)

    def enableChannel(self, *args):
        r"""
        enableChannel(M2kDigital self, unsigned int index, bool enable)

        Parameters
        ----------
        index: unsigned int
        enable: bool

        enableChannel(M2kDigital self, libm2k::digital::DIO_CHANNEL index, bool enable)

        Parameters
        ----------
        index: enum libm2k::digital::DIO_CHANNEL
        enable: bool

        """
        return _libm2k.M2kDigital_enableChannel(self, *args)

    def enableAllOut(self, enable):
        r"""
        enableAllOut(M2kDigital self, bool enable)

        Parameters
        ----------
        enable: bool

        """
        return _libm2k.M2kDigital_enableAllOut(self, enable)

    def anyChannelEnabled(self, dir):
        r"""
        anyChannelEnabled(M2kDigital self, libm2k::digital::DIO_DIRECTION dir) -> bool

        Parameters
        ----------
        dir: enum libm2k::digital::DIO_DIRECTION

        """
        return _libm2k.M2kDigital_anyChannelEnabled(self, dir)

    def setOutputMode(self, *args):
        r"""
        setOutputMode(M2kDigital self, libm2k::digital::DIO_CHANNEL chn, libm2k::digital::DIO_MODE mode)

        Parameters
        ----------
        chn: enum libm2k::digital::DIO_CHANNEL
        mode: enum libm2k::digital::DIO_MODE

        setOutputMode(M2kDigital self, unsigned int chn, libm2k::digital::DIO_MODE mode)

        Parameters
        ----------
        chn: unsigned int
        mode: enum libm2k::digital::DIO_MODE

        """
        return _libm2k.M2kDigital_setOutputMode(self, *args)

    def getOutputMode(self, *args):
        r"""
        getOutputMode(M2kDigital self, libm2k::digital::DIO_CHANNEL chn) -> libm2k::digital::DIO_MODE

        Parameters
        ----------
        chn: enum libm2k::digital::DIO_CHANNEL

        getOutputMode(M2kDigital self, unsigned int chn) -> libm2k::digital::DIO_MODE

        Parameters
        ----------
        chn: unsigned int

        """
        return _libm2k.M2kDigital_getOutputMode(self, *args)

    def setSampleRateIn(self, samplerate):
        r"""
        setSampleRateIn(M2kDigital self, double samplerate) -> double

        Parameters
        ----------
        samplerate: double

        """
        return _libm2k.M2kDigital_setSampleRateIn(self, samplerate)

    def setSampleRateOut(self, samplerate):
        r"""
        setSampleRateOut(M2kDigital self, double samplerate) -> double

        Parameters
        ----------
        samplerate: double

        """
        return _libm2k.M2kDigital_setSampleRateOut(self, samplerate)

    def getSampleRateIn(self):
        r"""getSampleRateIn(M2kDigital self) -> double"""
        return _libm2k.M2kDigital_getSampleRateIn(self)

    def getSampleRateOut(self):
        r"""getSampleRateOut(M2kDigital self) -> double"""
        return _libm2k.M2kDigital_getSampleRateOut(self)

    def getCyclic(self):
        r"""getCyclic(M2kDigital self) -> bool"""
        return _libm2k.M2kDigital_getCyclic(self)

    def setCyclic(self, cyclic):
        r"""
        setCyclic(M2kDigital self, bool cyclic)

        Parameters
        ----------
        cyclic: bool

        """
        return _libm2k.M2kDigital_setCyclic(self, cyclic)

    def getTrigger(self):
        r"""getTrigger(M2kDigital self) -> M2kHardwareTrigger"""
        return _libm2k.M2kDigital_getTrigger(self)

    def setKernelBuffersCountIn(self, count):
        r"""
        setKernelBuffersCountIn(M2kDigital self, unsigned int count)

        Parameters
        ----------
        count: unsigned int

        """
        return _libm2k.M2kDigital_setKernelBuffersCountIn(self, count)

    def setKernelBuffersCountOut(self, count):
        r"""
        setKernelBuffersCountOut(M2kDigital self, unsigned int count)

        Parameters
        ----------
        count: unsigned int

        """
        return _libm2k.M2kDigital_setKernelBuffersCountOut(self, count)

    def getIioObjects(self):
        r"""getIioObjects(M2kDigital self) -> IIO_OBJECTS"""
        return _libm2k.M2kDigital_getIioObjects(self)

    def getNbChannelsIn(self):
        r"""getNbChannelsIn(M2kDigital self) -> unsigned int"""
        return _libm2k.M2kDigital_getNbChannelsIn(self)

    def getNbChannelsOut(self):
        r"""getNbChannelsOut(M2kDigital self) -> unsigned int"""
        return _libm2k.M2kDigital_getNbChannelsOut(self)

    def getSamples(self, *args):
        r"""
        getSamples(M2kDigital self, unsigned int nb_samples) -> VectorUS

        Parameters
        ----------
        nb_samples: unsigned int

        getSamples(M2kDigital self, VectorUS data, unsigned int nb_samples)

        Parameters
        ----------
        data: std::vector< unsigned short,std::allocator< unsigned short > > &
        nb_samples: unsigned int

        """
        return _libm2k.M2kDigital_getSamples(self, *args)

    def setRateMux(self):
        r"""setRateMux(M2kDigital self)"""
        return _libm2k.M2kDigital_setRateMux(self)

    def resetRateMux(self):
        r"""resetRateMux(M2kDigital self)"""
        return _libm2k.M2kDigital_resetRateMux(self)

# Register M2kDigital in _libm2k:
_libm2k.M2kDigital_swigregister(M2kDigital)

class Context(object):
    r"""Proxy of C++ libm2k::context::Context class."""

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

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

    def reset(self):
        r"""reset(Context self)"""
        return _libm2k.Context_reset(self)

    def deinitialize(self):
        r"""deinitialize(Context self)"""
        return _libm2k.Context_deinitialize(self)

    def getUri(self):
        r"""getUri(Context self) -> std::string"""
        return _libm2k.Context_getUri(self)

    def getDMM(self, *args):
        r"""
        getDMM(Context self, unsigned int index) -> DMM

        Parameters
        ----------
        index: unsigned int

        getDMM(Context self, std::string name) -> DMM

        Parameters
        ----------
        name: std::string

        """
        return _libm2k.Context_getDMM(self, *args)

    def getAllDmm(self):
        r"""getAllDmm(Context self) -> DMMs"""
        return _libm2k.Context_getAllDmm(self)

    def getAvailableContextAttributes(self):
        r"""getAvailableContextAttributes(Context self) -> VectorStr"""
        return _libm2k.Context_getAvailableContextAttributes(self)

    def getContextAttributeValue(self, attr):
        r"""
        getContextAttributeValue(Context self, std::string attr) -> std::string

        Parameters
        ----------
        attr: std::string

        """
        return _libm2k.Context_getContextAttributeValue(self, attr)

    def getContextDescription(self):
        r"""getContextDescription(Context self) -> std::string"""
        return _libm2k.Context_getContextDescription(self)

    def getSerialNumber(self):
        r"""getSerialNumber(Context self) -> std::string"""
        return _libm2k.Context_getSerialNumber(self)

    def getAllDevices(self):
        r"""getAllDevices(Context self) -> std::unordered_set< std::string >"""
        return _libm2k.Context_getAllDevices(self)

    def toM2k(self):
        r"""toM2k(Context self) -> M2k"""
        return _libm2k.Context_toM2k(self)

    def toLidar(self):
        r"""toLidar(Context self) -> Lidar"""
        return _libm2k.Context_toLidar(self)

    def toGeneric(self):
        r"""toGeneric(Context self) -> Generic"""
        return _libm2k.Context_toGeneric(self)

    def getDmmCount(self):
        r"""getDmmCount(Context self) -> unsigned int"""
        return _libm2k.Context_getDmmCount(self)

    def getFirmwareVersion(self):
        r"""getFirmwareVersion(Context self) -> std::string"""
        return _libm2k.Context_getFirmwareVersion(self)

    def setTimeout(self, timeout):
        r"""
        setTimeout(Context self, unsigned int timeout)

        Parameters
        ----------
        timeout: unsigned int

        """
        return _libm2k.Context_setTimeout(self, timeout)

# Register Context in _libm2k:
_libm2k.Context_swigregister(Context)

CtxFMCOMMS = _libm2k.CtxFMCOMMS

CtxM2K = _libm2k.CtxM2K

CtxLIDAR = _libm2k.CtxLIDAR

Other = _libm2k.Other

class ContextBuilder(object):
    r"""Proxy of C++ libm2k::context::ContextBuilder class."""

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

    def __init__(self):
        r"""__init__(ContextBuilder self) -> ContextBuilder"""
        _libm2k.ContextBuilder_swiginit(self, _libm2k.new_ContextBuilder())
    __swig_destroy__ = _libm2k.delete_ContextBuilder

    @staticmethod
    def getContextsInfo():
        r"""getContextsInfo() -> std::vector< libm2k::CONTEXT_INFO *,std::allocator< libm2k::CONTEXT_INFO * > >"""
        return _libm2k.ContextBuilder_getContextsInfo()

    @staticmethod
    def getAllContexts():
        r"""getAllContexts() -> VectorStr"""
        return _libm2k.ContextBuilder_getAllContexts()

    @staticmethod
    def contextOpen(*args):
        r"""
        contextOpen(char const * arg1) -> Context

        Parameters
        ----------
        arg1: char const *

        contextOpen(iio_context * arg1, char const * arg2) -> Context

        Parameters
        ----------
        arg1: iio_context *
        arg2: char const *

        contextOpen() -> Context
        """
        return _libm2k.ContextBuilder_contextOpen(*args)

    @staticmethod
    def m2kOpen(*args):
        r"""
        m2kOpen(char const * arg1) -> M2k

        Parameters
        ----------
        arg1: char const *

        m2kOpen(iio_context * arg1, char const * arg2) -> M2k

        Parameters
        ----------
        arg1: iio_context *
        arg2: char const *

        m2kOpen() -> M2k
        """
        return _libm2k.ContextBuilder_m2kOpen(*args)

    @staticmethod
    def contextClose(arg1, deinit=True):
        r"""
        contextClose(Context arg1, bool deinit=True)

        Parameters
        ----------
        arg1: libm2k::context::Context *
        deinit: bool

        """
        return _libm2k.ContextBuilder_contextClose(arg1, deinit)

    @staticmethod
    def contextCloseAll():
        r"""contextCloseAll()"""
        return _libm2k.ContextBuilder_contextCloseAll()

    @staticmethod
    def getVersion():
        r"""getVersion() -> std::string"""
        return _libm2k.ContextBuilder_getVersion()

# Register ContextBuilder in _libm2k:
_libm2k.ContextBuilder_swigregister(ContextBuilder)

def ContextBuilder_getContextsInfo():
    r"""ContextBuilder_getContextsInfo() -> std::vector< libm2k::CONTEXT_INFO *,std::allocator< libm2k::CONTEXT_INFO * > >"""
    return _libm2k.ContextBuilder_getContextsInfo()

def ContextBuilder_getAllContexts():
    r"""ContextBuilder_getAllContexts() -> VectorStr"""
    return _libm2k.ContextBuilder_getAllContexts()

def ContextBuilder_contextOpen(*args):
    r"""
    ContextBuilder_contextOpen(char const * arg1) -> Context

    Parameters
    ----------
    arg1: char const *

    ContextBuilder_contextOpen(iio_context * arg1, char const * arg2) -> Context

    Parameters
    ----------
    arg1: iio_context *
    arg2: char const *

    ContextBuilder_contextOpen() -> Context
    """
    return _libm2k.ContextBuilder_contextOpen(*args)

def ContextBuilder_m2kOpen(*args):
    r"""
    ContextBuilder_m2kOpen(char const * arg1) -> M2k

    Parameters
    ----------
    arg1: char const *

    ContextBuilder_m2kOpen(iio_context * arg1, char const * arg2) -> M2k

    Parameters
    ----------
    arg1: iio_context *
    arg2: char const *

    ContextBuilder_m2kOpen() -> M2k
    """
    return _libm2k.ContextBuilder_m2kOpen(*args)

def ContextBuilder_contextClose(arg1, deinit=True):
    r"""
    ContextBuilder_contextClose(Context arg1, bool deinit=True)

    Parameters
    ----------
    arg1: libm2k::context::Context *
    deinit: bool

    """
    return _libm2k.ContextBuilder_contextClose(arg1, deinit)

def ContextBuilder_contextCloseAll():
    r"""ContextBuilder_contextCloseAll()"""
    return _libm2k.ContextBuilder_contextCloseAll()

def ContextBuilder_getVersion():
    r"""ContextBuilder_getVersion() -> std::string"""
    return _libm2k.ContextBuilder_getVersion()


def contextOpen(*args):
    r"""
    contextOpen() -> Context
    contextOpen(char const * uri) -> Context

    Parameters
    ----------
    uri: char const *

    contextOpen(iio_context * ctx, char const * uri) -> Context

    Parameters
    ----------
    ctx: iio_context *
    uri: char const *

    """
    return _libm2k.contextOpen(*args)

def m2kOpen(*args):
    r"""
    m2kOpen(char const * uri) -> M2k

    Parameters
    ----------
    uri: char const *

    m2kOpen(iio_context * ctx, char const * uri) -> M2k

    Parameters
    ----------
    ctx: iio_context *
    uri: char const *

    m2kOpen() -> M2k
    """
    return _libm2k.m2kOpen(*args)

def getContextsInfo():
    r"""getContextsInfo() -> std::vector< libm2k::CONTEXT_INFO *,std::allocator< libm2k::CONTEXT_INFO * > >"""
    return _libm2k.getContextsInfo()

def getAllContexts():
    r"""getAllContexts() -> VectorStr"""
    return _libm2k.getAllContexts()

def contextClose(ctx, deinit=True):
    r"""
    contextClose(Context ctx, bool deinit=True)

    Parameters
    ----------
    ctx: libm2k::context::Context *
    deinit: bool

    """
    return _libm2k.contextClose(ctx, deinit)

def contextCloseAll():
    r"""contextCloseAll()"""
    return _libm2k.contextCloseAll()

def getVersion():
    r"""getVersion() -> std::string"""
    return _libm2k.getVersion()
class FMCOMMS(object):
    r"""Proxy of C++ FMCOMMS class."""

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

    def __init__(self):
        r"""__init__(FMCOMMS self) -> FMCOMMS"""
        _libm2k.FMCOMMS_swiginit(self, _libm2k.new_FMCOMMS())
    __swig_destroy__ = _libm2k.delete_FMCOMMS

# Register FMCOMMS in _libm2k:
_libm2k.FMCOMMS_swigregister(FMCOMMS)

class Logger(object):
    r"""Proxy of C++ libm2k::Logger class."""

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

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

    @staticmethod
    def getInstance():
        r"""getInstance() -> Logger"""
        return _libm2k.Logger_getInstance()

    def warn(self, message):
        r"""
        warn(Logger self, std::string message)

        Parameters
        ----------
        message: std::string

        """
        return _libm2k.Logger_warn(self, message)
    __swig_destroy__ = _libm2k.delete_Logger

# Register Logger in _libm2k:
_libm2k.Logger_swigregister(Logger)

def Logger_getInstance():
    r"""Logger_getInstance() -> Logger"""
    return _libm2k.Logger_getInstance()

class M2kCalibration(object):
    r"""Proxy of C++ libm2k::M2kCalibration class."""

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

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

    def initialize(self):
        r"""initialize(M2kCalibration self) -> bool"""
        return _libm2k.M2kCalibration_initialize(self)

    def isInitialized(self):
        r"""isInitialized(M2kCalibration self) -> bool"""
        return _libm2k.M2kCalibration_isInitialized(self)

    def calibrateAll(self):
        r"""calibrateAll(M2kCalibration self) -> bool"""
        return _libm2k.M2kCalibration_calibrateAll(self)

    def calibrateADC(self):
        r"""calibrateADC(M2kCalibration self) -> bool"""
        return _libm2k.M2kCalibration_calibrateADC(self)

    def calibrateDAC(self):
        r"""calibrateDAC(M2kCalibration self) -> bool"""
        return _libm2k.M2kCalibration_calibrateDAC(self)

    def cancelCalibration(self):
        r"""cancelCalibration(M2kCalibration self)"""
        return _libm2k.M2kCalibration_cancelCalibration(self)

    def getAdcOffset(self, channel):
        r"""
        getAdcOffset(M2kCalibration self, unsigned int channel) -> int

        Parameters
        ----------
        channel: unsigned int

        """
        return _libm2k.M2kCalibration_getAdcOffset(self, channel)

    def getDacOffset(self, channel):
        r"""
        getDacOffset(M2kCalibration self, unsigned int channel) -> int

        Parameters
        ----------
        channel: unsigned int

        """
        return _libm2k.M2kCalibration_getDacOffset(self, channel)

    def getAdcGain(self, channel):
        r"""
        getAdcGain(M2kCalibration self, unsigned int channel) -> double

        Parameters
        ----------
        channel: unsigned int

        """
        return _libm2k.M2kCalibration_getAdcGain(self, channel)

    def getDacGain(self, channel):
        r"""
        getDacGain(M2kCalibration self, unsigned int channel) -> double

        Parameters
        ----------
        channel: unsigned int

        """
        return _libm2k.M2kCalibration_getDacGain(self, channel)

    def resetCalibration(self):
        r"""resetCalibration(M2kCalibration self) -> bool"""
        return _libm2k.M2kCalibration_resetCalibration(self)

    def setDacGain(self, chn, gain):
        r"""
        setDacGain(M2kCalibration self, unsigned int chn, double gain)

        Parameters
        ----------
        chn: unsigned int
        gain: double

        """
        return _libm2k.M2kCalibration_setDacGain(self, chn, gain)

    def setDacOffset(self, chn, offset):
        r"""
        setDacOffset(M2kCalibration self, unsigned int chn, int offset)

        Parameters
        ----------
        chn: unsigned int
        offset: int

        """
        return _libm2k.M2kCalibration_setDacOffset(self, chn, offset)

    def setAdcOffset(self, chn, offset):
        r"""
        setAdcOffset(M2kCalibration self, unsigned int chn, int offset)

        Parameters
        ----------
        chn: unsigned int
        offset: int

        """
        return _libm2k.M2kCalibration_setAdcOffset(self, chn, offset)

    def setAdcGain(self, chn, gain):
        r"""
        setAdcGain(M2kCalibration self, unsigned int chn, double gain)

        Parameters
        ----------
        chn: unsigned int
        gain: double

        """
        return _libm2k.M2kCalibration_setAdcGain(self, chn, gain)

# Register M2kCalibration in _libm2k:
_libm2k.M2kCalibration_swigregister(M2kCalibration)

class m2k_exception(object):
    r"""Proxy of C++ libm2k::m2k_exception class."""

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

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

    @staticmethod
    def make(what):
        r"""
        make(std::string what) -> m2k_exception_builder

        Parameters
        ----------
        what: std::string

        """
        return _libm2k.m2k_exception_make(what)

    def iioCode(self):
        r"""iioCode(m2k_exception self) -> int"""
        return _libm2k.m2k_exception_iioCode(self)

    def type(self):
        r"""type(m2k_exception self) -> libm2k::M2K_EXCEPTION_TYPE"""
        return _libm2k.m2k_exception_type(self)

    def line(self):
        r"""line(m2k_exception self) -> int"""
        return _libm2k.m2k_exception_line(self)

    def file(self):
        r"""file(m2k_exception self) -> std::string"""
        return _libm2k.m2k_exception_file(self)

    def what(self):
        r"""what(m2k_exception self) -> char const *"""
        return _libm2k.m2k_exception_what(self)
    __swig_destroy__ = _libm2k.delete_m2k_exception

# Register m2k_exception in _libm2k:
_libm2k.m2k_exception_swigregister(m2k_exception)

def m2k_exception_make(what):
    r"""
    m2k_exception_make(std::string what) -> m2k_exception_builder

    Parameters
    ----------
    what: std::string

    """
    return _libm2k.m2k_exception_make(what)

class m2k_exception_builder(object):
    r"""Proxy of C++ libm2k::m2k_exception_builder class."""

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

    def __init__(self, *args):
        r"""
        __init__(m2k_exception_builder self) -> m2k_exception_builder
        __init__(m2k_exception_builder self, std::string & what) -> m2k_exception_builder

        Parameters
        ----------
        what: std::string &

        __init__(m2k_exception_builder self, char const * what) -> m2k_exception_builder

        Parameters
        ----------
        what: char const *

        """
        _libm2k.m2k_exception_builder_swiginit(self, _libm2k.new_m2k_exception_builder(*args))

    def iioCode(self, code):
        r"""
        iioCode(m2k_exception_builder self, int code) -> m2k_exception_builder

        Parameters
        ----------
        code: int

        """
        return _libm2k.m2k_exception_builder_iioCode(self, code)

    def type(self, type):
        r"""
        type(m2k_exception_builder self, libm2k::M2K_EXCEPTION_TYPE type) -> m2k_exception_builder

        Parameters
        ----------
        type: enum libm2k::M2K_EXCEPTION_TYPE

        """
        return _libm2k.m2k_exception_builder_type(self, type)

    def line(self, lineNumber):
        r"""
        line(m2k_exception_builder self, int lineNumber) -> m2k_exception_builder

        Parameters
        ----------
        lineNumber: int

        """
        return _libm2k.m2k_exception_builder_line(self, lineNumber)

    def file(self, fileName):
        r"""
        file(m2k_exception_builder self, std::string const & fileName) -> m2k_exception_builder

        Parameters
        ----------
        fileName: std::string const &

        """
        return _libm2k.m2k_exception_builder_file(self, fileName)

    def build(self):
        r"""build(m2k_exception_builder self) -> m2k_exception"""
        return _libm2k.m2k_exception_builder_build(self)
    __swig_destroy__ = _libm2k.delete_m2k_exception_builder

# Register m2k_exception_builder in _libm2k:
_libm2k.m2k_exception_builder_swigregister(m2k_exception_builder)


def throw_exception(exception):
    r"""
    throw_exception(m2k_exception exception)

    Parameters
    ----------
    exception: libm2k::m2k_exception const &

    """
    return _libm2k.throw_exception(exception)
class M2k(Context):
    r"""Proxy of C++ libm2k::context::M2k class."""

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

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

    def reset(self):
        r"""reset(M2k self)"""
        return _libm2k.M2k_reset(self)

    def deinitialize(self):
        r"""deinitialize(M2k self)"""
        return _libm2k.M2k_deinitialize(self)

    def calibrate(self):
        r"""calibrate(M2k self) -> bool"""
        return _libm2k.M2k_calibrate(self)

    def calibrateADC(self):
        r"""calibrateADC(M2k self) -> bool"""
        return _libm2k.M2k_calibrateADC(self)

    def calibrateDAC(self):
        r"""calibrateDAC(M2k self) -> bool"""
        return _libm2k.M2k_calibrateDAC(self)

    def resetCalibration(self):
        r"""resetCalibration(M2k self) -> bool"""
        return _libm2k.M2k_resetCalibration(self)

    def getDigital(self):
        r"""getDigital(M2k self) -> M2kDigital"""
        return _libm2k.M2k_getDigital(self)

    def getPowerSupply(self):
        r"""getPowerSupply(M2k self) -> M2kPowerSupply"""
        return _libm2k.M2k_getPowerSupply(self)

    def getAnalogIn(self, *args):
        r"""
        getAnalogIn(M2k self) -> M2kAnalogIn
        getAnalogIn(M2k self, std::string dev_name) -> M2kAnalogIn

        Parameters
        ----------
        dev_name: std::string

        """
        return _libm2k.M2k_getAnalogIn(self, *args)

    def getAnalogOut(self):
        r"""getAnalogOut(M2k self) -> M2kAnalogOut"""
        return _libm2k.M2k_getAnalogOut(self)

    def getAllAnalogIn(self):
        r"""getAllAnalogIn(M2k self) -> M2kAnalogIns"""
        return _libm2k.M2k_getAllAnalogIn(self)

    def getAllAnalogOut(self):
        r"""getAllAnalogOut(M2k self) -> M2kAnalogOuts"""
        return _libm2k.M2k_getAllAnalogOut(self)

    def hasMixedSignal(self):
        r"""hasMixedSignal(M2k self) -> bool"""
        return _libm2k.M2k_hasMixedSignal(self)

    def startMixedSignalAcquisition(self, nb_samples):
        r"""
        startMixedSignalAcquisition(M2k self, unsigned int nb_samples)

        Parameters
        ----------
        nb_samples: unsigned int

        """
        return _libm2k.M2k_startMixedSignalAcquisition(self, nb_samples)

    def stopMixedSignalAcquisition(self):
        r"""stopMixedSignalAcquisition(M2k self)"""
        return _libm2k.M2k_stopMixedSignalAcquisition(self)

    def getDacCalibrationOffset(self, chn):
        r"""
        getDacCalibrationOffset(M2k self, unsigned int chn) -> int

        Parameters
        ----------
        chn: unsigned int

        """
        return _libm2k.M2k_getDacCalibrationOffset(self, chn)

    def getDacCalibrationGain(self, chn):
        r"""
        getDacCalibrationGain(M2k self, unsigned int chn) -> double

        Parameters
        ----------
        chn: unsigned int

        """
        return _libm2k.M2k_getDacCalibrationGain(self, chn)

    def getAdcCalibrationOffset(self, chn):
        r"""
        getAdcCalibrationOffset(M2k self, unsigned int chn) -> int

        Parameters
        ----------
        chn: unsigned int

        """
        return _libm2k.M2k_getAdcCalibrationOffset(self, chn)

    def getAdcCalibrationGain(self, chn):
        r"""
        getAdcCalibrationGain(M2k self, unsigned int chn) -> double

        Parameters
        ----------
        chn: unsigned int

        """
        return _libm2k.M2k_getAdcCalibrationGain(self, chn)

    def setDacCalibrationOffset(self, chn, offset):
        r"""
        setDacCalibrationOffset(M2k self, unsigned int chn, int offset)

        Parameters
        ----------
        chn: unsigned int
        offset: int

        """
        return _libm2k.M2k_setDacCalibrationOffset(self, chn, offset)

    def setDacCalibrationGain(self, chn, gain):
        r"""
        setDacCalibrationGain(M2k self, unsigned int chn, double gain)

        Parameters
        ----------
        chn: unsigned int
        gain: double

        """
        return _libm2k.M2k_setDacCalibrationGain(self, chn, gain)

    def setAdcCalibrationOffset(self, chn, offset):
        r"""
        setAdcCalibrationOffset(M2k self, unsigned int chn, int offset)

        Parameters
        ----------
        chn: unsigned int
        offset: int

        """
        return _libm2k.M2k_setAdcCalibrationOffset(self, chn, offset)

    def setAdcCalibrationGain(self, chn, gain):
        r"""
        setAdcCalibrationGain(M2k self, unsigned int chn, double gain)

        Parameters
        ----------
        chn: unsigned int
        gain: double

        """
        return _libm2k.M2k_setAdcCalibrationGain(self, chn, gain)

    def isCalibrated(self):
        r"""isCalibrated(M2k self) -> bool"""
        return _libm2k.M2k_isCalibrated(self)

    def setLed(self, on):
        r"""
        setLed(M2k self, bool on)

        Parameters
        ----------
        on: bool

        """
        return _libm2k.M2k_setLed(self, on)

    def getLed(self):
        r"""getLed(M2k self) -> bool"""
        return _libm2k.M2k_getLed(self)

# Register M2k in _libm2k:
_libm2k.M2k_swigregister(M2k)

class Generic(Context):
    r"""Proxy of C++ libm2k::context::Generic class."""

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

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

    def getAnalogIn(self, *args):
        r"""
        getAnalogIn(Generic self, unsigned int arg2) -> GenericAnalogIn

        Parameters
        ----------
        arg2: unsigned int

        getAnalogIn(Generic self, std::string arg2) -> GenericAnalogIn

        Parameters
        ----------
        arg2: std::string

        """
        return _libm2k.Generic_getAnalogIn(self, *args)

    def getAnalogOut(self, *args):
        r"""
        getAnalogOut(Generic self, unsigned int arg2) -> GenericAnalogOut

        Parameters
        ----------
        arg2: unsigned int

        getAnalogOut(Generic self, std::string arg2) -> GenericAnalogOut

        Parameters
        ----------
        arg2: std::string

        """
        return _libm2k.Generic_getAnalogOut(self, *args)

    def getAnalogInCount(self):
        r"""getAnalogInCount(Generic self) -> unsigned int"""
        return _libm2k.Generic_getAnalogInCount(self)

    def getAnalogOutCount(self):
        r"""getAnalogOutCount(Generic self) -> unsigned int"""
        return _libm2k.Generic_getAnalogOutCount(self)

# Register Generic in _libm2k:
_libm2k.Generic_swigregister(Generic)

class Lidar(Context):
    r"""Proxy of C++ libm2k::context::Lidar class."""

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

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

    def channelEnableDisable(self, channel, enable):
        r"""
        channelEnableDisable(Lidar self, std::string channel, bool enable)

        Parameters
        ----------
        channel: std::string
        enable: bool

        """
        return _libm2k.Lidar_channelEnableDisable(self, channel, enable)

    def readChannels(self, nb_samples):
        r"""
        readChannels(Lidar self, unsigned int nb_samples) -> std::map< std::string,std::vector< int8_t > >

        Parameters
        ----------
        nb_samples: unsigned int

        """
        return _libm2k.Lidar_readChannels(self, nb_samples)

    def setApdBias(self, bias):
        r"""
        setApdBias(Lidar self, unsigned int bias)

        Parameters
        ----------
        bias: unsigned int

        """
        return _libm2k.Lidar_setApdBias(self, bias)

    def setTiltVoltage(self, voltage):
        r"""
        setTiltVoltage(Lidar self, unsigned int voltage)

        Parameters
        ----------
        voltage: unsigned int

        """
        return _libm2k.Lidar_setTiltVoltage(self, voltage)

    def laserEnable(self):
        r"""laserEnable(Lidar self)"""
        return _libm2k.Lidar_laserEnable(self)

    def laserDisable(self):
        r"""laserDisable(Lidar self)"""
        return _libm2k.Lidar_laserDisable(self)

    def setLaserPulseWidth(self, pulse_width):
        r"""
        setLaserPulseWidth(Lidar self, long long pulse_width)

        Parameters
        ----------
        pulse_width: long long

        """
        return _libm2k.Lidar_setLaserPulseWidth(self, pulse_width)

    def setLaserFrequency(self, frequency):
        r"""
        setLaserFrequency(Lidar self, long long frequency)

        Parameters
        ----------
        frequency: long long

        """
        return _libm2k.Lidar_setLaserFrequency(self, frequency)

    def enableChannelSequencer(self):
        r"""enableChannelSequencer(Lidar self)"""
        return _libm2k.Lidar_enableChannelSequencer(self)

    def disableChannelSequencer(self):
        r"""disableChannelSequencer(Lidar self)"""
        return _libm2k.Lidar_disableChannelSequencer(self)

    def setSequencerPulseDelay(self, ns):
        r"""
        setSequencerPulseDelay(Lidar self, long long ns)

        Parameters
        ----------
        ns: long long

        """
        return _libm2k.Lidar_setSequencerPulseDelay(self, ns)

    def setChannelSequencerOpModeManual(self):
        r"""setChannelSequencerOpModeManual(Lidar self)"""
        return _libm2k.Lidar_setChannelSequencerOpModeManual(self)

    def setChannelSequencerOpModeAuto(self):
        r"""setChannelSequencerOpModeAuto(Lidar self)"""
        return _libm2k.Lidar_setChannelSequencerOpModeAuto(self)

    def setChannelSequencerOrderAutoMode(self, order):
        r"""
        setChannelSequencerOrderAutoMode(Lidar self, char const * order)

        Parameters
        ----------
        order: char const *

        """
        return _libm2k.Lidar_setChannelSequencerOrderAutoMode(self, order)

    def setChannelSequencerOrderManualMode(self, order):
        r"""
        setChannelSequencerOrderManualMode(Lidar self, char const * order)

        Parameters
        ----------
        order: char const *

        """
        return _libm2k.Lidar_setChannelSequencerOrderManualMode(self, order)

# Register Lidar in _libm2k:
_libm2k.Lidar_swigregister(Lidar)

SPI_CPHA = _libm2k.SPI_CPHA

SPI_CPOL = _libm2k.SPI_CPOL

SPI_MODE_0 = _libm2k.SPI_MODE_0

SPI_MODE_1 = _libm2k.SPI_MODE_1

SPI_MODE_2 = _libm2k.SPI_MODE_2

SPI_MODE_3 = _libm2k.SPI_MODE_3

class spi_init_param(object):
    r"""Proxy of C++ spi_init_param class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    max_speed_hz = property(_libm2k.spi_init_param_max_speed_hz_get, _libm2k.spi_init_param_max_speed_hz_set, doc=r"""max_speed_hz : uint32_t""")
    chip_select = property(_libm2k.spi_init_param_chip_select_get, _libm2k.spi_init_param_chip_select_set, doc=r"""chip_select : uint8_t""")
    mode = property(_libm2k.spi_init_param_mode_get, _libm2k.spi_init_param_mode_set, doc=r"""mode : enum spi_mode""")
    extra = property(_libm2k.spi_init_param_extra_get, _libm2k.spi_init_param_extra_set, doc=r"""extra : p.void""")

    def __init__(self):
        r"""__init__(spi_init_param self) -> spi_init_param"""
        _libm2k.spi_init_param_swiginit(self, _libm2k.new_spi_init_param())
    __swig_destroy__ = _libm2k.delete_spi_init_param

# Register spi_init_param in _libm2k:
_libm2k.spi_init_param_swigregister(spi_init_param)

class spi_desc(object):
    r"""Proxy of C++ spi_desc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    max_speed_hz = property(_libm2k.spi_desc_max_speed_hz_get, _libm2k.spi_desc_max_speed_hz_set, doc=r"""max_speed_hz : uint32_t""")
    chip_select = property(_libm2k.spi_desc_chip_select_get, _libm2k.spi_desc_chip_select_set, doc=r"""chip_select : uint8_t""")
    mode = property(_libm2k.spi_desc_mode_get, _libm2k.spi_desc_mode_set, doc=r"""mode : enum spi_mode""")
    extra = property(_libm2k.spi_desc_extra_get, _libm2k.spi_desc_extra_set, doc=r"""extra : p.void""")

    def __init__(self):
        r"""__init__(spi_desc self) -> spi_desc"""
        _libm2k.spi_desc_swiginit(self, _libm2k.new_spi_desc())
    __swig_destroy__ = _libm2k.delete_spi_desc

# Register spi_desc in _libm2k:
_libm2k.spi_desc_swigregister(spi_desc)


def spi_remove(desc):
    r"""
    spi_remove(spi_desc desc) -> int32_t

    Parameters
    ----------
    desc: spi_desc *

    """
    return _libm2k.spi_remove(desc)

def spi_write_and_read(desc, data):
    r"""
    spi_write_and_read(spi_desc desc, uint8_t * data) -> int32_t

    Parameters
    ----------
    desc: spi_desc *
    data: uint8_t *

    """
    return _libm2k.spi_write_and_read(desc, data)
LSB = _libm2k.LSB

MSB = _libm2k.MSB

class m2k_spi_init(object):
    r"""Proxy of C++ m2k_spi_init class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    clock = property(_libm2k.m2k_spi_init_clock_get, _libm2k.m2k_spi_init_clock_set, doc=r"""clock : uint8_t""")
    mosi = property(_libm2k.m2k_spi_init_mosi_get, _libm2k.m2k_spi_init_mosi_set, doc=r"""mosi : uint8_t""")
    miso = property(_libm2k.m2k_spi_init_miso_get, _libm2k.m2k_spi_init_miso_set, doc=r"""miso : uint8_t""")
    bit_numbering = property(_libm2k.m2k_spi_init_bit_numbering_get, _libm2k.m2k_spi_init_bit_numbering_set, doc=r"""bit_numbering : enum bit_numbering""")
    context = property(_libm2k.m2k_spi_init_context_get, _libm2k.m2k_spi_init_context_set, doc=r"""context : p.libm2k::context::M2k""")

    def __init__(self):
        r"""__init__(m2k_spi_init self) -> m2k_spi_init"""
        _libm2k.m2k_spi_init_swiginit(self, _libm2k.new_m2k_spi_init())
    __swig_destroy__ = _libm2k.delete_m2k_spi_init

# Register m2k_spi_init in _libm2k:
_libm2k.m2k_spi_init_swigregister(m2k_spi_init)

class m2k_spi_desc(object):
    r"""Proxy of C++ m2k_spi_desc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    clock = property(_libm2k.m2k_spi_desc_clock_get, _libm2k.m2k_spi_desc_clock_set, doc=r"""clock : uint8_t""")
    mosi = property(_libm2k.m2k_spi_desc_mosi_get, _libm2k.m2k_spi_desc_mosi_set, doc=r"""mosi : uint8_t""")
    miso = property(_libm2k.m2k_spi_desc_miso_get, _libm2k.m2k_spi_desc_miso_set, doc=r"""miso : uint8_t""")
    bit_numbering = property(_libm2k.m2k_spi_desc_bit_numbering_get, _libm2k.m2k_spi_desc_bit_numbering_set, doc=r"""bit_numbering : enum bit_numbering""")
    context = property(_libm2k.m2k_spi_desc_context_get, _libm2k.m2k_spi_desc_context_set, doc=r"""context : p.libm2k::context::M2k""")
    digital = property(_libm2k.m2k_spi_desc_digital_get, _libm2k.m2k_spi_desc_digital_set, doc=r"""digital : p.libm2k::digital::M2kDigital""")
    sample_rate = property(_libm2k.m2k_spi_desc_sample_rate_get, _libm2k.m2k_spi_desc_sample_rate_set, doc=r"""sample_rate : unsigned int""")

    def __init__(self):
        r"""__init__(m2k_spi_desc self) -> m2k_spi_desc"""
        _libm2k.m2k_spi_desc_swiginit(self, _libm2k.new_m2k_spi_desc())
    __swig_destroy__ = _libm2k.delete_m2k_spi_desc

# Register m2k_spi_desc in _libm2k:
_libm2k.m2k_spi_desc_swigregister(m2k_spi_desc)


def spi_init_write_only(desc, param):
    r"""
    spi_init_write_only(spi_desc ** desc, spi_init_param param) -> int32_t

    Parameters
    ----------
    desc: spi_desc **
    param: spi_init_param const *

    """
    return _libm2k.spi_init_write_only(desc, param)

def spi_write_only(desc, data):
    r"""
    spi_write_only(spi_desc desc, uint8_t * data) -> int32_t

    Parameters
    ----------
    desc: spi_desc *
    data: uint8_t *

    """
    return _libm2k.spi_write_only(desc, data)
i2c_general_call = _libm2k.i2c_general_call

i2c_repeated_start = _libm2k.i2c_repeated_start

i2c_10_bit_transfer = _libm2k.i2c_10_bit_transfer

class i2c_init_param(object):
    r"""Proxy of C++ i2c_init_param class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    max_speed_hz = property(_libm2k.i2c_init_param_max_speed_hz_get, _libm2k.i2c_init_param_max_speed_hz_set, doc=r"""max_speed_hz : uint32_t""")
    slave_address = property(_libm2k.i2c_init_param_slave_address_get, _libm2k.i2c_init_param_slave_address_set, doc=r"""slave_address : uint16_t""")
    extra = property(_libm2k.i2c_init_param_extra_get, _libm2k.i2c_init_param_extra_set, doc=r"""extra : p.void""")

    def __init__(self):
        r"""__init__(i2c_init_param self) -> i2c_init_param"""
        _libm2k.i2c_init_param_swiginit(self, _libm2k.new_i2c_init_param())
    __swig_destroy__ = _libm2k.delete_i2c_init_param

# Register i2c_init_param in _libm2k:
_libm2k.i2c_init_param_swigregister(i2c_init_param)

class i2c_desc(object):
    r"""Proxy of C++ i2c_desc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    max_speed_hz = property(_libm2k.i2c_desc_max_speed_hz_get, _libm2k.i2c_desc_max_speed_hz_set, doc=r"""max_speed_hz : uint32_t""")
    slave_address = property(_libm2k.i2c_desc_slave_address_get, _libm2k.i2c_desc_slave_address_set, doc=r"""slave_address : uint16_t""")
    extra = property(_libm2k.i2c_desc_extra_get, _libm2k.i2c_desc_extra_set, doc=r"""extra : p.void""")

    def __init__(self):
        r"""__init__(i2c_desc self) -> i2c_desc"""
        _libm2k.i2c_desc_swiginit(self, _libm2k.new_i2c_desc())
    __swig_destroy__ = _libm2k.delete_i2c_desc

# Register i2c_desc in _libm2k:
_libm2k.i2c_desc_swigregister(i2c_desc)


def i2c_remove(desc):
    r"""
    i2c_remove(i2c_desc desc) -> int32_t

    Parameters
    ----------
    desc: i2c_desc *

    """
    return _libm2k.i2c_remove(desc)

def i2c_write(desc, data, option):
    r"""
    i2c_write(i2c_desc desc, uint8_t * data, uint8_t option) -> int32_t

    Parameters
    ----------
    desc: i2c_desc *
    data: uint8_t *
    option: uint8_t

    """
    return _libm2k.i2c_write(desc, data, option)

def i2c_read(desc, data, option):
    r"""
    i2c_read(i2c_desc desc, uint8_t * data, uint8_t option) -> int32_t

    Parameters
    ----------
    desc: i2c_desc *
    data: uint8_t *
    option: uint8_t

    """
    return _libm2k.i2c_read(desc, data, option)
class m2k_i2c_init(object):
    r"""Proxy of C++ m2k_i2c_init class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    scl = property(_libm2k.m2k_i2c_init_scl_get, _libm2k.m2k_i2c_init_scl_set, doc=r"""scl : uint8_t""")
    sda = property(_libm2k.m2k_i2c_init_sda_get, _libm2k.m2k_i2c_init_sda_set, doc=r"""sda : uint8_t""")
    context = property(_libm2k.m2k_i2c_init_context_get, _libm2k.m2k_i2c_init_context_set, doc=r"""context : p.libm2k::context::M2k""")

    def __init__(self):
        r"""__init__(m2k_i2c_init self) -> m2k_i2c_init"""
        _libm2k.m2k_i2c_init_swiginit(self, _libm2k.new_m2k_i2c_init())
    __swig_destroy__ = _libm2k.delete_m2k_i2c_init

# Register m2k_i2c_init in _libm2k:
_libm2k.m2k_i2c_init_swigregister(m2k_i2c_init)

class m2k_i2c_desc(object):
    r"""Proxy of C++ m2k_i2c_desc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    scl = property(_libm2k.m2k_i2c_desc_scl_get, _libm2k.m2k_i2c_desc_scl_set, doc=r"""scl : uint8_t""")
    sda = property(_libm2k.m2k_i2c_desc_sda_get, _libm2k.m2k_i2c_desc_sda_set, doc=r"""sda : uint8_t""")
    context = property(_libm2k.m2k_i2c_desc_context_get, _libm2k.m2k_i2c_desc_context_set, doc=r"""context : p.libm2k::context::M2k""")
    digital = property(_libm2k.m2k_i2c_desc_digital_get, _libm2k.m2k_i2c_desc_digital_set, doc=r"""digital : p.libm2k::digital::M2kDigital""")
    sample_rate = property(_libm2k.m2k_i2c_desc_sample_rate_get, _libm2k.m2k_i2c_desc_sample_rate_set, doc=r"""sample_rate : unsigned int""")

    def __init__(self):
        r"""__init__(m2k_i2c_desc self) -> m2k_i2c_desc"""
        _libm2k.m2k_i2c_desc_swiginit(self, _libm2k.new_m2k_i2c_desc())
    __swig_destroy__ = _libm2k.delete_m2k_i2c_desc

# Register m2k_i2c_desc in _libm2k:
_libm2k.m2k_i2c_desc_swigregister(m2k_i2c_desc)


def i2c_init_write_only(desc, param):
    r"""
    i2c_init_write_only(i2c_desc ** desc, i2c_init_param param) -> int32_t

    Parameters
    ----------
    desc: i2c_desc **
    param: i2c_init_param const *

    """
    return _libm2k.i2c_init_write_only(desc, param)

def i2c_write_only(desc, data, option):
    r"""
    i2c_write_only(i2c_desc desc, uint8_t * data, uint8_t option) -> int32_t

    Parameters
    ----------
    desc: i2c_desc *
    data: uint8_t *
    option: uint8_t

    """
    return _libm2k.i2c_write_only(desc, data, option)
class uart_init_param(object):
    r"""Proxy of C++ uart_init_param class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    device_id = property(_libm2k.uart_init_param_device_id_get, _libm2k.uart_init_param_device_id_set, doc=r"""device_id : uint8_t""")
    baud_rate = property(_libm2k.uart_init_param_baud_rate_get, _libm2k.uart_init_param_baud_rate_set, doc=r"""baud_rate : uint32_t""")
    extra = property(_libm2k.uart_init_param_extra_get, _libm2k.uart_init_param_extra_set, doc=r"""extra : p.void""")

    def __init__(self):
        r"""__init__(uart_init_param self) -> uart_init_param"""
        _libm2k.uart_init_param_swiginit(self, _libm2k.new_uart_init_param())
    __swig_destroy__ = _libm2k.delete_uart_init_param

# Register uart_init_param in _libm2k:
_libm2k.uart_init_param_swigregister(uart_init_param)

class uart_desc(object):
    r"""Proxy of C++ uart_desc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    device_id = property(_libm2k.uart_desc_device_id_get, _libm2k.uart_desc_device_id_set, doc=r"""device_id : uint8_t""")
    baud_rate = property(_libm2k.uart_desc_baud_rate_get, _libm2k.uart_desc_baud_rate_set, doc=r"""baud_rate : uint32_t""")
    extra = property(_libm2k.uart_desc_extra_get, _libm2k.uart_desc_extra_set, doc=r"""extra : p.void""")

    def __init__(self):
        r"""__init__(uart_desc self) -> uart_desc"""
        _libm2k.uart_desc_swiginit(self, _libm2k.new_uart_desc())
    __swig_destroy__ = _libm2k.delete_uart_desc

# Register uart_desc in _libm2k:
_libm2k.uart_desc_swigregister(uart_desc)


def uart_read(desc, data):
    r"""
    uart_read(uart_desc desc, uint8_t * data) -> int32_t

    Parameters
    ----------
    desc: uart_desc *
    data: uint8_t *

    """
    return _libm2k.uart_read(desc, data)

def uart_write(desc, data):
    r"""
    uart_write(uart_desc desc, uint8_t const * data) -> int32_t

    Parameters
    ----------
    desc: uart_desc *
    data: uint8_t const *

    """
    return _libm2k.uart_write(desc, data)

def uart_remove(desc):
    r"""
    uart_remove(uart_desc desc) -> int32_t

    Parameters
    ----------
    desc: uart_desc *

    """
    return _libm2k.uart_remove(desc)

def uart_get_errors(desc):
    r"""
    uart_get_errors(uart_desc desc) -> uint32_t

    Parameters
    ----------
    desc: uart_desc *

    """
    return _libm2k.uart_get_errors(desc)
NO_PARITY = _libm2k.NO_PARITY

ODD = _libm2k.ODD

EVEN = _libm2k.EVEN

MARK = _libm2k.MARK

SPACE = _libm2k.SPACE

ONE = _libm2k.ONE

ONE_AND_A_HALF = _libm2k.ONE_AND_A_HALF

TWO = _libm2k.TWO

class m2k_uart_init(object):
    r"""Proxy of C++ m2k_uart_init class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    parity = property(_libm2k.m2k_uart_init_parity_get, _libm2k.m2k_uart_init_parity_set, doc=r"""parity : enum uart_parity""")
    bits_number = property(_libm2k.m2k_uart_init_bits_number_get, _libm2k.m2k_uart_init_bits_number_set, doc=r"""bits_number : uint8_t""")
    stop_bits = property(_libm2k.m2k_uart_init_stop_bits_get, _libm2k.m2k_uart_init_stop_bits_set, doc=r"""stop_bits : enum uart_stop_bits""")
    context = property(_libm2k.m2k_uart_init_context_get, _libm2k.m2k_uart_init_context_set, doc=r"""context : p.libm2k::context::M2k""")

    def __init__(self):
        r"""__init__(m2k_uart_init self) -> m2k_uart_init"""
        _libm2k.m2k_uart_init_swiginit(self, _libm2k.new_m2k_uart_init())
    __swig_destroy__ = _libm2k.delete_m2k_uart_init

# Register m2k_uart_init in _libm2k:
_libm2k.m2k_uart_init_swigregister(m2k_uart_init)

class m2k_uart_desc(object):
    r"""Proxy of C++ m2k_uart_desc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    parity = property(_libm2k.m2k_uart_desc_parity_get, _libm2k.m2k_uart_desc_parity_set, doc=r"""parity : enum uart_parity""")
    bits_number = property(_libm2k.m2k_uart_desc_bits_number_get, _libm2k.m2k_uart_desc_bits_number_set, doc=r"""bits_number : uint8_t""")
    stop_bits = property(_libm2k.m2k_uart_desc_stop_bits_get, _libm2k.m2k_uart_desc_stop_bits_set, doc=r"""stop_bits : enum uart_stop_bits""")
    context = property(_libm2k.m2k_uart_desc_context_get, _libm2k.m2k_uart_desc_context_set, doc=r"""context : p.libm2k::context::M2k""")
    digital = property(_libm2k.m2k_uart_desc_digital_get, _libm2k.m2k_uart_desc_digital_set, doc=r"""digital : p.libm2k::digital::M2kDigital""")
    sample_rate = property(_libm2k.m2k_uart_desc_sample_rate_get, _libm2k.m2k_uart_desc_sample_rate_set, doc=r"""sample_rate : unsigned int""")
    total_error_count = property(_libm2k.m2k_uart_desc_total_error_count_get, _libm2k.m2k_uart_desc_total_error_count_set, doc=r"""total_error_count : unsigned int""")

    def __init__(self):
        r"""__init__(m2k_uart_desc self) -> m2k_uart_desc"""
        _libm2k.m2k_uart_desc_swiginit(self, _libm2k.new_m2k_uart_desc())
    __swig_destroy__ = _libm2k.delete_m2k_uart_desc

# Register m2k_uart_desc in _libm2k:
_libm2k.m2k_uart_desc_swigregister(m2k_uart_desc)

class DMMReading(object):
    r"""Proxy of C++ std::vector< libm2k::analog::DMM_READING > class."""

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

    def iterator(self):
        r"""iterator(DMMReading self) -> SwigPyIterator"""
        return _libm2k.DMMReading_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(DMMReading self) -> bool"""
        return _libm2k.DMMReading___nonzero__(self)

    def __bool__(self):
        r"""__bool__(DMMReading self) -> bool"""
        return _libm2k.DMMReading___bool__(self)

    def __len__(self):
        r"""__len__(DMMReading self) -> std::vector< libm2k::analog::DMM_READING >::size_type"""
        return _libm2k.DMMReading___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(DMMReading self, std::vector< libm2k::analog::DMM_READING >::difference_type i, std::vector< libm2k::analog::DMM_READING >::difference_type j) -> DMMReading

        Parameters
        ----------
        i: std::vector< libm2k::analog::DMM_READING >::difference_type
        j: std::vector< libm2k::analog::DMM_READING >::difference_type

        """
        return _libm2k.DMMReading___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(DMMReading self, std::vector< libm2k::analog::DMM_READING >::difference_type i, std::vector< libm2k::analog::DMM_READING >::difference_type j)

        Parameters
        ----------
        i: std::vector< libm2k::analog::DMM_READING >::difference_type
        j: std::vector< libm2k::analog::DMM_READING >::difference_type

        __setslice__(DMMReading self, std::vector< libm2k::analog::DMM_READING >::difference_type i, std::vector< libm2k::analog::DMM_READING >::difference_type j, DMMReading v)

        Parameters
        ----------
        i: std::vector< libm2k::analog::DMM_READING >::difference_type
        j: std::vector< libm2k::analog::DMM_READING >::difference_type
        v: std::vector< libm2k::analog::DMM_READING,std::allocator< libm2k::analog::DMM_READING > > const &

        """
        return _libm2k.DMMReading___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(DMMReading self, std::vector< libm2k::analog::DMM_READING >::difference_type i, std::vector< libm2k::analog::DMM_READING >::difference_type j)

        Parameters
        ----------
        i: std::vector< libm2k::analog::DMM_READING >::difference_type
        j: std::vector< libm2k::analog::DMM_READING >::difference_type

        """
        return _libm2k.DMMReading___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(DMMReading self, std::vector< libm2k::analog::DMM_READING >::difference_type i)

        Parameters
        ----------
        i: std::vector< libm2k::analog::DMM_READING >::difference_type

        __delitem__(DMMReading self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.DMMReading___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(DMMReading self, PySliceObject * slice) -> DMMReading

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(DMMReading self, std::vector< libm2k::analog::DMM_READING >::difference_type i) -> DMM_READING

        Parameters
        ----------
        i: std::vector< libm2k::analog::DMM_READING >::difference_type

        """
        return _libm2k.DMMReading___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(DMMReading self, PySliceObject * slice, DMMReading v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< libm2k::analog::DMM_READING,std::allocator< libm2k::analog::DMM_READING > > const &

        __setitem__(DMMReading self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(DMMReading self, std::vector< libm2k::analog::DMM_READING >::difference_type i, DMM_READING x)

        Parameters
        ----------
        i: std::vector< libm2k::analog::DMM_READING >::difference_type
        x: std::vector< libm2k::analog::DMM_READING >::value_type const &

        """
        return _libm2k.DMMReading___setitem__(self, *args)

    def pop(self):
        r"""pop(DMMReading self) -> DMM_READING"""
        return _libm2k.DMMReading_pop(self)

    def append(self, x):
        r"""
        append(DMMReading self, DMM_READING x)

        Parameters
        ----------
        x: std::vector< libm2k::analog::DMM_READING >::value_type const &

        """
        return _libm2k.DMMReading_append(self, x)

    def empty(self):
        r"""empty(DMMReading self) -> bool"""
        return _libm2k.DMMReading_empty(self)

    def size(self):
        r"""size(DMMReading self) -> std::vector< libm2k::analog::DMM_READING >::size_type"""
        return _libm2k.DMMReading_size(self)

    def swap(self, v):
        r"""
        swap(DMMReading self, DMMReading v)

        Parameters
        ----------
        v: std::vector< libm2k::analog::DMM_READING > &

        """
        return _libm2k.DMMReading_swap(self, v)

    def begin(self):
        r"""begin(DMMReading self) -> std::vector< libm2k::analog::DMM_READING >::iterator"""
        return _libm2k.DMMReading_begin(self)

    def end(self):
        r"""end(DMMReading self) -> std::vector< libm2k::analog::DMM_READING >::iterator"""
        return _libm2k.DMMReading_end(self)

    def rbegin(self):
        r"""rbegin(DMMReading self) -> std::vector< libm2k::analog::DMM_READING >::reverse_iterator"""
        return _libm2k.DMMReading_rbegin(self)

    def rend(self):
        r"""rend(DMMReading self) -> std::vector< libm2k::analog::DMM_READING >::reverse_iterator"""
        return _libm2k.DMMReading_rend(self)

    def clear(self):
        r"""clear(DMMReading self)"""
        return _libm2k.DMMReading_clear(self)

    def get_allocator(self):
        r"""get_allocator(DMMReading self) -> std::vector< libm2k::analog::DMM_READING >::allocator_type"""
        return _libm2k.DMMReading_get_allocator(self)

    def pop_back(self):
        r"""pop_back(DMMReading self)"""
        return _libm2k.DMMReading_pop_back(self)

    def erase(self, *args):
        r"""
        erase(DMMReading self, std::vector< libm2k::analog::DMM_READING >::iterator pos) -> std::vector< libm2k::analog::DMM_READING >::iterator

        Parameters
        ----------
        pos: std::vector< libm2k::analog::DMM_READING >::iterator

        erase(DMMReading self, std::vector< libm2k::analog::DMM_READING >::iterator first, std::vector< libm2k::analog::DMM_READING >::iterator last) -> std::vector< libm2k::analog::DMM_READING >::iterator

        Parameters
        ----------
        first: std::vector< libm2k::analog::DMM_READING >::iterator
        last: std::vector< libm2k::analog::DMM_READING >::iterator

        """
        return _libm2k.DMMReading_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(DMMReading self) -> DMMReading
        __init__(DMMReading self, DMMReading other) -> DMMReading

        Parameters
        ----------
        other: std::vector< libm2k::analog::DMM_READING > const &

        __init__(DMMReading self, std::vector< libm2k::analog::DMM_READING >::size_type size) -> DMMReading

        Parameters
        ----------
        size: std::vector< libm2k::analog::DMM_READING >::size_type

        __init__(DMMReading self, std::vector< libm2k::analog::DMM_READING >::size_type size, DMM_READING value) -> DMMReading

        Parameters
        ----------
        size: std::vector< libm2k::analog::DMM_READING >::size_type
        value: std::vector< libm2k::analog::DMM_READING >::value_type const &

        """
        _libm2k.DMMReading_swiginit(self, _libm2k.new_DMMReading(*args))

    def push_back(self, x):
        r"""
        push_back(DMMReading self, DMM_READING x)

        Parameters
        ----------
        x: std::vector< libm2k::analog::DMM_READING >::value_type const &

        """
        return _libm2k.DMMReading_push_back(self, x)

    def front(self):
        r"""front(DMMReading self) -> DMM_READING"""
        return _libm2k.DMMReading_front(self)

    def back(self):
        r"""back(DMMReading self) -> DMM_READING"""
        return _libm2k.DMMReading_back(self)

    def assign(self, n, x):
        r"""
        assign(DMMReading self, std::vector< libm2k::analog::DMM_READING >::size_type n, DMM_READING x)

        Parameters
        ----------
        n: std::vector< libm2k::analog::DMM_READING >::size_type
        x: std::vector< libm2k::analog::DMM_READING >::value_type const &

        """
        return _libm2k.DMMReading_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(DMMReading self, std::vector< libm2k::analog::DMM_READING >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< libm2k::analog::DMM_READING >::size_type

        resize(DMMReading self, std::vector< libm2k::analog::DMM_READING >::size_type new_size, DMM_READING x)

        Parameters
        ----------
        new_size: std::vector< libm2k::analog::DMM_READING >::size_type
        x: std::vector< libm2k::analog::DMM_READING >::value_type const &

        """
        return _libm2k.DMMReading_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(DMMReading self, std::vector< libm2k::analog::DMM_READING >::iterator pos, DMM_READING x) -> std::vector< libm2k::analog::DMM_READING >::iterator

        Parameters
        ----------
        pos: std::vector< libm2k::analog::DMM_READING >::iterator
        x: std::vector< libm2k::analog::DMM_READING >::value_type const &

        insert(DMMReading self, std::vector< libm2k::analog::DMM_READING >::iterator pos, std::vector< libm2k::analog::DMM_READING >::size_type n, DMM_READING x)

        Parameters
        ----------
        pos: std::vector< libm2k::analog::DMM_READING >::iterator
        n: std::vector< libm2k::analog::DMM_READING >::size_type
        x: std::vector< libm2k::analog::DMM_READING >::value_type const &

        """
        return _libm2k.DMMReading_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(DMMReading self, std::vector< libm2k::analog::DMM_READING >::size_type n)

        Parameters
        ----------
        n: std::vector< libm2k::analog::DMM_READING >::size_type

        """
        return _libm2k.DMMReading_reserve(self, n)

    def capacity(self):
        r"""capacity(DMMReading self) -> std::vector< libm2k::analog::DMM_READING >::size_type"""
        return _libm2k.DMMReading_capacity(self)
    __swig_destroy__ = _libm2k.delete_DMMReading

# Register DMMReading in _libm2k:
_libm2k.DMMReading_swigregister(DMMReading)

class DMMs(object):
    r"""Proxy of C++ std::vector< libm2k::analog::DMM * > class."""

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

    def iterator(self):
        r"""iterator(DMMs self) -> SwigPyIterator"""
        return _libm2k.DMMs_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(DMMs self) -> bool"""
        return _libm2k.DMMs___nonzero__(self)

    def __bool__(self):
        r"""__bool__(DMMs self) -> bool"""
        return _libm2k.DMMs___bool__(self)

    def __len__(self):
        r"""__len__(DMMs self) -> std::vector< libm2k::analog::DMM * >::size_type"""
        return _libm2k.DMMs___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(DMMs self, std::vector< libm2k::analog::DMM * >::difference_type i, std::vector< libm2k::analog::DMM * >::difference_type j) -> DMMs

        Parameters
        ----------
        i: std::vector< libm2k::analog::DMM * >::difference_type
        j: std::vector< libm2k::analog::DMM * >::difference_type

        """
        return _libm2k.DMMs___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(DMMs self, std::vector< libm2k::analog::DMM * >::difference_type i, std::vector< libm2k::analog::DMM * >::difference_type j)

        Parameters
        ----------
        i: std::vector< libm2k::analog::DMM * >::difference_type
        j: std::vector< libm2k::analog::DMM * >::difference_type

        __setslice__(DMMs self, std::vector< libm2k::analog::DMM * >::difference_type i, std::vector< libm2k::analog::DMM * >::difference_type j, DMMs v)

        Parameters
        ----------
        i: std::vector< libm2k::analog::DMM * >::difference_type
        j: std::vector< libm2k::analog::DMM * >::difference_type
        v: std::vector< libm2k::analog::DMM *,std::allocator< libm2k::analog::DMM * > > const &

        """
        return _libm2k.DMMs___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(DMMs self, std::vector< libm2k::analog::DMM * >::difference_type i, std::vector< libm2k::analog::DMM * >::difference_type j)

        Parameters
        ----------
        i: std::vector< libm2k::analog::DMM * >::difference_type
        j: std::vector< libm2k::analog::DMM * >::difference_type

        """
        return _libm2k.DMMs___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(DMMs self, std::vector< libm2k::analog::DMM * >::difference_type i)

        Parameters
        ----------
        i: std::vector< libm2k::analog::DMM * >::difference_type

        __delitem__(DMMs self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.DMMs___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(DMMs self, PySliceObject * slice) -> DMMs

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(DMMs self, std::vector< libm2k::analog::DMM * >::difference_type i) -> DMM

        Parameters
        ----------
        i: std::vector< libm2k::analog::DMM * >::difference_type

        """
        return _libm2k.DMMs___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(DMMs self, PySliceObject * slice, DMMs v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< libm2k::analog::DMM *,std::allocator< libm2k::analog::DMM * > > const &

        __setitem__(DMMs self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(DMMs self, std::vector< libm2k::analog::DMM * >::difference_type i, DMM x)

        Parameters
        ----------
        i: std::vector< libm2k::analog::DMM * >::difference_type
        x: std::vector< libm2k::analog::DMM * >::value_type

        """
        return _libm2k.DMMs___setitem__(self, *args)

    def pop(self):
        r"""pop(DMMs self) -> DMM"""
        return _libm2k.DMMs_pop(self)

    def append(self, x):
        r"""
        append(DMMs self, DMM x)

        Parameters
        ----------
        x: std::vector< libm2k::analog::DMM * >::value_type

        """
        return _libm2k.DMMs_append(self, x)

    def empty(self):
        r"""empty(DMMs self) -> bool"""
        return _libm2k.DMMs_empty(self)

    def size(self):
        r"""size(DMMs self) -> std::vector< libm2k::analog::DMM * >::size_type"""
        return _libm2k.DMMs_size(self)

    def swap(self, v):
        r"""
        swap(DMMs self, DMMs v)

        Parameters
        ----------
        v: std::vector< libm2k::analog::DMM * > &

        """
        return _libm2k.DMMs_swap(self, v)

    def begin(self):
        r"""begin(DMMs self) -> std::vector< libm2k::analog::DMM * >::iterator"""
        return _libm2k.DMMs_begin(self)

    def end(self):
        r"""end(DMMs self) -> std::vector< libm2k::analog::DMM * >::iterator"""
        return _libm2k.DMMs_end(self)

    def rbegin(self):
        r"""rbegin(DMMs self) -> std::vector< libm2k::analog::DMM * >::reverse_iterator"""
        return _libm2k.DMMs_rbegin(self)

    def rend(self):
        r"""rend(DMMs self) -> std::vector< libm2k::analog::DMM * >::reverse_iterator"""
        return _libm2k.DMMs_rend(self)

    def clear(self):
        r"""clear(DMMs self)"""
        return _libm2k.DMMs_clear(self)

    def get_allocator(self):
        r"""get_allocator(DMMs self) -> std::vector< libm2k::analog::DMM * >::allocator_type"""
        return _libm2k.DMMs_get_allocator(self)

    def pop_back(self):
        r"""pop_back(DMMs self)"""
        return _libm2k.DMMs_pop_back(self)

    def erase(self, *args):
        r"""
        erase(DMMs self, std::vector< libm2k::analog::DMM * >::iterator pos) -> std::vector< libm2k::analog::DMM * >::iterator

        Parameters
        ----------
        pos: std::vector< libm2k::analog::DMM * >::iterator

        erase(DMMs self, std::vector< libm2k::analog::DMM * >::iterator first, std::vector< libm2k::analog::DMM * >::iterator last) -> std::vector< libm2k::analog::DMM * >::iterator

        Parameters
        ----------
        first: std::vector< libm2k::analog::DMM * >::iterator
        last: std::vector< libm2k::analog::DMM * >::iterator

        """
        return _libm2k.DMMs_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(DMMs self) -> DMMs
        __init__(DMMs self, DMMs other) -> DMMs

        Parameters
        ----------
        other: std::vector< libm2k::analog::DMM * > const &

        __init__(DMMs self, std::vector< libm2k::analog::DMM * >::size_type size) -> DMMs

        Parameters
        ----------
        size: std::vector< libm2k::analog::DMM * >::size_type

        __init__(DMMs self, std::vector< libm2k::analog::DMM * >::size_type size, DMM value) -> DMMs

        Parameters
        ----------
        size: std::vector< libm2k::analog::DMM * >::size_type
        value: std::vector< libm2k::analog::DMM * >::value_type

        """
        _libm2k.DMMs_swiginit(self, _libm2k.new_DMMs(*args))

    def push_back(self, x):
        r"""
        push_back(DMMs self, DMM x)

        Parameters
        ----------
        x: std::vector< libm2k::analog::DMM * >::value_type

        """
        return _libm2k.DMMs_push_back(self, x)

    def front(self):
        r"""front(DMMs self) -> DMM"""
        return _libm2k.DMMs_front(self)

    def back(self):
        r"""back(DMMs self) -> DMM"""
        return _libm2k.DMMs_back(self)

    def assign(self, n, x):
        r"""
        assign(DMMs self, std::vector< libm2k::analog::DMM * >::size_type n, DMM x)

        Parameters
        ----------
        n: std::vector< libm2k::analog::DMM * >::size_type
        x: std::vector< libm2k::analog::DMM * >::value_type

        """
        return _libm2k.DMMs_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(DMMs self, std::vector< libm2k::analog::DMM * >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< libm2k::analog::DMM * >::size_type

        resize(DMMs self, std::vector< libm2k::analog::DMM * >::size_type new_size, DMM x)

        Parameters
        ----------
        new_size: std::vector< libm2k::analog::DMM * >::size_type
        x: std::vector< libm2k::analog::DMM * >::value_type

        """
        return _libm2k.DMMs_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(DMMs self, std::vector< libm2k::analog::DMM * >::iterator pos, DMM x) -> std::vector< libm2k::analog::DMM * >::iterator

        Parameters
        ----------
        pos: std::vector< libm2k::analog::DMM * >::iterator
        x: std::vector< libm2k::analog::DMM * >::value_type

        insert(DMMs self, std::vector< libm2k::analog::DMM * >::iterator pos, std::vector< libm2k::analog::DMM * >::size_type n, DMM x)

        Parameters
        ----------
        pos: std::vector< libm2k::analog::DMM * >::iterator
        n: std::vector< libm2k::analog::DMM * >::size_type
        x: std::vector< libm2k::analog::DMM * >::value_type

        """
        return _libm2k.DMMs_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(DMMs self, std::vector< libm2k::analog::DMM * >::size_type n)

        Parameters
        ----------
        n: std::vector< libm2k::analog::DMM * >::size_type

        """
        return _libm2k.DMMs_reserve(self, n)

    def capacity(self):
        r"""capacity(DMMs self) -> std::vector< libm2k::analog::DMM * >::size_type"""
        return _libm2k.DMMs_capacity(self)
    __swig_destroy__ = _libm2k.delete_DMMs

# Register DMMs in _libm2k:
_libm2k.DMMs_swigregister(DMMs)

class M2kAnalogIns(object):
    r"""Proxy of C++ std::vector< libm2k::analog::M2kAnalogIn * > class."""

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

    def iterator(self):
        r"""iterator(M2kAnalogIns self) -> SwigPyIterator"""
        return _libm2k.M2kAnalogIns_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(M2kAnalogIns self) -> bool"""
        return _libm2k.M2kAnalogIns___nonzero__(self)

    def __bool__(self):
        r"""__bool__(M2kAnalogIns self) -> bool"""
        return _libm2k.M2kAnalogIns___bool__(self)

    def __len__(self):
        r"""__len__(M2kAnalogIns self) -> std::vector< libm2k::analog::M2kAnalogIn * >::size_type"""
        return _libm2k.M2kAnalogIns___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::difference_type i, std::vector< libm2k::analog::M2kAnalogIn * >::difference_type j) -> M2kAnalogIns

        Parameters
        ----------
        i: std::vector< libm2k::analog::M2kAnalogIn * >::difference_type
        j: std::vector< libm2k::analog::M2kAnalogIn * >::difference_type

        """
        return _libm2k.M2kAnalogIns___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::difference_type i, std::vector< libm2k::analog::M2kAnalogIn * >::difference_type j)

        Parameters
        ----------
        i: std::vector< libm2k::analog::M2kAnalogIn * >::difference_type
        j: std::vector< libm2k::analog::M2kAnalogIn * >::difference_type

        __setslice__(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::difference_type i, std::vector< libm2k::analog::M2kAnalogIn * >::difference_type j, M2kAnalogIns v)

        Parameters
        ----------
        i: std::vector< libm2k::analog::M2kAnalogIn * >::difference_type
        j: std::vector< libm2k::analog::M2kAnalogIn * >::difference_type
        v: std::vector< libm2k::analog::M2kAnalogIn *,std::allocator< libm2k::analog::M2kAnalogIn * > > const &

        """
        return _libm2k.M2kAnalogIns___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::difference_type i, std::vector< libm2k::analog::M2kAnalogIn * >::difference_type j)

        Parameters
        ----------
        i: std::vector< libm2k::analog::M2kAnalogIn * >::difference_type
        j: std::vector< libm2k::analog::M2kAnalogIn * >::difference_type

        """
        return _libm2k.M2kAnalogIns___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::difference_type i)

        Parameters
        ----------
        i: std::vector< libm2k::analog::M2kAnalogIn * >::difference_type

        __delitem__(M2kAnalogIns self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.M2kAnalogIns___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(M2kAnalogIns self, PySliceObject * slice) -> M2kAnalogIns

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::difference_type i) -> M2kAnalogIn

        Parameters
        ----------
        i: std::vector< libm2k::analog::M2kAnalogIn * >::difference_type

        """
        return _libm2k.M2kAnalogIns___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(M2kAnalogIns self, PySliceObject * slice, M2kAnalogIns v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< libm2k::analog::M2kAnalogIn *,std::allocator< libm2k::analog::M2kAnalogIn * > > const &

        __setitem__(M2kAnalogIns self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::difference_type i, M2kAnalogIn x)

        Parameters
        ----------
        i: std::vector< libm2k::analog::M2kAnalogIn * >::difference_type
        x: std::vector< libm2k::analog::M2kAnalogIn * >::value_type

        """
        return _libm2k.M2kAnalogIns___setitem__(self, *args)

    def pop(self):
        r"""pop(M2kAnalogIns self) -> M2kAnalogIn"""
        return _libm2k.M2kAnalogIns_pop(self)

    def append(self, x):
        r"""
        append(M2kAnalogIns self, M2kAnalogIn x)

        Parameters
        ----------
        x: std::vector< libm2k::analog::M2kAnalogIn * >::value_type

        """
        return _libm2k.M2kAnalogIns_append(self, x)

    def empty(self):
        r"""empty(M2kAnalogIns self) -> bool"""
        return _libm2k.M2kAnalogIns_empty(self)

    def size(self):
        r"""size(M2kAnalogIns self) -> std::vector< libm2k::analog::M2kAnalogIn * >::size_type"""
        return _libm2k.M2kAnalogIns_size(self)

    def swap(self, v):
        r"""
        swap(M2kAnalogIns self, M2kAnalogIns v)

        Parameters
        ----------
        v: std::vector< libm2k::analog::M2kAnalogIn * > &

        """
        return _libm2k.M2kAnalogIns_swap(self, v)

    def begin(self):
        r"""begin(M2kAnalogIns self) -> std::vector< libm2k::analog::M2kAnalogIn * >::iterator"""
        return _libm2k.M2kAnalogIns_begin(self)

    def end(self):
        r"""end(M2kAnalogIns self) -> std::vector< libm2k::analog::M2kAnalogIn * >::iterator"""
        return _libm2k.M2kAnalogIns_end(self)

    def rbegin(self):
        r"""rbegin(M2kAnalogIns self) -> std::vector< libm2k::analog::M2kAnalogIn * >::reverse_iterator"""
        return _libm2k.M2kAnalogIns_rbegin(self)

    def rend(self):
        r"""rend(M2kAnalogIns self) -> std::vector< libm2k::analog::M2kAnalogIn * >::reverse_iterator"""
        return _libm2k.M2kAnalogIns_rend(self)

    def clear(self):
        r"""clear(M2kAnalogIns self)"""
        return _libm2k.M2kAnalogIns_clear(self)

    def get_allocator(self):
        r"""get_allocator(M2kAnalogIns self) -> std::vector< libm2k::analog::M2kAnalogIn * >::allocator_type"""
        return _libm2k.M2kAnalogIns_get_allocator(self)

    def pop_back(self):
        r"""pop_back(M2kAnalogIns self)"""
        return _libm2k.M2kAnalogIns_pop_back(self)

    def erase(self, *args):
        r"""
        erase(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::iterator pos) -> std::vector< libm2k::analog::M2kAnalogIn * >::iterator

        Parameters
        ----------
        pos: std::vector< libm2k::analog::M2kAnalogIn * >::iterator

        erase(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::iterator first, std::vector< libm2k::analog::M2kAnalogIn * >::iterator last) -> std::vector< libm2k::analog::M2kAnalogIn * >::iterator

        Parameters
        ----------
        first: std::vector< libm2k::analog::M2kAnalogIn * >::iterator
        last: std::vector< libm2k::analog::M2kAnalogIn * >::iterator

        """
        return _libm2k.M2kAnalogIns_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(M2kAnalogIns self) -> M2kAnalogIns
        __init__(M2kAnalogIns self, M2kAnalogIns other) -> M2kAnalogIns

        Parameters
        ----------
        other: std::vector< libm2k::analog::M2kAnalogIn * > const &

        __init__(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::size_type size) -> M2kAnalogIns

        Parameters
        ----------
        size: std::vector< libm2k::analog::M2kAnalogIn * >::size_type

        __init__(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::size_type size, M2kAnalogIn value) -> M2kAnalogIns

        Parameters
        ----------
        size: std::vector< libm2k::analog::M2kAnalogIn * >::size_type
        value: std::vector< libm2k::analog::M2kAnalogIn * >::value_type

        """
        _libm2k.M2kAnalogIns_swiginit(self, _libm2k.new_M2kAnalogIns(*args))

    def push_back(self, x):
        r"""
        push_back(M2kAnalogIns self, M2kAnalogIn x)

        Parameters
        ----------
        x: std::vector< libm2k::analog::M2kAnalogIn * >::value_type

        """
        return _libm2k.M2kAnalogIns_push_back(self, x)

    def front(self):
        r"""front(M2kAnalogIns self) -> M2kAnalogIn"""
        return _libm2k.M2kAnalogIns_front(self)

    def back(self):
        r"""back(M2kAnalogIns self) -> M2kAnalogIn"""
        return _libm2k.M2kAnalogIns_back(self)

    def assign(self, n, x):
        r"""
        assign(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::size_type n, M2kAnalogIn x)

        Parameters
        ----------
        n: std::vector< libm2k::analog::M2kAnalogIn * >::size_type
        x: std::vector< libm2k::analog::M2kAnalogIn * >::value_type

        """
        return _libm2k.M2kAnalogIns_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< libm2k::analog::M2kAnalogIn * >::size_type

        resize(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::size_type new_size, M2kAnalogIn x)

        Parameters
        ----------
        new_size: std::vector< libm2k::analog::M2kAnalogIn * >::size_type
        x: std::vector< libm2k::analog::M2kAnalogIn * >::value_type

        """
        return _libm2k.M2kAnalogIns_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::iterator pos, M2kAnalogIn x) -> std::vector< libm2k::analog::M2kAnalogIn * >::iterator

        Parameters
        ----------
        pos: std::vector< libm2k::analog::M2kAnalogIn * >::iterator
        x: std::vector< libm2k::analog::M2kAnalogIn * >::value_type

        insert(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::iterator pos, std::vector< libm2k::analog::M2kAnalogIn * >::size_type n, M2kAnalogIn x)

        Parameters
        ----------
        pos: std::vector< libm2k::analog::M2kAnalogIn * >::iterator
        n: std::vector< libm2k::analog::M2kAnalogIn * >::size_type
        x: std::vector< libm2k::analog::M2kAnalogIn * >::value_type

        """
        return _libm2k.M2kAnalogIns_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(M2kAnalogIns self, std::vector< libm2k::analog::M2kAnalogIn * >::size_type n)

        Parameters
        ----------
        n: std::vector< libm2k::analog::M2kAnalogIn * >::size_type

        """
        return _libm2k.M2kAnalogIns_reserve(self, n)

    def capacity(self):
        r"""capacity(M2kAnalogIns self) -> std::vector< libm2k::analog::M2kAnalogIn * >::size_type"""
        return _libm2k.M2kAnalogIns_capacity(self)
    __swig_destroy__ = _libm2k.delete_M2kAnalogIns

# Register M2kAnalogIns in _libm2k:
_libm2k.M2kAnalogIns_swigregister(M2kAnalogIns)

class M2kAnalogOuts(object):
    r"""Proxy of C++ std::vector< libm2k::analog::M2kAnalogOut * > class."""

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

    def iterator(self):
        r"""iterator(M2kAnalogOuts self) -> SwigPyIterator"""
        return _libm2k.M2kAnalogOuts_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(M2kAnalogOuts self) -> bool"""
        return _libm2k.M2kAnalogOuts___nonzero__(self)

    def __bool__(self):
        r"""__bool__(M2kAnalogOuts self) -> bool"""
        return _libm2k.M2kAnalogOuts___bool__(self)

    def __len__(self):
        r"""__len__(M2kAnalogOuts self) -> std::vector< libm2k::analog::M2kAnalogOut * >::size_type"""
        return _libm2k.M2kAnalogOuts___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::difference_type i, std::vector< libm2k::analog::M2kAnalogOut * >::difference_type j) -> M2kAnalogOuts

        Parameters
        ----------
        i: std::vector< libm2k::analog::M2kAnalogOut * >::difference_type
        j: std::vector< libm2k::analog::M2kAnalogOut * >::difference_type

        """
        return _libm2k.M2kAnalogOuts___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::difference_type i, std::vector< libm2k::analog::M2kAnalogOut * >::difference_type j)

        Parameters
        ----------
        i: std::vector< libm2k::analog::M2kAnalogOut * >::difference_type
        j: std::vector< libm2k::analog::M2kAnalogOut * >::difference_type

        __setslice__(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::difference_type i, std::vector< libm2k::analog::M2kAnalogOut * >::difference_type j, M2kAnalogOuts v)

        Parameters
        ----------
        i: std::vector< libm2k::analog::M2kAnalogOut * >::difference_type
        j: std::vector< libm2k::analog::M2kAnalogOut * >::difference_type
        v: std::vector< libm2k::analog::M2kAnalogOut *,std::allocator< libm2k::analog::M2kAnalogOut * > > const &

        """
        return _libm2k.M2kAnalogOuts___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::difference_type i, std::vector< libm2k::analog::M2kAnalogOut * >::difference_type j)

        Parameters
        ----------
        i: std::vector< libm2k::analog::M2kAnalogOut * >::difference_type
        j: std::vector< libm2k::analog::M2kAnalogOut * >::difference_type

        """
        return _libm2k.M2kAnalogOuts___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::difference_type i)

        Parameters
        ----------
        i: std::vector< libm2k::analog::M2kAnalogOut * >::difference_type

        __delitem__(M2kAnalogOuts self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.M2kAnalogOuts___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(M2kAnalogOuts self, PySliceObject * slice) -> M2kAnalogOuts

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::difference_type i) -> M2kAnalogOut

        Parameters
        ----------
        i: std::vector< libm2k::analog::M2kAnalogOut * >::difference_type

        """
        return _libm2k.M2kAnalogOuts___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(M2kAnalogOuts self, PySliceObject * slice, M2kAnalogOuts v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< libm2k::analog::M2kAnalogOut *,std::allocator< libm2k::analog::M2kAnalogOut * > > const &

        __setitem__(M2kAnalogOuts self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::difference_type i, M2kAnalogOut x)

        Parameters
        ----------
        i: std::vector< libm2k::analog::M2kAnalogOut * >::difference_type
        x: std::vector< libm2k::analog::M2kAnalogOut * >::value_type

        """
        return _libm2k.M2kAnalogOuts___setitem__(self, *args)

    def pop(self):
        r"""pop(M2kAnalogOuts self) -> M2kAnalogOut"""
        return _libm2k.M2kAnalogOuts_pop(self)

    def append(self, x):
        r"""
        append(M2kAnalogOuts self, M2kAnalogOut x)

        Parameters
        ----------
        x: std::vector< libm2k::analog::M2kAnalogOut * >::value_type

        """
        return _libm2k.M2kAnalogOuts_append(self, x)

    def empty(self):
        r"""empty(M2kAnalogOuts self) -> bool"""
        return _libm2k.M2kAnalogOuts_empty(self)

    def size(self):
        r"""size(M2kAnalogOuts self) -> std::vector< libm2k::analog::M2kAnalogOut * >::size_type"""
        return _libm2k.M2kAnalogOuts_size(self)

    def swap(self, v):
        r"""
        swap(M2kAnalogOuts self, M2kAnalogOuts v)

        Parameters
        ----------
        v: std::vector< libm2k::analog::M2kAnalogOut * > &

        """
        return _libm2k.M2kAnalogOuts_swap(self, v)

    def begin(self):
        r"""begin(M2kAnalogOuts self) -> std::vector< libm2k::analog::M2kAnalogOut * >::iterator"""
        return _libm2k.M2kAnalogOuts_begin(self)

    def end(self):
        r"""end(M2kAnalogOuts self) -> std::vector< libm2k::analog::M2kAnalogOut * >::iterator"""
        return _libm2k.M2kAnalogOuts_end(self)

    def rbegin(self):
        r"""rbegin(M2kAnalogOuts self) -> std::vector< libm2k::analog::M2kAnalogOut * >::reverse_iterator"""
        return _libm2k.M2kAnalogOuts_rbegin(self)

    def rend(self):
        r"""rend(M2kAnalogOuts self) -> std::vector< libm2k::analog::M2kAnalogOut * >::reverse_iterator"""
        return _libm2k.M2kAnalogOuts_rend(self)

    def clear(self):
        r"""clear(M2kAnalogOuts self)"""
        return _libm2k.M2kAnalogOuts_clear(self)

    def get_allocator(self):
        r"""get_allocator(M2kAnalogOuts self) -> std::vector< libm2k::analog::M2kAnalogOut * >::allocator_type"""
        return _libm2k.M2kAnalogOuts_get_allocator(self)

    def pop_back(self):
        r"""pop_back(M2kAnalogOuts self)"""
        return _libm2k.M2kAnalogOuts_pop_back(self)

    def erase(self, *args):
        r"""
        erase(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::iterator pos) -> std::vector< libm2k::analog::M2kAnalogOut * >::iterator

        Parameters
        ----------
        pos: std::vector< libm2k::analog::M2kAnalogOut * >::iterator

        erase(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::iterator first, std::vector< libm2k::analog::M2kAnalogOut * >::iterator last) -> std::vector< libm2k::analog::M2kAnalogOut * >::iterator

        Parameters
        ----------
        first: std::vector< libm2k::analog::M2kAnalogOut * >::iterator
        last: std::vector< libm2k::analog::M2kAnalogOut * >::iterator

        """
        return _libm2k.M2kAnalogOuts_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(M2kAnalogOuts self) -> M2kAnalogOuts
        __init__(M2kAnalogOuts self, M2kAnalogOuts other) -> M2kAnalogOuts

        Parameters
        ----------
        other: std::vector< libm2k::analog::M2kAnalogOut * > const &

        __init__(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::size_type size) -> M2kAnalogOuts

        Parameters
        ----------
        size: std::vector< libm2k::analog::M2kAnalogOut * >::size_type

        __init__(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::size_type size, M2kAnalogOut value) -> M2kAnalogOuts

        Parameters
        ----------
        size: std::vector< libm2k::analog::M2kAnalogOut * >::size_type
        value: std::vector< libm2k::analog::M2kAnalogOut * >::value_type

        """
        _libm2k.M2kAnalogOuts_swiginit(self, _libm2k.new_M2kAnalogOuts(*args))

    def push_back(self, x):
        r"""
        push_back(M2kAnalogOuts self, M2kAnalogOut x)

        Parameters
        ----------
        x: std::vector< libm2k::analog::M2kAnalogOut * >::value_type

        """
        return _libm2k.M2kAnalogOuts_push_back(self, x)

    def front(self):
        r"""front(M2kAnalogOuts self) -> M2kAnalogOut"""
        return _libm2k.M2kAnalogOuts_front(self)

    def back(self):
        r"""back(M2kAnalogOuts self) -> M2kAnalogOut"""
        return _libm2k.M2kAnalogOuts_back(self)

    def assign(self, n, x):
        r"""
        assign(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::size_type n, M2kAnalogOut x)

        Parameters
        ----------
        n: std::vector< libm2k::analog::M2kAnalogOut * >::size_type
        x: std::vector< libm2k::analog::M2kAnalogOut * >::value_type

        """
        return _libm2k.M2kAnalogOuts_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< libm2k::analog::M2kAnalogOut * >::size_type

        resize(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::size_type new_size, M2kAnalogOut x)

        Parameters
        ----------
        new_size: std::vector< libm2k::analog::M2kAnalogOut * >::size_type
        x: std::vector< libm2k::analog::M2kAnalogOut * >::value_type

        """
        return _libm2k.M2kAnalogOuts_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::iterator pos, M2kAnalogOut x) -> std::vector< libm2k::analog::M2kAnalogOut * >::iterator

        Parameters
        ----------
        pos: std::vector< libm2k::analog::M2kAnalogOut * >::iterator
        x: std::vector< libm2k::analog::M2kAnalogOut * >::value_type

        insert(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::iterator pos, std::vector< libm2k::analog::M2kAnalogOut * >::size_type n, M2kAnalogOut x)

        Parameters
        ----------
        pos: std::vector< libm2k::analog::M2kAnalogOut * >::iterator
        n: std::vector< libm2k::analog::M2kAnalogOut * >::size_type
        x: std::vector< libm2k::analog::M2kAnalogOut * >::value_type

        """
        return _libm2k.M2kAnalogOuts_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(M2kAnalogOuts self, std::vector< libm2k::analog::M2kAnalogOut * >::size_type n)

        Parameters
        ----------
        n: std::vector< libm2k::analog::M2kAnalogOut * >::size_type

        """
        return _libm2k.M2kAnalogOuts_reserve(self, n)

    def capacity(self):
        r"""capacity(M2kAnalogOuts self) -> std::vector< libm2k::analog::M2kAnalogOut * >::size_type"""
        return _libm2k.M2kAnalogOuts_capacity(self)
    __swig_destroy__ = _libm2k.delete_M2kAnalogOuts

# Register M2kAnalogOuts in _libm2k:
_libm2k.M2kAnalogOuts_swigregister(M2kAnalogOuts)

class M2kConditionAnalog(object):
    r"""Proxy of C++ std::vector< libm2k::M2K_TRIGGER_CONDITION_ANALOG > class."""

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

    def iterator(self):
        r"""iterator(M2kConditionAnalog self) -> SwigPyIterator"""
        return _libm2k.M2kConditionAnalog_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(M2kConditionAnalog self) -> bool"""
        return _libm2k.M2kConditionAnalog___nonzero__(self)

    def __bool__(self):
        r"""__bool__(M2kConditionAnalog self) -> bool"""
        return _libm2k.M2kConditionAnalog___bool__(self)

    def __len__(self):
        r"""__len__(M2kConditionAnalog self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type"""
        return _libm2k.M2kConditionAnalog___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type j) -> M2kConditionAnalog

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type
        j: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type

        """
        return _libm2k.M2kConditionAnalog___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type j)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type
        j: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type

        __setslice__(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type j, M2kConditionAnalog v)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type
        j: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type
        v: std::vector< libm2k::M2K_TRIGGER_CONDITION_ANALOG,std::allocator< libm2k::M2K_TRIGGER_CONDITION_ANALOG > > const &

        """
        return _libm2k.M2kConditionAnalog___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type j)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type
        j: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type

        """
        return _libm2k.M2kConditionAnalog___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type i)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type

        __delitem__(M2kConditionAnalog self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.M2kConditionAnalog___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(M2kConditionAnalog self, PySliceObject * slice) -> M2kConditionAnalog

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type i) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const &

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type

        """
        return _libm2k.M2kConditionAnalog___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(M2kConditionAnalog self, PySliceObject * slice, M2kConditionAnalog v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< libm2k::M2K_TRIGGER_CONDITION_ANALOG,std::allocator< libm2k::M2K_TRIGGER_CONDITION_ANALOG > > const &

        __setitem__(M2kConditionAnalog self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const & x)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::difference_type
        x: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const &

        """
        return _libm2k.M2kConditionAnalog___setitem__(self, *args)

    def pop(self):
        r"""pop(M2kConditionAnalog self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type"""
        return _libm2k.M2kConditionAnalog_pop(self)

    def append(self, x):
        r"""
        append(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const & x)

        Parameters
        ----------
        x: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const &

        """
        return _libm2k.M2kConditionAnalog_append(self, x)

    def empty(self):
        r"""empty(M2kConditionAnalog self) -> bool"""
        return _libm2k.M2kConditionAnalog_empty(self)

    def size(self):
        r"""size(M2kConditionAnalog self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type"""
        return _libm2k.M2kConditionAnalog_size(self)

    def swap(self, v):
        r"""
        swap(M2kConditionAnalog self, M2kConditionAnalog v)

        Parameters
        ----------
        v: std::vector< libm2k::M2K_TRIGGER_CONDITION_ANALOG > &

        """
        return _libm2k.M2kConditionAnalog_swap(self, v)

    def begin(self):
        r"""begin(M2kConditionAnalog self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator"""
        return _libm2k.M2kConditionAnalog_begin(self)

    def end(self):
        r"""end(M2kConditionAnalog self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator"""
        return _libm2k.M2kConditionAnalog_end(self)

    def rbegin(self):
        r"""rbegin(M2kConditionAnalog self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::reverse_iterator"""
        return _libm2k.M2kConditionAnalog_rbegin(self)

    def rend(self):
        r"""rend(M2kConditionAnalog self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::reverse_iterator"""
        return _libm2k.M2kConditionAnalog_rend(self)

    def clear(self):
        r"""clear(M2kConditionAnalog self)"""
        return _libm2k.M2kConditionAnalog_clear(self)

    def get_allocator(self):
        r"""get_allocator(M2kConditionAnalog self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::allocator_type"""
        return _libm2k.M2kConditionAnalog_get_allocator(self)

    def pop_back(self):
        r"""pop_back(M2kConditionAnalog self)"""
        return _libm2k.M2kConditionAnalog_pop_back(self)

    def erase(self, *args):
        r"""
        erase(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator pos) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator

        Parameters
        ----------
        pos: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator

        erase(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator first, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator last) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator

        Parameters
        ----------
        first: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator
        last: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator

        """
        return _libm2k.M2kConditionAnalog_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(M2kConditionAnalog self) -> M2kConditionAnalog
        __init__(M2kConditionAnalog self, M2kConditionAnalog other) -> M2kConditionAnalog

        Parameters
        ----------
        other: std::vector< libm2k::M2K_TRIGGER_CONDITION_ANALOG > const &

        __init__(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type size) -> M2kConditionAnalog

        Parameters
        ----------
        size: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type

        __init__(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type size, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const & value) -> M2kConditionAnalog

        Parameters
        ----------
        size: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type
        value: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const &

        """
        _libm2k.M2kConditionAnalog_swiginit(self, _libm2k.new_M2kConditionAnalog(*args))

    def push_back(self, x):
        r"""
        push_back(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const & x)

        Parameters
        ----------
        x: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const &

        """
        return _libm2k.M2kConditionAnalog_push_back(self, x)

    def front(self):
        r"""front(M2kConditionAnalog self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const &"""
        return _libm2k.M2kConditionAnalog_front(self)

    def back(self):
        r"""back(M2kConditionAnalog self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const &"""
        return _libm2k.M2kConditionAnalog_back(self)

    def assign(self, n, x):
        r"""
        assign(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type n, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const & x)

        Parameters
        ----------
        n: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type
        x: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const &

        """
        return _libm2k.M2kConditionAnalog_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type

        resize(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type new_size, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type
        x: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const &

        """
        return _libm2k.M2kConditionAnalog_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator pos, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const & x) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator

        Parameters
        ----------
        pos: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator
        x: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const &

        insert(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator pos, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type n, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::iterator
        n: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type
        x: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::value_type const &

        """
        return _libm2k.M2kConditionAnalog_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(M2kConditionAnalog self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type n)

        Parameters
        ----------
        n: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type

        """
        return _libm2k.M2kConditionAnalog_reserve(self, n)

    def capacity(self):
        r"""capacity(M2kConditionAnalog self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_ANALOG >::size_type"""
        return _libm2k.M2kConditionAnalog_capacity(self)
    __swig_destroy__ = _libm2k.delete_M2kConditionAnalog

# Register M2kConditionAnalog in _libm2k:
_libm2k.M2kConditionAnalog_swigregister(M2kConditionAnalog)

class M2kConditionDigital(object):
    r"""Proxy of C++ std::vector< libm2k::M2K_TRIGGER_CONDITION_DIGITAL > class."""

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

    def iterator(self):
        r"""iterator(M2kConditionDigital self) -> SwigPyIterator"""
        return _libm2k.M2kConditionDigital_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(M2kConditionDigital self) -> bool"""
        return _libm2k.M2kConditionDigital___nonzero__(self)

    def __bool__(self):
        r"""__bool__(M2kConditionDigital self) -> bool"""
        return _libm2k.M2kConditionDigital___bool__(self)

    def __len__(self):
        r"""__len__(M2kConditionDigital self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type"""
        return _libm2k.M2kConditionDigital___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type j) -> M2kConditionDigital

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type
        j: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type

        """
        return _libm2k.M2kConditionDigital___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type j)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type
        j: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type

        __setslice__(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type j, M2kConditionDigital v)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type
        j: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type
        v: std::vector< libm2k::M2K_TRIGGER_CONDITION_DIGITAL,std::allocator< libm2k::M2K_TRIGGER_CONDITION_DIGITAL > > const &

        """
        return _libm2k.M2kConditionDigital___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type j)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type
        j: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type

        """
        return _libm2k.M2kConditionDigital___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type i)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type

        __delitem__(M2kConditionDigital self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.M2kConditionDigital___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(M2kConditionDigital self, PySliceObject * slice) -> M2kConditionDigital

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type i) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const &

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type

        """
        return _libm2k.M2kConditionDigital___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(M2kConditionDigital self, PySliceObject * slice, M2kConditionDigital v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< libm2k::M2K_TRIGGER_CONDITION_DIGITAL,std::allocator< libm2k::M2K_TRIGGER_CONDITION_DIGITAL > > const &

        __setitem__(M2kConditionDigital self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const & x)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::difference_type
        x: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const &

        """
        return _libm2k.M2kConditionDigital___setitem__(self, *args)

    def pop(self):
        r"""pop(M2kConditionDigital self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type"""
        return _libm2k.M2kConditionDigital_pop(self)

    def append(self, x):
        r"""
        append(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const & x)

        Parameters
        ----------
        x: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const &

        """
        return _libm2k.M2kConditionDigital_append(self, x)

    def empty(self):
        r"""empty(M2kConditionDigital self) -> bool"""
        return _libm2k.M2kConditionDigital_empty(self)

    def size(self):
        r"""size(M2kConditionDigital self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type"""
        return _libm2k.M2kConditionDigital_size(self)

    def swap(self, v):
        r"""
        swap(M2kConditionDigital self, M2kConditionDigital v)

        Parameters
        ----------
        v: std::vector< libm2k::M2K_TRIGGER_CONDITION_DIGITAL > &

        """
        return _libm2k.M2kConditionDigital_swap(self, v)

    def begin(self):
        r"""begin(M2kConditionDigital self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator"""
        return _libm2k.M2kConditionDigital_begin(self)

    def end(self):
        r"""end(M2kConditionDigital self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator"""
        return _libm2k.M2kConditionDigital_end(self)

    def rbegin(self):
        r"""rbegin(M2kConditionDigital self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::reverse_iterator"""
        return _libm2k.M2kConditionDigital_rbegin(self)

    def rend(self):
        r"""rend(M2kConditionDigital self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::reverse_iterator"""
        return _libm2k.M2kConditionDigital_rend(self)

    def clear(self):
        r"""clear(M2kConditionDigital self)"""
        return _libm2k.M2kConditionDigital_clear(self)

    def get_allocator(self):
        r"""get_allocator(M2kConditionDigital self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::allocator_type"""
        return _libm2k.M2kConditionDigital_get_allocator(self)

    def pop_back(self):
        r"""pop_back(M2kConditionDigital self)"""
        return _libm2k.M2kConditionDigital_pop_back(self)

    def erase(self, *args):
        r"""
        erase(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator pos) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator

        Parameters
        ----------
        pos: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator

        erase(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator first, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator last) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator

        Parameters
        ----------
        first: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator
        last: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator

        """
        return _libm2k.M2kConditionDigital_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(M2kConditionDigital self) -> M2kConditionDigital
        __init__(M2kConditionDigital self, M2kConditionDigital other) -> M2kConditionDigital

        Parameters
        ----------
        other: std::vector< libm2k::M2K_TRIGGER_CONDITION_DIGITAL > const &

        __init__(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type size) -> M2kConditionDigital

        Parameters
        ----------
        size: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type

        __init__(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type size, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const & value) -> M2kConditionDigital

        Parameters
        ----------
        size: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type
        value: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const &

        """
        _libm2k.M2kConditionDigital_swiginit(self, _libm2k.new_M2kConditionDigital(*args))

    def push_back(self, x):
        r"""
        push_back(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const & x)

        Parameters
        ----------
        x: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const &

        """
        return _libm2k.M2kConditionDigital_push_back(self, x)

    def front(self):
        r"""front(M2kConditionDigital self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const &"""
        return _libm2k.M2kConditionDigital_front(self)

    def back(self):
        r"""back(M2kConditionDigital self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const &"""
        return _libm2k.M2kConditionDigital_back(self)

    def assign(self, n, x):
        r"""
        assign(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type n, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const & x)

        Parameters
        ----------
        n: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type
        x: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const &

        """
        return _libm2k.M2kConditionDigital_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type

        resize(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type new_size, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type
        x: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const &

        """
        return _libm2k.M2kConditionDigital_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator pos, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const & x) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator

        Parameters
        ----------
        pos: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator
        x: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const &

        insert(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator pos, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type n, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::iterator
        n: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type
        x: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::value_type const &

        """
        return _libm2k.M2kConditionDigital_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(M2kConditionDigital self, std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type n)

        Parameters
        ----------
        n: std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type

        """
        return _libm2k.M2kConditionDigital_reserve(self, n)

    def capacity(self):
        r"""capacity(M2kConditionDigital self) -> std::vector< enum libm2k::M2K_TRIGGER_CONDITION_DIGITAL >::size_type"""
        return _libm2k.M2kConditionDigital_capacity(self)
    __swig_destroy__ = _libm2k.delete_M2kConditionDigital

# Register M2kConditionDigital in _libm2k:
_libm2k.M2kConditionDigital_swigregister(M2kConditionDigital)

class M2kModes(object):
    r"""Proxy of C++ std::vector< libm2k::M2K_TRIGGER_MODE > class."""

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

    def iterator(self):
        r"""iterator(M2kModes self) -> SwigPyIterator"""
        return _libm2k.M2kModes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(M2kModes self) -> bool"""
        return _libm2k.M2kModes___nonzero__(self)

    def __bool__(self):
        r"""__bool__(M2kModes self) -> bool"""
        return _libm2k.M2kModes___bool__(self)

    def __len__(self):
        r"""__len__(M2kModes self) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type"""
        return _libm2k.M2kModes___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type j) -> M2kModes

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type
        j: std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type

        """
        return _libm2k.M2kModes___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type j)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type
        j: std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type

        __setslice__(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type j, M2kModes v)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type
        j: std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type
        v: std::vector< libm2k::M2K_TRIGGER_MODE,std::allocator< libm2k::M2K_TRIGGER_MODE > > const &

        """
        return _libm2k.M2kModes___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type j)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type
        j: std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type

        """
        return _libm2k.M2kModes___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type i)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type

        __delitem__(M2kModes self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.M2kModes___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(M2kModes self, PySliceObject * slice) -> M2kModes

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type i) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const &

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type

        """
        return _libm2k.M2kModes___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(M2kModes self, PySliceObject * slice, M2kModes v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< libm2k::M2K_TRIGGER_MODE,std::allocator< libm2k::M2K_TRIGGER_MODE > > const &

        __setitem__(M2kModes self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type i, std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const & x)

        Parameters
        ----------
        i: std::vector< enum libm2k::M2K_TRIGGER_MODE >::difference_type
        x: std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const &

        """
        return _libm2k.M2kModes___setitem__(self, *args)

    def pop(self):
        r"""pop(M2kModes self) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type"""
        return _libm2k.M2kModes_pop(self)

    def append(self, x):
        r"""
        append(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const & x)

        Parameters
        ----------
        x: std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const &

        """
        return _libm2k.M2kModes_append(self, x)

    def empty(self):
        r"""empty(M2kModes self) -> bool"""
        return _libm2k.M2kModes_empty(self)

    def size(self):
        r"""size(M2kModes self) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type"""
        return _libm2k.M2kModes_size(self)

    def swap(self, v):
        r"""
        swap(M2kModes self, M2kModes v)

        Parameters
        ----------
        v: std::vector< libm2k::M2K_TRIGGER_MODE > &

        """
        return _libm2k.M2kModes_swap(self, v)

    def begin(self):
        r"""begin(M2kModes self) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator"""
        return _libm2k.M2kModes_begin(self)

    def end(self):
        r"""end(M2kModes self) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator"""
        return _libm2k.M2kModes_end(self)

    def rbegin(self):
        r"""rbegin(M2kModes self) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::reverse_iterator"""
        return _libm2k.M2kModes_rbegin(self)

    def rend(self):
        r"""rend(M2kModes self) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::reverse_iterator"""
        return _libm2k.M2kModes_rend(self)

    def clear(self):
        r"""clear(M2kModes self)"""
        return _libm2k.M2kModes_clear(self)

    def get_allocator(self):
        r"""get_allocator(M2kModes self) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::allocator_type"""
        return _libm2k.M2kModes_get_allocator(self)

    def pop_back(self):
        r"""pop_back(M2kModes self)"""
        return _libm2k.M2kModes_pop_back(self)

    def erase(self, *args):
        r"""
        erase(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator pos) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator

        Parameters
        ----------
        pos: std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator

        erase(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator first, std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator last) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator

        Parameters
        ----------
        first: std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator
        last: std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator

        """
        return _libm2k.M2kModes_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(M2kModes self) -> M2kModes
        __init__(M2kModes self, M2kModes other) -> M2kModes

        Parameters
        ----------
        other: std::vector< libm2k::M2K_TRIGGER_MODE > const &

        __init__(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type size) -> M2kModes

        Parameters
        ----------
        size: std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type

        __init__(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type size, std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const & value) -> M2kModes

        Parameters
        ----------
        size: std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type
        value: std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const &

        """
        _libm2k.M2kModes_swiginit(self, _libm2k.new_M2kModes(*args))

    def push_back(self, x):
        r"""
        push_back(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const & x)

        Parameters
        ----------
        x: std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const &

        """
        return _libm2k.M2kModes_push_back(self, x)

    def front(self):
        r"""front(M2kModes self) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const &"""
        return _libm2k.M2kModes_front(self)

    def back(self):
        r"""back(M2kModes self) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const &"""
        return _libm2k.M2kModes_back(self)

    def assign(self, n, x):
        r"""
        assign(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type n, std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const & x)

        Parameters
        ----------
        n: std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type
        x: std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const &

        """
        return _libm2k.M2kModes_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type

        resize(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type new_size, std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const & x)

        Parameters
        ----------
        new_size: std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type
        x: std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const &

        """
        return _libm2k.M2kModes_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator pos, std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const & x) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator

        Parameters
        ----------
        pos: std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator
        x: std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const &

        insert(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator pos, std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type n, std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const & x)

        Parameters
        ----------
        pos: std::vector< enum libm2k::M2K_TRIGGER_MODE >::iterator
        n: std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type
        x: std::vector< enum libm2k::M2K_TRIGGER_MODE >::value_type const &

        """
        return _libm2k.M2kModes_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(M2kModes self, std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type n)

        Parameters
        ----------
        n: std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type

        """
        return _libm2k.M2kModes_reserve(self, n)

    def capacity(self):
        r"""capacity(M2kModes self) -> std::vector< enum libm2k::M2K_TRIGGER_MODE >::size_type"""
        return _libm2k.M2kModes_capacity(self)
    __swig_destroy__ = _libm2k.delete_M2kModes

# Register M2kModes in _libm2k:
_libm2k.M2kModes_swigregister(M2kModes)

class IioBuffers(object):
    r"""Proxy of C++ std::vector< struct iio_buffer * > class."""

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

    def iterator(self):
        r"""iterator(IioBuffers self) -> SwigPyIterator"""
        return _libm2k.IioBuffers_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(IioBuffers self) -> bool"""
        return _libm2k.IioBuffers___nonzero__(self)

    def __bool__(self):
        r"""__bool__(IioBuffers self) -> bool"""
        return _libm2k.IioBuffers___bool__(self)

    def __len__(self):
        r"""__len__(IioBuffers self) -> std::vector< struct iio_buffer * >::size_type"""
        return _libm2k.IioBuffers___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(IioBuffers self, std::vector< struct iio_buffer * >::difference_type i, std::vector< struct iio_buffer * >::difference_type j) -> std::vector< iio_buffer *,std::allocator< iio_buffer * > > *

        Parameters
        ----------
        i: std::vector< struct iio_buffer * >::difference_type
        j: std::vector< struct iio_buffer * >::difference_type

        """
        return _libm2k.IioBuffers___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(IioBuffers self, std::vector< struct iio_buffer * >::difference_type i, std::vector< struct iio_buffer * >::difference_type j)

        Parameters
        ----------
        i: std::vector< struct iio_buffer * >::difference_type
        j: std::vector< struct iio_buffer * >::difference_type

        __setslice__(IioBuffers self, std::vector< struct iio_buffer * >::difference_type i, std::vector< struct iio_buffer * >::difference_type j, std::vector< iio_buffer *,std::allocator< iio_buffer * > > const & v)

        Parameters
        ----------
        i: std::vector< struct iio_buffer * >::difference_type
        j: std::vector< struct iio_buffer * >::difference_type
        v: std::vector< iio_buffer *,std::allocator< iio_buffer * > > const &

        """
        return _libm2k.IioBuffers___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(IioBuffers self, std::vector< struct iio_buffer * >::difference_type i, std::vector< struct iio_buffer * >::difference_type j)

        Parameters
        ----------
        i: std::vector< struct iio_buffer * >::difference_type
        j: std::vector< struct iio_buffer * >::difference_type

        """
        return _libm2k.IioBuffers___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(IioBuffers self, std::vector< struct iio_buffer * >::difference_type i)

        Parameters
        ----------
        i: std::vector< struct iio_buffer * >::difference_type

        __delitem__(IioBuffers self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.IioBuffers___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(IioBuffers self, PySliceObject * slice) -> std::vector< iio_buffer *,std::allocator< iio_buffer * > >

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(IioBuffers self, std::vector< struct iio_buffer * >::difference_type i) -> std::vector< struct iio_buffer * >::value_type

        Parameters
        ----------
        i: std::vector< struct iio_buffer * >::difference_type

        """
        return _libm2k.IioBuffers___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(IioBuffers self, PySliceObject * slice, std::vector< iio_buffer *,std::allocator< iio_buffer * > > const & v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< iio_buffer *,std::allocator< iio_buffer * > > const &

        __setitem__(IioBuffers self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(IioBuffers self, std::vector< struct iio_buffer * >::difference_type i, std::vector< struct iio_buffer * >::value_type x)

        Parameters
        ----------
        i: std::vector< struct iio_buffer * >::difference_type
        x: std::vector< struct iio_buffer * >::value_type

        """
        return _libm2k.IioBuffers___setitem__(self, *args)

    def pop(self):
        r"""pop(IioBuffers self) -> std::vector< struct iio_buffer * >::value_type"""
        return _libm2k.IioBuffers_pop(self)

    def append(self, x):
        r"""
        append(IioBuffers self, std::vector< struct iio_buffer * >::value_type x)

        Parameters
        ----------
        x: std::vector< struct iio_buffer * >::value_type

        """
        return _libm2k.IioBuffers_append(self, x)

    def empty(self):
        r"""empty(IioBuffers self) -> bool"""
        return _libm2k.IioBuffers_empty(self)

    def size(self):
        r"""size(IioBuffers self) -> std::vector< struct iio_buffer * >::size_type"""
        return _libm2k.IioBuffers_size(self)

    def swap(self, v):
        r"""
        swap(IioBuffers self, std::vector< iio_buffer * > & v)

        Parameters
        ----------
        v: std::vector< iio_buffer * > &

        """
        return _libm2k.IioBuffers_swap(self, v)

    def begin(self):
        r"""begin(IioBuffers self) -> std::vector< struct iio_buffer * >::iterator"""
        return _libm2k.IioBuffers_begin(self)

    def end(self):
        r"""end(IioBuffers self) -> std::vector< struct iio_buffer * >::iterator"""
        return _libm2k.IioBuffers_end(self)

    def rbegin(self):
        r"""rbegin(IioBuffers self) -> std::vector< struct iio_buffer * >::reverse_iterator"""
        return _libm2k.IioBuffers_rbegin(self)

    def rend(self):
        r"""rend(IioBuffers self) -> std::vector< struct iio_buffer * >::reverse_iterator"""
        return _libm2k.IioBuffers_rend(self)

    def clear(self):
        r"""clear(IioBuffers self)"""
        return _libm2k.IioBuffers_clear(self)

    def get_allocator(self):
        r"""get_allocator(IioBuffers self) -> std::vector< struct iio_buffer * >::allocator_type"""
        return _libm2k.IioBuffers_get_allocator(self)

    def pop_back(self):
        r"""pop_back(IioBuffers self)"""
        return _libm2k.IioBuffers_pop_back(self)

    def erase(self, *args):
        r"""
        erase(IioBuffers self, std::vector< struct iio_buffer * >::iterator pos) -> std::vector< struct iio_buffer * >::iterator

        Parameters
        ----------
        pos: std::vector< struct iio_buffer * >::iterator

        erase(IioBuffers self, std::vector< struct iio_buffer * >::iterator first, std::vector< struct iio_buffer * >::iterator last) -> std::vector< struct iio_buffer * >::iterator

        Parameters
        ----------
        first: std::vector< struct iio_buffer * >::iterator
        last: std::vector< struct iio_buffer * >::iterator

        """
        return _libm2k.IioBuffers_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(IioBuffers self) -> IioBuffers
        __init__(IioBuffers self, std::vector< iio_buffer * > const & other) -> IioBuffers

        Parameters
        ----------
        other: std::vector< iio_buffer * > const &

        __init__(IioBuffers self, std::vector< struct iio_buffer * >::size_type size) -> IioBuffers

        Parameters
        ----------
        size: std::vector< struct iio_buffer * >::size_type

        __init__(IioBuffers self, std::vector< struct iio_buffer * >::size_type size, std::vector< struct iio_buffer * >::value_type value) -> IioBuffers

        Parameters
        ----------
        size: std::vector< struct iio_buffer * >::size_type
        value: std::vector< struct iio_buffer * >::value_type

        """
        _libm2k.IioBuffers_swiginit(self, _libm2k.new_IioBuffers(*args))

    def push_back(self, x):
        r"""
        push_back(IioBuffers self, std::vector< struct iio_buffer * >::value_type x)

        Parameters
        ----------
        x: std::vector< struct iio_buffer * >::value_type

        """
        return _libm2k.IioBuffers_push_back(self, x)

    def front(self):
        r"""front(IioBuffers self) -> std::vector< struct iio_buffer * >::value_type"""
        return _libm2k.IioBuffers_front(self)

    def back(self):
        r"""back(IioBuffers self) -> std::vector< struct iio_buffer * >::value_type"""
        return _libm2k.IioBuffers_back(self)

    def assign(self, n, x):
        r"""
        assign(IioBuffers self, std::vector< struct iio_buffer * >::size_type n, std::vector< struct iio_buffer * >::value_type x)

        Parameters
        ----------
        n: std::vector< struct iio_buffer * >::size_type
        x: std::vector< struct iio_buffer * >::value_type

        """
        return _libm2k.IioBuffers_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(IioBuffers self, std::vector< struct iio_buffer * >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< struct iio_buffer * >::size_type

        resize(IioBuffers self, std::vector< struct iio_buffer * >::size_type new_size, std::vector< struct iio_buffer * >::value_type x)

        Parameters
        ----------
        new_size: std::vector< struct iio_buffer * >::size_type
        x: std::vector< struct iio_buffer * >::value_type

        """
        return _libm2k.IioBuffers_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(IioBuffers self, std::vector< struct iio_buffer * >::iterator pos, std::vector< struct iio_buffer * >::value_type x) -> std::vector< struct iio_buffer * >::iterator

        Parameters
        ----------
        pos: std::vector< struct iio_buffer * >::iterator
        x: std::vector< struct iio_buffer * >::value_type

        insert(IioBuffers self, std::vector< struct iio_buffer * >::iterator pos, std::vector< struct iio_buffer * >::size_type n, std::vector< struct iio_buffer * >::value_type x)

        Parameters
        ----------
        pos: std::vector< struct iio_buffer * >::iterator
        n: std::vector< struct iio_buffer * >::size_type
        x: std::vector< struct iio_buffer * >::value_type

        """
        return _libm2k.IioBuffers_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(IioBuffers self, std::vector< struct iio_buffer * >::size_type n)

        Parameters
        ----------
        n: std::vector< struct iio_buffer * >::size_type

        """
        return _libm2k.IioBuffers_reserve(self, n)

    def capacity(self):
        r"""capacity(IioBuffers self) -> std::vector< struct iio_buffer * >::size_type"""
        return _libm2k.IioBuffers_capacity(self)
    __swig_destroy__ = _libm2k.delete_IioBuffers

# Register IioBuffers in _libm2k:
_libm2k.IioBuffers_swigregister(IioBuffers)

class IioChannels(object):
    r"""Proxy of C++ std::vector< struct iio_channel * > class."""

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

    def iterator(self):
        r"""iterator(IioChannels self) -> SwigPyIterator"""
        return _libm2k.IioChannels_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(IioChannels self) -> bool"""
        return _libm2k.IioChannels___nonzero__(self)

    def __bool__(self):
        r"""__bool__(IioChannels self) -> bool"""
        return _libm2k.IioChannels___bool__(self)

    def __len__(self):
        r"""__len__(IioChannels self) -> std::vector< struct iio_channel * >::size_type"""
        return _libm2k.IioChannels___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(IioChannels self, std::vector< struct iio_channel * >::difference_type i, std::vector< struct iio_channel * >::difference_type j) -> std::vector< iio_channel *,std::allocator< iio_channel * > > *

        Parameters
        ----------
        i: std::vector< struct iio_channel * >::difference_type
        j: std::vector< struct iio_channel * >::difference_type

        """
        return _libm2k.IioChannels___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(IioChannels self, std::vector< struct iio_channel * >::difference_type i, std::vector< struct iio_channel * >::difference_type j)

        Parameters
        ----------
        i: std::vector< struct iio_channel * >::difference_type
        j: std::vector< struct iio_channel * >::difference_type

        __setslice__(IioChannels self, std::vector< struct iio_channel * >::difference_type i, std::vector< struct iio_channel * >::difference_type j, std::vector< iio_channel *,std::allocator< iio_channel * > > const & v)

        Parameters
        ----------
        i: std::vector< struct iio_channel * >::difference_type
        j: std::vector< struct iio_channel * >::difference_type
        v: std::vector< iio_channel *,std::allocator< iio_channel * > > const &

        """
        return _libm2k.IioChannels___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(IioChannels self, std::vector< struct iio_channel * >::difference_type i, std::vector< struct iio_channel * >::difference_type j)

        Parameters
        ----------
        i: std::vector< struct iio_channel * >::difference_type
        j: std::vector< struct iio_channel * >::difference_type

        """
        return _libm2k.IioChannels___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(IioChannels self, std::vector< struct iio_channel * >::difference_type i)

        Parameters
        ----------
        i: std::vector< struct iio_channel * >::difference_type

        __delitem__(IioChannels self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.IioChannels___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(IioChannels self, PySliceObject * slice) -> std::vector< iio_channel *,std::allocator< iio_channel * > >

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(IioChannels self, std::vector< struct iio_channel * >::difference_type i) -> std::vector< struct iio_channel * >::value_type

        Parameters
        ----------
        i: std::vector< struct iio_channel * >::difference_type

        """
        return _libm2k.IioChannels___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(IioChannels self, PySliceObject * slice, std::vector< iio_channel *,std::allocator< iio_channel * > > const & v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< iio_channel *,std::allocator< iio_channel * > > const &

        __setitem__(IioChannels self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(IioChannels self, std::vector< struct iio_channel * >::difference_type i, std::vector< struct iio_channel * >::value_type x)

        Parameters
        ----------
        i: std::vector< struct iio_channel * >::difference_type
        x: std::vector< struct iio_channel * >::value_type

        """
        return _libm2k.IioChannels___setitem__(self, *args)

    def pop(self):
        r"""pop(IioChannels self) -> std::vector< struct iio_channel * >::value_type"""
        return _libm2k.IioChannels_pop(self)

    def append(self, x):
        r"""
        append(IioChannels self, std::vector< struct iio_channel * >::value_type x)

        Parameters
        ----------
        x: std::vector< struct iio_channel * >::value_type

        """
        return _libm2k.IioChannels_append(self, x)

    def empty(self):
        r"""empty(IioChannels self) -> bool"""
        return _libm2k.IioChannels_empty(self)

    def size(self):
        r"""size(IioChannels self) -> std::vector< struct iio_channel * >::size_type"""
        return _libm2k.IioChannels_size(self)

    def swap(self, v):
        r"""
        swap(IioChannels self, std::vector< iio_channel * > & v)

        Parameters
        ----------
        v: std::vector< iio_channel * > &

        """
        return _libm2k.IioChannels_swap(self, v)

    def begin(self):
        r"""begin(IioChannels self) -> std::vector< struct iio_channel * >::iterator"""
        return _libm2k.IioChannels_begin(self)

    def end(self):
        r"""end(IioChannels self) -> std::vector< struct iio_channel * >::iterator"""
        return _libm2k.IioChannels_end(self)

    def rbegin(self):
        r"""rbegin(IioChannels self) -> std::vector< struct iio_channel * >::reverse_iterator"""
        return _libm2k.IioChannels_rbegin(self)

    def rend(self):
        r"""rend(IioChannels self) -> std::vector< struct iio_channel * >::reverse_iterator"""
        return _libm2k.IioChannels_rend(self)

    def clear(self):
        r"""clear(IioChannels self)"""
        return _libm2k.IioChannels_clear(self)

    def get_allocator(self):
        r"""get_allocator(IioChannels self) -> std::vector< struct iio_channel * >::allocator_type"""
        return _libm2k.IioChannels_get_allocator(self)

    def pop_back(self):
        r"""pop_back(IioChannels self)"""
        return _libm2k.IioChannels_pop_back(self)

    def erase(self, *args):
        r"""
        erase(IioChannels self, std::vector< struct iio_channel * >::iterator pos) -> std::vector< struct iio_channel * >::iterator

        Parameters
        ----------
        pos: std::vector< struct iio_channel * >::iterator

        erase(IioChannels self, std::vector< struct iio_channel * >::iterator first, std::vector< struct iio_channel * >::iterator last) -> std::vector< struct iio_channel * >::iterator

        Parameters
        ----------
        first: std::vector< struct iio_channel * >::iterator
        last: std::vector< struct iio_channel * >::iterator

        """
        return _libm2k.IioChannels_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(IioChannels self) -> IioChannels
        __init__(IioChannels self, std::vector< iio_channel * > const & other) -> IioChannels

        Parameters
        ----------
        other: std::vector< iio_channel * > const &

        __init__(IioChannels self, std::vector< struct iio_channel * >::size_type size) -> IioChannels

        Parameters
        ----------
        size: std::vector< struct iio_channel * >::size_type

        __init__(IioChannels self, std::vector< struct iio_channel * >::size_type size, std::vector< struct iio_channel * >::value_type value) -> IioChannels

        Parameters
        ----------
        size: std::vector< struct iio_channel * >::size_type
        value: std::vector< struct iio_channel * >::value_type

        """
        _libm2k.IioChannels_swiginit(self, _libm2k.new_IioChannels(*args))

    def push_back(self, x):
        r"""
        push_back(IioChannels self, std::vector< struct iio_channel * >::value_type x)

        Parameters
        ----------
        x: std::vector< struct iio_channel * >::value_type

        """
        return _libm2k.IioChannels_push_back(self, x)

    def front(self):
        r"""front(IioChannels self) -> std::vector< struct iio_channel * >::value_type"""
        return _libm2k.IioChannels_front(self)

    def back(self):
        r"""back(IioChannels self) -> std::vector< struct iio_channel * >::value_type"""
        return _libm2k.IioChannels_back(self)

    def assign(self, n, x):
        r"""
        assign(IioChannels self, std::vector< struct iio_channel * >::size_type n, std::vector< struct iio_channel * >::value_type x)

        Parameters
        ----------
        n: std::vector< struct iio_channel * >::size_type
        x: std::vector< struct iio_channel * >::value_type

        """
        return _libm2k.IioChannels_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(IioChannels self, std::vector< struct iio_channel * >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< struct iio_channel * >::size_type

        resize(IioChannels self, std::vector< struct iio_channel * >::size_type new_size, std::vector< struct iio_channel * >::value_type x)

        Parameters
        ----------
        new_size: std::vector< struct iio_channel * >::size_type
        x: std::vector< struct iio_channel * >::value_type

        """
        return _libm2k.IioChannels_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(IioChannels self, std::vector< struct iio_channel * >::iterator pos, std::vector< struct iio_channel * >::value_type x) -> std::vector< struct iio_channel * >::iterator

        Parameters
        ----------
        pos: std::vector< struct iio_channel * >::iterator
        x: std::vector< struct iio_channel * >::value_type

        insert(IioChannels self, std::vector< struct iio_channel * >::iterator pos, std::vector< struct iio_channel * >::size_type n, std::vector< struct iio_channel * >::value_type x)

        Parameters
        ----------
        pos: std::vector< struct iio_channel * >::iterator
        n: std::vector< struct iio_channel * >::size_type
        x: std::vector< struct iio_channel * >::value_type

        """
        return _libm2k.IioChannels_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(IioChannels self, std::vector< struct iio_channel * >::size_type n)

        Parameters
        ----------
        n: std::vector< struct iio_channel * >::size_type

        """
        return _libm2k.IioChannels_reserve(self, n)

    def capacity(self):
        r"""capacity(IioChannels self) -> std::vector< struct iio_channel * >::size_type"""
        return _libm2k.IioChannels_capacity(self)
    __swig_destroy__ = _libm2k.delete_IioChannels

# Register IioChannels in _libm2k:
_libm2k.IioChannels_swigregister(IioChannels)

class IioDevices(object):
    r"""Proxy of C++ std::vector< struct iio_device * > class."""

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

    def iterator(self):
        r"""iterator(IioDevices self) -> SwigPyIterator"""
        return _libm2k.IioDevices_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(IioDevices self) -> bool"""
        return _libm2k.IioDevices___nonzero__(self)

    def __bool__(self):
        r"""__bool__(IioDevices self) -> bool"""
        return _libm2k.IioDevices___bool__(self)

    def __len__(self):
        r"""__len__(IioDevices self) -> std::vector< struct iio_device * >::size_type"""
        return _libm2k.IioDevices___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(IioDevices self, std::vector< struct iio_device * >::difference_type i, std::vector< struct iio_device * >::difference_type j) -> std::vector< iio_device *,std::allocator< iio_device * > > *

        Parameters
        ----------
        i: std::vector< struct iio_device * >::difference_type
        j: std::vector< struct iio_device * >::difference_type

        """
        return _libm2k.IioDevices___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(IioDevices self, std::vector< struct iio_device * >::difference_type i, std::vector< struct iio_device * >::difference_type j)

        Parameters
        ----------
        i: std::vector< struct iio_device * >::difference_type
        j: std::vector< struct iio_device * >::difference_type

        __setslice__(IioDevices self, std::vector< struct iio_device * >::difference_type i, std::vector< struct iio_device * >::difference_type j, std::vector< iio_device *,std::allocator< iio_device * > > const & v)

        Parameters
        ----------
        i: std::vector< struct iio_device * >::difference_type
        j: std::vector< struct iio_device * >::difference_type
        v: std::vector< iio_device *,std::allocator< iio_device * > > const &

        """
        return _libm2k.IioDevices___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(IioDevices self, std::vector< struct iio_device * >::difference_type i, std::vector< struct iio_device * >::difference_type j)

        Parameters
        ----------
        i: std::vector< struct iio_device * >::difference_type
        j: std::vector< struct iio_device * >::difference_type

        """
        return _libm2k.IioDevices___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(IioDevices self, std::vector< struct iio_device * >::difference_type i)

        Parameters
        ----------
        i: std::vector< struct iio_device * >::difference_type

        __delitem__(IioDevices self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _libm2k.IioDevices___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(IioDevices self, PySliceObject * slice) -> std::vector< iio_device *,std::allocator< iio_device * > >

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(IioDevices self, std::vector< struct iio_device * >::difference_type i) -> std::vector< struct iio_device * >::value_type

        Parameters
        ----------
        i: std::vector< struct iio_device * >::difference_type

        """
        return _libm2k.IioDevices___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(IioDevices self, PySliceObject * slice, std::vector< iio_device *,std::allocator< iio_device * > > const & v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< iio_device *,std::allocator< iio_device * > > const &

        __setitem__(IioDevices self, PySliceObject * slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(IioDevices self, std::vector< struct iio_device * >::difference_type i, std::vector< struct iio_device * >::value_type x)

        Parameters
        ----------
        i: std::vector< struct iio_device * >::difference_type
        x: std::vector< struct iio_device * >::value_type

        """
        return _libm2k.IioDevices___setitem__(self, *args)

    def pop(self):
        r"""pop(IioDevices self) -> std::vector< struct iio_device * >::value_type"""
        return _libm2k.IioDevices_pop(self)

    def append(self, x):
        r"""
        append(IioDevices self, std::vector< struct iio_device * >::value_type x)

        Parameters
        ----------
        x: std::vector< struct iio_device * >::value_type

        """
        return _libm2k.IioDevices_append(self, x)

    def empty(self):
        r"""empty(IioDevices self) -> bool"""
        return _libm2k.IioDevices_empty(self)

    def size(self):
        r"""size(IioDevices self) -> std::vector< struct iio_device * >::size_type"""
        return _libm2k.IioDevices_size(self)

    def swap(self, v):
        r"""
        swap(IioDevices self, std::vector< iio_device * > & v)

        Parameters
        ----------
        v: std::vector< iio_device * > &

        """
        return _libm2k.IioDevices_swap(self, v)

    def begin(self):
        r"""begin(IioDevices self) -> std::vector< struct iio_device * >::iterator"""
        return _libm2k.IioDevices_begin(self)

    def end(self):
        r"""end(IioDevices self) -> std::vector< struct iio_device * >::iterator"""
        return _libm2k.IioDevices_end(self)

    def rbegin(self):
        r"""rbegin(IioDevices self) -> std::vector< struct iio_device * >::reverse_iterator"""
        return _libm2k.IioDevices_rbegin(self)

    def rend(self):
        r"""rend(IioDevices self) -> std::vector< struct iio_device * >::reverse_iterator"""
        return _libm2k.IioDevices_rend(self)

    def clear(self):
        r"""clear(IioDevices self)"""
        return _libm2k.IioDevices_clear(self)

    def get_allocator(self):
        r"""get_allocator(IioDevices self) -> std::vector< struct iio_device * >::allocator_type"""
        return _libm2k.IioDevices_get_allocator(self)

    def pop_back(self):
        r"""pop_back(IioDevices self)"""
        return _libm2k.IioDevices_pop_back(self)

    def erase(self, *args):
        r"""
        erase(IioDevices self, std::vector< struct iio_device * >::iterator pos) -> std::vector< struct iio_device * >::iterator

        Parameters
        ----------
        pos: std::vector< struct iio_device * >::iterator

        erase(IioDevices self, std::vector< struct iio_device * >::iterator first, std::vector< struct iio_device * >::iterator last) -> std::vector< struct iio_device * >::iterator

        Parameters
        ----------
        first: std::vector< struct iio_device * >::iterator
        last: std::vector< struct iio_device * >::iterator

        """
        return _libm2k.IioDevices_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(IioDevices self) -> IioDevices
        __init__(IioDevices self, std::vector< iio_device * > const & other) -> IioDevices

        Parameters
        ----------
        other: std::vector< iio_device * > const &

        __init__(IioDevices self, std::vector< struct iio_device * >::size_type size) -> IioDevices

        Parameters
        ----------
        size: std::vector< struct iio_device * >::size_type

        __init__(IioDevices self, std::vector< struct iio_device * >::size_type size, std::vector< struct iio_device * >::value_type value) -> IioDevices

        Parameters
        ----------
        size: std::vector< struct iio_device * >::size_type
        value: std::vector< struct iio_device * >::value_type

        """
        _libm2k.IioDevices_swiginit(self, _libm2k.new_IioDevices(*args))

    def push_back(self, x):
        r"""
        push_back(IioDevices self, std::vector< struct iio_device * >::value_type x)

        Parameters
        ----------
        x: std::vector< struct iio_device * >::value_type

        """
        return _libm2k.IioDevices_push_back(self, x)

    def front(self):
        r"""front(IioDevices self) -> std::vector< struct iio_device * >::value_type"""
        return _libm2k.IioDevices_front(self)

    def back(self):
        r"""back(IioDevices self) -> std::vector< struct iio_device * >::value_type"""
        return _libm2k.IioDevices_back(self)

    def assign(self, n, x):
        r"""
        assign(IioDevices self, std::vector< struct iio_device * >::size_type n, std::vector< struct iio_device * >::value_type x)

        Parameters
        ----------
        n: std::vector< struct iio_device * >::size_type
        x: std::vector< struct iio_device * >::value_type

        """
        return _libm2k.IioDevices_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(IioDevices self, std::vector< struct iio_device * >::size_type new_size)

        Parameters
        ----------
        new_size: std::vector< struct iio_device * >::size_type

        resize(IioDevices self, std::vector< struct iio_device * >::size_type new_size, std::vector< struct iio_device * >::value_type x)

        Parameters
        ----------
        new_size: std::vector< struct iio_device * >::size_type
        x: std::vector< struct iio_device * >::value_type

        """
        return _libm2k.IioDevices_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(IioDevices self, std::vector< struct iio_device * >::iterator pos, std::vector< struct iio_device * >::value_type x) -> std::vector< struct iio_device * >::iterator

        Parameters
        ----------
        pos: std::vector< struct iio_device * >::iterator
        x: std::vector< struct iio_device * >::value_type

        insert(IioDevices self, std::vector< struct iio_device * >::iterator pos, std::vector< struct iio_device * >::size_type n, std::vector< struct iio_device * >::value_type x)

        Parameters
        ----------
        pos: std::vector< struct iio_device * >::iterator
        n: std::vector< struct iio_device * >::size_type
        x: std::vector< struct iio_device * >::value_type

        """
        return _libm2k.IioDevices_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(IioDevices self, std::vector< struct iio_device * >::size_type n)

        Parameters
        ----------
        n: std::vector< struct iio_device * >::size_type

        """
        return _libm2k.IioDevices_reserve(self, n)

    def capacity(self):
        r"""capacity(IioDevices self) -> std::vector< struct iio_device * >::size_type"""
        return _libm2k.IioDevices_capacity(self)
    __swig_destroy__ = _libm2k.delete_IioDevices

# Register IioDevices in _libm2k:
_libm2k.IioDevices_swigregister(IioDevices)



