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

"""Easy SDIF wrapper module for reading/writing SDIF files"""

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if getattr(globals().get("__spec__"), "parent", None) or globals().get("__package__") or "." in __name__:
    from . import _eaSDIF
else:
    import _eaSDIF

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 == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(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__)


HAVE_NUMPY = _eaSDIF.HAVE_NUMPY
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__ = _eaSDIF.delete_SwigPyIterator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def CreateSignature(p1, p2, p3, p4):
    return _eaSDIF.CreateSignature(p1, p2, p3, p4)
class Vector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _eaSDIF.Vector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _eaSDIF.Vector___nonzero__(self)

    def __bool__(self):
        return _eaSDIF.Vector___bool__(self)

    def __len__(self):
        return _eaSDIF.Vector___len__(self)

    def __getslice__(self, i, j):
        return _eaSDIF.Vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _eaSDIF.Vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _eaSDIF.Vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _eaSDIF.Vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _eaSDIF.Vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _eaSDIF.Vector___setitem__(self, *args)

    def pop(self):
        return _eaSDIF.Vector_pop(self)

    def append(self, x):
        return _eaSDIF.Vector_append(self, x)

    def empty(self):
        return _eaSDIF.Vector_empty(self)

    def size(self):
        return _eaSDIF.Vector_size(self)

    def swap(self, v):
        return _eaSDIF.Vector_swap(self, v)

    def begin(self):
        return _eaSDIF.Vector_begin(self)

    def end(self):
        return _eaSDIF.Vector_end(self)

    def rbegin(self):
        return _eaSDIF.Vector_rbegin(self)

    def rend(self):
        return _eaSDIF.Vector_rend(self)

    def clear(self):
        return _eaSDIF.Vector_clear(self)

    def get_allocator(self):
        return _eaSDIF.Vector_get_allocator(self)

    def pop_back(self):
        return _eaSDIF.Vector_pop_back(self)

    def erase(self, *args):
        return _eaSDIF.Vector_erase(self, *args)

    def __init__(self, *args):
        _eaSDIF.Vector_swiginit(self, _eaSDIF.new_Vector(*args))

    def push_back(self, x):
        return _eaSDIF.Vector_push_back(self, x)

    def front(self):
        return _eaSDIF.Vector_front(self)

    def back(self):
        return _eaSDIF.Vector_back(self)

    def assign(self, n, x):
        return _eaSDIF.Vector_assign(self, n, x)

    def resize(self, *args):
        return _eaSDIF.Vector_resize(self, *args)

    def insert(self, *args):
        return _eaSDIF.Vector_insert(self, *args)

    def reserve(self, n):
        return _eaSDIF.Vector_reserve(self, n)

    def capacity(self):
        return _eaSDIF.Vector_capacity(self)
    __swig_destroy__ = _eaSDIF.delete_Vector

# Register Vector in _eaSDIF:
_eaSDIF.Vector_swigregister(Vector)
class FVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _eaSDIF.FVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _eaSDIF.FVector___nonzero__(self)

    def __bool__(self):
        return _eaSDIF.FVector___bool__(self)

    def __len__(self):
        return _eaSDIF.FVector___len__(self)

    def __getslice__(self, i, j):
        return _eaSDIF.FVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _eaSDIF.FVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _eaSDIF.FVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _eaSDIF.FVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _eaSDIF.FVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _eaSDIF.FVector___setitem__(self, *args)

    def pop(self):
        return _eaSDIF.FVector_pop(self)

    def append(self, x):
        return _eaSDIF.FVector_append(self, x)

    def empty(self):
        return _eaSDIF.FVector_empty(self)

    def size(self):
        return _eaSDIF.FVector_size(self)

    def swap(self, v):
        return _eaSDIF.FVector_swap(self, v)

    def begin(self):
        return _eaSDIF.FVector_begin(self)

    def end(self):
        return _eaSDIF.FVector_end(self)

    def rbegin(self):
        return _eaSDIF.FVector_rbegin(self)

    def rend(self):
        return _eaSDIF.FVector_rend(self)

    def clear(self):
        return _eaSDIF.FVector_clear(self)

    def get_allocator(self):
        return _eaSDIF.FVector_get_allocator(self)

    def pop_back(self):
        return _eaSDIF.FVector_pop_back(self)

    def erase(self, *args):
        return _eaSDIF.FVector_erase(self, *args)

    def __init__(self, *args):
        _eaSDIF.FVector_swiginit(self, _eaSDIF.new_FVector(*args))

    def push_back(self, x):
        return _eaSDIF.FVector_push_back(self, x)

    def front(self):
        return _eaSDIF.FVector_front(self)

    def back(self):
        return _eaSDIF.FVector_back(self)

    def assign(self, n, x):
        return _eaSDIF.FVector_assign(self, n, x)

    def resize(self, *args):
        return _eaSDIF.FVector_resize(self, *args)

    def insert(self, *args):
        return _eaSDIF.FVector_insert(self, *args)

    def reserve(self, n):
        return _eaSDIF.FVector_reserve(self, n)

    def capacity(self):
        return _eaSDIF.FVector_capacity(self)
    __swig_destroy__ = _eaSDIF.delete_FVector

# Register FVector in _eaSDIF:
_eaSDIF.FVector_swigregister(FVector)
class IVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _eaSDIF.IVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _eaSDIF.IVector___nonzero__(self)

    def __bool__(self):
        return _eaSDIF.IVector___bool__(self)

    def __len__(self):
        return _eaSDIF.IVector___len__(self)

    def __getslice__(self, i, j):
        return _eaSDIF.IVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _eaSDIF.IVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _eaSDIF.IVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _eaSDIF.IVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _eaSDIF.IVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _eaSDIF.IVector___setitem__(self, *args)

    def pop(self):
        return _eaSDIF.IVector_pop(self)

    def append(self, x):
        return _eaSDIF.IVector_append(self, x)

    def empty(self):
        return _eaSDIF.IVector_empty(self)

    def size(self):
        return _eaSDIF.IVector_size(self)

    def swap(self, v):
        return _eaSDIF.IVector_swap(self, v)

    def begin(self):
        return _eaSDIF.IVector_begin(self)

    def end(self):
        return _eaSDIF.IVector_end(self)

    def rbegin(self):
        return _eaSDIF.IVector_rbegin(self)

    def rend(self):
        return _eaSDIF.IVector_rend(self)

    def clear(self):
        return _eaSDIF.IVector_clear(self)

    def get_allocator(self):
        return _eaSDIF.IVector_get_allocator(self)

    def pop_back(self):
        return _eaSDIF.IVector_pop_back(self)

    def erase(self, *args):
        return _eaSDIF.IVector_erase(self, *args)

    def __init__(self, *args):
        _eaSDIF.IVector_swiginit(self, _eaSDIF.new_IVector(*args))

    def push_back(self, x):
        return _eaSDIF.IVector_push_back(self, x)

    def front(self):
        return _eaSDIF.IVector_front(self)

    def back(self):
        return _eaSDIF.IVector_back(self)

    def assign(self, n, x):
        return _eaSDIF.IVector_assign(self, n, x)

    def resize(self, *args):
        return _eaSDIF.IVector_resize(self, *args)

    def insert(self, *args):
        return _eaSDIF.IVector_insert(self, *args)

    def reserve(self, n):
        return _eaSDIF.IVector_reserve(self, n)

    def capacity(self):
        return _eaSDIF.IVector_capacity(self)
    __swig_destroy__ = _eaSDIF.delete_IVector

# Register IVector in _eaSDIF:
_eaSDIF.IVector_swigregister(IVector)
class Selection(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _eaSDIF.Selection_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _eaSDIF.Selection___nonzero__(self)

    def __bool__(self):
        return _eaSDIF.Selection___bool__(self)

    def __len__(self):
        return _eaSDIF.Selection___len__(self)

    def __getslice__(self, i, j):
        return _eaSDIF.Selection___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _eaSDIF.Selection___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _eaSDIF.Selection___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _eaSDIF.Selection___delitem__(self, *args)

    def __getitem__(self, *args):
        return _eaSDIF.Selection___getitem__(self, *args)

    def __setitem__(self, *args):
        return _eaSDIF.Selection___setitem__(self, *args)

    def pop(self):
        return _eaSDIF.Selection_pop(self)

    def append(self, x):
        return _eaSDIF.Selection_append(self, x)

    def empty(self):
        return _eaSDIF.Selection_empty(self)

    def size(self):
        return _eaSDIF.Selection_size(self)

    def swap(self, v):
        return _eaSDIF.Selection_swap(self, v)

    def begin(self):
        return _eaSDIF.Selection_begin(self)

    def end(self):
        return _eaSDIF.Selection_end(self)

    def rbegin(self):
        return _eaSDIF.Selection_rbegin(self)

    def rend(self):
        return _eaSDIF.Selection_rend(self)

    def clear(self):
        return _eaSDIF.Selection_clear(self)

    def get_allocator(self):
        return _eaSDIF.Selection_get_allocator(self)

    def pop_back(self):
        return _eaSDIF.Selection_pop_back(self)

    def erase(self, *args):
        return _eaSDIF.Selection_erase(self, *args)

    def __init__(self, *args):
        _eaSDIF.Selection_swiginit(self, _eaSDIF.new_Selection(*args))

    def push_back(self, x):
        return _eaSDIF.Selection_push_back(self, x)

    def front(self):
        return _eaSDIF.Selection_front(self)

    def back(self):
        return _eaSDIF.Selection_back(self)

    def assign(self, n, x):
        return _eaSDIF.Selection_assign(self, n, x)

    def resize(self, *args):
        return _eaSDIF.Selection_resize(self, *args)

    def insert(self, *args):
        return _eaSDIF.Selection_insert(self, *args)

    def reserve(self, n):
        return _eaSDIF.Selection_reserve(self, n)

    def capacity(self):
        return _eaSDIF.Selection_capacity(self)
    __swig_destroy__ = _eaSDIF.delete_Selection

# Register Selection in _eaSDIF:
_eaSDIF.Selection_swigregister(Selection)
eText = _eaSDIF.eText

eChar = _eaSDIF.eChar

eFloat4 = _eaSDIF.eFloat4

eFloat8 = _eaSDIF.eFloat8

eInt1 = _eaSDIF.eInt1

eInt2 = _eaSDIF.eInt2

eInt4 = _eaSDIF.eInt4

eInt8 = _eaSDIF.eInt8

eUInt1 = _eaSDIF.eUInt1

eUInt2 = _eaSDIF.eUInt2

eUInt4 = _eaSDIF.eUInt4

eUInt8 = _eaSDIF.eUInt8

eFloat4a = _eaSDIF.eFloat4a

eFloat4b = _eaSDIF.eFloat4b

eFloat8a = _eaSDIF.eFloat8a

eFloat8b = _eaSDIF.eFloat8b

eUnknownFileMode = _eaSDIF.eUnknownFileMode

eWriteFile = _eaSDIF.eWriteFile

eReadFile = _eaSDIF.eReadFile

ePredefinedTypes = _eaSDIF.ePredefinedTypes

class stringmap(object):
    r"""Proxy of C++ std::map< std::string,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(stringmap self) -> SwigPyIterator"""
        return _eaSDIF.stringmap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(stringmap self) -> bool"""
        return _eaSDIF.stringmap___nonzero__(self)

    def __bool__(self):
        r"""__bool__(stringmap self) -> bool"""
        return _eaSDIF.stringmap___bool__(self)

    def __len__(self):
        r"""__len__(stringmap self) -> std::map< std::string,std::string >::size_type"""
        return _eaSDIF.stringmap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        r"""__getitem__(stringmap self, std::map< std::string,std::string >::key_type const & key) -> std::map< std::string,std::string >::mapped_type const &"""
        return _eaSDIF.stringmap___getitem__(self, key)

    def __delitem__(self, key):
        r"""__delitem__(stringmap self, std::map< std::string,std::string >::key_type const & key)"""
        return _eaSDIF.stringmap___delitem__(self, key)

    def has_key(self, key):
        r"""has_key(stringmap self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _eaSDIF.stringmap_has_key(self, key)

    def keys(self):
        r"""keys(stringmap self) -> PyObject *"""
        return _eaSDIF.stringmap_keys(self)

    def values(self):
        r"""values(stringmap self) -> PyObject *"""
        return _eaSDIF.stringmap_values(self)

    def items(self):
        r"""items(stringmap self) -> PyObject *"""
        return _eaSDIF.stringmap_items(self)

    def __contains__(self, key):
        r"""__contains__(stringmap self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _eaSDIF.stringmap___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(stringmap self) -> SwigPyIterator"""
        return _eaSDIF.stringmap_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(stringmap self) -> SwigPyIterator"""
        return _eaSDIF.stringmap_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(stringmap self, std::map< std::string,std::string >::key_type const & key)
        __setitem__(stringmap self, std::map< std::string,std::string >::key_type const & key, std::map< std::string,std::string >::mapped_type const & x)
        """
        return _eaSDIF.stringmap___setitem__(self, *args)

    def asdict(self):
        r"""asdict(stringmap self) -> PyObject *"""
        return _eaSDIF.stringmap_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(stringmap self, std::less< std::string > const & other) -> stringmap
        __init__(stringmap self) -> stringmap
        __init__(stringmap self, stringmap other) -> stringmap
        """
        _eaSDIF.stringmap_swiginit(self, _eaSDIF.new_stringmap(*args))

    def empty(self):
        r"""empty(stringmap self) -> bool"""
        return _eaSDIF.stringmap_empty(self)

    def size(self):
        r"""size(stringmap self) -> std::map< std::string,std::string >::size_type"""
        return _eaSDIF.stringmap_size(self)

    def swap(self, v):
        r"""swap(stringmap self, stringmap v)"""
        return _eaSDIF.stringmap_swap(self, v)

    def begin(self):
        r"""begin(stringmap self) -> std::map< std::string,std::string >::iterator"""
        return _eaSDIF.stringmap_begin(self)

    def end(self):
        r"""end(stringmap self) -> std::map< std::string,std::string >::iterator"""
        return _eaSDIF.stringmap_end(self)

    def rbegin(self):
        r"""rbegin(stringmap self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _eaSDIF.stringmap_rbegin(self)

    def rend(self):
        r"""rend(stringmap self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _eaSDIF.stringmap_rend(self)

    def clear(self):
        r"""clear(stringmap self)"""
        return _eaSDIF.stringmap_clear(self)

    def get_allocator(self):
        r"""get_allocator(stringmap self) -> std::map< std::string,std::string >::allocator_type"""
        return _eaSDIF.stringmap_get_allocator(self)

    def count(self, x):
        r"""count(stringmap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type"""
        return _eaSDIF.stringmap_count(self, x)

    def erase(self, *args):
        r"""
        erase(stringmap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type
        erase(stringmap self, std::map< std::string,std::string >::iterator position)
        erase(stringmap self, std::map< std::string,std::string >::iterator first, std::map< std::string,std::string >::iterator last)
        """
        return _eaSDIF.stringmap_erase(self, *args)

    def find(self, x):
        r"""find(stringmap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _eaSDIF.stringmap_find(self, x)

    def lower_bound(self, x):
        r"""lower_bound(stringmap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _eaSDIF.stringmap_lower_bound(self, x)

    def upper_bound(self, x):
        r"""upper_bound(stringmap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _eaSDIF.stringmap_upper_bound(self, x)
    __swig_destroy__ = _eaSDIF.delete_stringmap

# Register stringmap in _eaSDIF:
_eaSDIF.stringmap_swigregister(stringmap)
class Directory(object):
    r"""Proxy of C++ std::list< Easdif::SDIFLocation > 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(Directory self) -> SwigPyIterator"""
        return _eaSDIF.Directory_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(Directory self) -> bool"""
        return _eaSDIF.Directory___nonzero__(self)

    def __bool__(self):
        r"""__bool__(Directory self) -> bool"""
        return _eaSDIF.Directory___bool__(self)

    def __len__(self):
        r"""__len__(Directory self) -> std::list< Easdif::SDIFLocation >::size_type"""
        return _eaSDIF.Directory___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(Directory self, std::list< Easdif::SDIFLocation >::difference_type i, std::list< Easdif::SDIFLocation >::difference_type j) -> Directory"""
        return _eaSDIF.Directory___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(Directory self, std::list< Easdif::SDIFLocation >::difference_type i, std::list< Easdif::SDIFLocation >::difference_type j)
        __setslice__(Directory self, std::list< Easdif::SDIFLocation >::difference_type i, std::list< Easdif::SDIFLocation >::difference_type j, Directory v)
        """
        return _eaSDIF.Directory___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(Directory self, std::list< Easdif::SDIFLocation >::difference_type i, std::list< Easdif::SDIFLocation >::difference_type j)"""
        return _eaSDIF.Directory___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(Directory self, std::list< Easdif::SDIFLocation >::difference_type i)
        __delitem__(Directory self, SWIGPY_SLICEOBJECT * slice)
        """
        return _eaSDIF.Directory___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(Directory self, SWIGPY_SLICEOBJECT * slice) -> Directory
        __getitem__(Directory self, std::list< Easdif::SDIFLocation >::difference_type i) -> SDIFLocation
        """
        return _eaSDIF.Directory___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(Directory self, SWIGPY_SLICEOBJECT * slice, Directory v)
        __setitem__(Directory self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(Directory self, std::list< Easdif::SDIFLocation >::difference_type i, SDIFLocation x)
        """
        return _eaSDIF.Directory___setitem__(self, *args)

    def pop(self):
        r"""pop(Directory self) -> SDIFLocation"""
        return _eaSDIF.Directory_pop(self)

    def append(self, x):
        r"""append(Directory self, SDIFLocation x)"""
        return _eaSDIF.Directory_append(self, x)

    def empty(self):
        r"""empty(Directory self) -> bool"""
        return _eaSDIF.Directory_empty(self)

    def size(self):
        r"""size(Directory self) -> std::list< Easdif::SDIFLocation >::size_type"""
        return _eaSDIF.Directory_size(self)

    def swap(self, v):
        r"""swap(Directory self, Directory v)"""
        return _eaSDIF.Directory_swap(self, v)

    def begin(self):
        r"""begin(Directory self) -> std::list< Easdif::SDIFLocation >::iterator"""
        return _eaSDIF.Directory_begin(self)

    def end(self):
        r"""end(Directory self) -> std::list< Easdif::SDIFLocation >::iterator"""
        return _eaSDIF.Directory_end(self)

    def rbegin(self):
        r"""rbegin(Directory self) -> std::list< Easdif::SDIFLocation >::reverse_iterator"""
        return _eaSDIF.Directory_rbegin(self)

    def rend(self):
        r"""rend(Directory self) -> std::list< Easdif::SDIFLocation >::reverse_iterator"""
        return _eaSDIF.Directory_rend(self)

    def clear(self):
        r"""clear(Directory self)"""
        return _eaSDIF.Directory_clear(self)

    def get_allocator(self):
        r"""get_allocator(Directory self) -> std::list< Easdif::SDIFLocation >::allocator_type"""
        return _eaSDIF.Directory_get_allocator(self)

    def pop_back(self):
        r"""pop_back(Directory self)"""
        return _eaSDIF.Directory_pop_back(self)

    def erase(self, *args):
        r"""
        erase(Directory self, std::list< Easdif::SDIFLocation >::iterator pos) -> std::list< Easdif::SDIFLocation >::iterator
        erase(Directory self, std::list< Easdif::SDIFLocation >::iterator first, std::list< Easdif::SDIFLocation >::iterator last) -> std::list< Easdif::SDIFLocation >::iterator
        """
        return _eaSDIF.Directory_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(Directory self) -> Directory
        __init__(Directory self, Directory other) -> Directory
        __init__(Directory self, std::list< Easdif::SDIFLocation >::size_type size) -> Directory
        __init__(Directory self, std::list< Easdif::SDIFLocation >::size_type size, SDIFLocation value) -> Directory
        """
        _eaSDIF.Directory_swiginit(self, _eaSDIF.new_Directory(*args))

    def push_back(self, x):
        r"""push_back(Directory self, SDIFLocation x)"""
        return _eaSDIF.Directory_push_back(self, x)

    def front(self):
        r"""front(Directory self) -> SDIFLocation"""
        return _eaSDIF.Directory_front(self)

    def back(self):
        r"""back(Directory self) -> SDIFLocation"""
        return _eaSDIF.Directory_back(self)

    def assign(self, n, x):
        r"""assign(Directory self, std::list< Easdif::SDIFLocation >::size_type n, SDIFLocation x)"""
        return _eaSDIF.Directory_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(Directory self, std::list< Easdif::SDIFLocation >::size_type new_size)
        resize(Directory self, std::list< Easdif::SDIFLocation >::size_type new_size, SDIFLocation x)
        """
        return _eaSDIF.Directory_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(Directory self, std::list< Easdif::SDIFLocation >::iterator pos, SDIFLocation x) -> std::list< Easdif::SDIFLocation >::iterator
        insert(Directory self, std::list< Easdif::SDIFLocation >::iterator pos, std::list< Easdif::SDIFLocation >::size_type n, SDIFLocation x)
        """
        return _eaSDIF.Directory_insert(self, *args)

    def pop_front(self):
        r"""pop_front(Directory self)"""
        return _eaSDIF.Directory_pop_front(self)

    def push_front(self, x):
        r"""push_front(Directory self, SDIFLocation x)"""
        return _eaSDIF.Directory_push_front(self, x)

    def reverse(self):
        r"""reverse(Directory self)"""
        return _eaSDIF.Directory_reverse(self)
    __swig_destroy__ = _eaSDIF.delete_Directory

# Register Directory in _eaSDIF:
_eaSDIF.Directory_swigregister(Directory)
SDIFMATRIX_H_ = _eaSDIF.SDIFMATRIX_H_

class Matrix(object):
    r"""Proxy of C++ Easdif::SDIFMatrix 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"""
        SDIFMatrix(SdifDataTypeET const _type=eFloat4) -> Matrix
        SDIFMatrix(Matrix aMatrix) -> Matrix
        SDIFMatrix(std::string const & sig, int nrows=1, int ncols=1, SdifDataTypeET type=eFloat4) -> Matrix
        """
        _eaSDIF.Matrix_swiginit(self, _eaSDIF.new_Matrix(*args))
    __swig_destroy__ = _eaSDIF.delete_Matrix

    def Print(self):
        r"""Print(Matrix self)"""
        return _eaSDIF.Matrix_Print(self)

    def Write(self, file):
        r"""Write(Matrix self, SdifFileT * file) -> int"""
        return _eaSDIF.Matrix_Write(self, file)

    def Read(self, file, hlsel=None):
        r"""Read(Matrix self, SdifFileT * file, ISet hlsel=None) -> int"""
        return _eaSDIF.Matrix_Read(self, file, hlsel)

    def Init(self, *args):
        r"""
        Init(Matrix self, SdifSignature sig, int nrows, int ncols, SdifDataTypeET type)
        Init(Matrix self, std::string const & sig, int nrows, int ncols, SdifDataTypeET type)
        """
        return _eaSDIF.Matrix_Init(self, *args)

    def Resize(self, nrows, ncols):
        r"""Resize(Matrix self, int nrows, int ncols) -> bool"""
        return _eaSDIF.Matrix_Resize(self, nrows, ncols)

    def Clear(self):
        r"""Clear(Matrix self) -> bool"""
        return _eaSDIF.Matrix_Clear(self)

    def GetSize(self):
        r"""GetSize(Matrix self) -> int"""
        return _eaSDIF.Matrix_GetSize(self)

    def GetNbRows(self):
        r"""GetNbRows(Matrix self) -> int"""
        return _eaSDIF.Matrix_GetNbRows(self)

    def GetNbCols(self):
        r"""GetNbCols(Matrix self) -> int"""
        return _eaSDIF.Matrix_GetNbCols(self)

    def GetSignature(self):
        r"""GetSignature(Matrix self) -> SdifSignature"""
        return _eaSDIF.Matrix_GetSignature(self)

    def GetStringSignature(self):
        r"""GetStringSignature(Matrix self) -> std::string"""
        return _eaSDIF.Matrix_GetStringSignature(self)

    def GetType(self):
        r"""GetType(Matrix self) -> SdifDataTypeET"""
        return _eaSDIF.Matrix_GetType(self)

    def GetColName(self, i):
        r"""GetColName(Matrix self, int i) -> std::string"""
        return _eaSDIF.Matrix_GetColName(self, i)

    def GetElementSize(self):
        r"""GetElementSize(Matrix self) -> int"""
        return _eaSDIF.Matrix_GetElementSize(self)

    def SetSignature(self, *args):
        r"""
        SetSignature(Matrix self, SdifSignature sig)
        SetSignature(Matrix self, std::string const & signature)
        """
        return _eaSDIF.Matrix_SetSignature(self, *args)

    def GetUChar(self, i, j):
        r"""GetUChar(Matrix self, int i, int j) -> int"""
        return _eaSDIF.Matrix_GetUChar(self, i, j)

    def GetInt(self, i, j):
        r"""GetInt(Matrix self, int i, int j) -> int"""
        return _eaSDIF.Matrix_GetInt(self, i, j)

    def GetFloat(self, i, j):
        r"""GetFloat(Matrix self, int i, int j) -> float"""
        return _eaSDIF.Matrix_GetFloat(self, i, j)

    def GetDouble(self, i, j):
        r"""GetDouble(Matrix self, int i, int j) -> double"""
        return _eaSDIF.Matrix_GetDouble(self, i, j)

    def Get(self, *args):
        r"""
        Get(Matrix self, int i, int j, float & value)
        Get(Matrix self, int i, int j, int & value)
        Get(Matrix self, std::string & value)
        """
        return _eaSDIF.Matrix_Get(self, *args)

    def Set(self, *args):
        r"""
        Set(Matrix self, int i, int j, float const value)
        Set(Matrix self, int i, int j, int const value)
        Set(Matrix self, int i, int j, unsigned char const value)
        Set(Matrix self, std::string const & str)
        """
        return _eaSDIF.Matrix_Set(self, *args)

    def GetRow(self, *args):
        r"""
        GetRow(Matrix self, double * out, int irow)
        GetRow(Matrix self, Vector out, int irow)
        GetRow(Matrix self, float * out, int irow)
        GetRow(Matrix self, FVector out, int irow)
        GetRow(Matrix self, char * out, int irow)
        GetRow(Matrix self, std::vector< char,std::allocator< char > > & out, int irow)
        GetRow(Matrix self, short * out, int irow)
        GetRow(Matrix self, std::vector< short,std::allocator< short > > & out, int irow)
        GetRow(Matrix self, int * out, int irow)
        GetRow(Matrix self, IVector out, int irow)
        GetRow(Matrix self, unsigned char * out, int irow)
        GetRow(Matrix self, std::vector< unsigned char,std::allocator< unsigned char > > & out, int irow)
        GetRow(Matrix self, unsigned short * out, int irow)
        GetRow(Matrix self, std::vector< unsigned short,std::allocator< unsigned short > > & out, int irow)
        GetRow(Matrix self, unsigned int * out, int irow)
        GetRow(Matrix self, Selection out, int irow)
        """
        return _eaSDIF.Matrix_GetRow(self, *args)

    def GetCol(self, *args):
        r"""
        GetCol(Matrix self, double * out, int icol)
        GetCol(Matrix self, Vector out, int icol)
        GetCol(Matrix self, float * out, int icol)
        GetCol(Matrix self, FVector out, int icol)
        GetCol(Matrix self, char * out, int icol)
        GetCol(Matrix self, std::vector< char,std::allocator< char > > & out, int icol)
        GetCol(Matrix self, short * out, int icol)
        GetCol(Matrix self, std::vector< short,std::allocator< short > > & out, int icol)
        GetCol(Matrix self, int * out, int icol)
        GetCol(Matrix self, IVector out, int icol)
        GetCol(Matrix self, unsigned char * out, int icol)
        GetCol(Matrix self, std::vector< unsigned char,std::allocator< unsigned char > > & out, int icol)
        GetCol(Matrix self, unsigned short * out, int icol)
        GetCol(Matrix self, std::vector< unsigned short,std::allocator< unsigned short > > & out, int icol)
        GetCol(Matrix self, unsigned int * out, int icol)
        GetCol(Matrix self, Selection out, int icol)
        """
        return _eaSDIF.Matrix_GetCol(self, *args)

    def SetRow(self, *args):
        r"""
        SetRow(Matrix self, double const * in_arr, int irow)
        SetRow(Matrix self, Vector inVec, int irow)
        SetRow(Matrix self, float const * in_arr, int irow)
        SetRow(Matrix self, FVector inVec, int irow)
        SetRow(Matrix self, char const * in_arr, int irow)
        SetRow(Matrix self, std::vector< char,std::allocator< char > > const & inVec, int irow)
        SetRow(Matrix self, short const * in_arr, int irow)
        SetRow(Matrix self, std::vector< short,std::allocator< short > > const & inVec, int irow)
        SetRow(Matrix self, int const * in_arr, int irow)
        SetRow(Matrix self, IVector inVec, int irow)
        SetRow(Matrix self, unsigned char const * in_arr, int irow)
        SetRow(Matrix self, std::vector< unsigned char,std::allocator< unsigned char > > const & inVec, int irow)
        SetRow(Matrix self, unsigned short const * in_arr, int irow)
        SetRow(Matrix self, std::vector< unsigned short,std::allocator< unsigned short > > const & inVec, int irow)
        SetRow(Matrix self, unsigned int const * in_arr, int irow)
        SetRow(Matrix self, Selection inVec, int irow)
        """
        return _eaSDIF.Matrix_SetRow(self, *args)

    def SetCol(self, *args):
        r"""
        SetCol(Matrix self, double const * in_arr, int icol)
        SetCol(Matrix self, Vector inVec, int icol)
        SetCol(Matrix self, float const * in_arr, int icol)
        SetCol(Matrix self, FVector inVec, int icol)
        SetCol(Matrix self, char const * in_arr, int icol)
        SetCol(Matrix self, std::vector< char,std::allocator< char > > const & inVec, int icol)
        SetCol(Matrix self, short const * in_arr, int icol)
        SetCol(Matrix self, std::vector< short,std::allocator< short > > const & inVec, int icol)
        SetCol(Matrix self, int const * in_arr, int icol)
        SetCol(Matrix self, IVector inVec, int icol)
        SetCol(Matrix self, unsigned char const * in_arr, int icol)
        SetCol(Matrix self, std::vector< unsigned char,std::allocator< unsigned char > > const & inVec, int icol)
        SetCol(Matrix self, unsigned short const * in_arr, int icol)
        SetCol(Matrix self, std::vector< unsigned short,std::allocator< unsigned short > > const & inVec, int icol)
        SetCol(Matrix self, unsigned int const * in_arr, int icol)
        SetCol(Matrix self, Selection inVec, int icol)
        """
        return _eaSDIF.Matrix_SetCol(self, *args)

    def GetColA(self, *args):
        r"""
        GetColA(Matrix self, signed char * outarr, int col) -> int
        GetColA(Matrix self, double * outarr, int col) -> int
        GetColA(Matrix self, float * outarr, int col) -> int
        GetColA(Matrix self, unsigned int * outarr, int col) -> int
        GetColA(Matrix self, unsigned short * outarr, int col) -> int
        GetColA(Matrix self, unsigned char * outarr, int col) -> int
        GetColA(Matrix self, int * outarr, int col) -> int
        GetColA(Matrix self, short * outarr, int col) -> int
        GetColA(Matrix self, char * outarr, int outarrsize, int col) -> int
        """
        return _eaSDIF.Matrix_GetColA(self, *args)

    def GetRowA(self, *args):
        r"""
        GetRowA(Matrix self, signed char * outarr, int col) -> int
        GetRowA(Matrix self, double * outarr, int col) -> int
        GetRowA(Matrix self, float * outarr, int col) -> int
        GetRowA(Matrix self, unsigned int * outarr, int col) -> int
        GetRowA(Matrix self, unsigned short * outarr, int col) -> int
        GetRowA(Matrix self, unsigned char * outarr, int col) -> int
        GetRowA(Matrix self, int * outarr, int col) -> int
        GetRowA(Matrix self, short * outarr, int col) -> int
        GetRowA(Matrix self, char * outarr, int outarrsize, int col) -> int
        """
        return _eaSDIF.Matrix_GetRowA(self, *args)

    def SetColA(self, *args):
        r"""
        SetColA(Matrix self, double const * inarr, int col) -> int
        SetColA(Matrix self, float const * inarr, int col) -> int
        SetColA(Matrix self, unsigned int const * inarr, int col) -> int
        SetColA(Matrix self, unsigned short const * inarr, int col) -> int
        SetColA(Matrix self, unsigned char const * inarr, int col) -> int
        SetColA(Matrix self, int const * inarr, int col) -> int
        SetColA(Matrix self, short const * inarr, int col) -> int
        SetColA(Matrix self, char const * inarr, int inarrsize, int col) -> int
        SetColA(Matrix self, signed char const * outarr, int outarrsize, int col) -> int
        """
        return _eaSDIF.Matrix_SetColA(self, *args)

    def SetRowA(self, *args):
        r"""
        SetRowA(Matrix self, double const * inarr, int col) -> int
        SetRowA(Matrix self, float const * inarr, int col) -> int
        SetRowA(Matrix self, unsigned int const * inarr, int col) -> int
        SetRowA(Matrix self, unsigned short const * inarr, int col) -> int
        SetRowA(Matrix self, unsigned char const * inarr, int col) -> int
        SetRowA(Matrix self, int const * inarr, int col) -> int
        SetRowA(Matrix self, short const * inarr, int col) -> int
        SetRowA(Matrix self, char const * inarr, int inarrsize, int col) -> int
        SetRowA(Matrix self, signed char const * outarr, int outarrsize, int col) -> int
        """
        return _eaSDIF.Matrix_SetRowA(self, *args)

    def GetMatrixData(self):
        r"""GetMatrixData(Matrix self) -> PyObject *"""
        return _eaSDIF.Matrix_GetMatrixData(self)

# Register Matrix in _eaSDIF:
_eaSDIF.Matrix_swigregister(Matrix)
SDIFNAMEVALUETABLE_H_ = _eaSDIF.SDIFNAMEVALUETABLE_H_

class NameValueTable(stringmap):
    r"""Proxy of C++ Easdif::SDIFNameValueTable 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__(NameValueTable self) -> NameValueTable"""
        _eaSDIF.NameValueTable_swiginit(self, _eaSDIF.new_NameValueTable())
    __swig_destroy__ = _eaSDIF.delete_NameValueTable

    def AddNameValue(self, name, value):
        r"""AddNameValue(NameValueTable self, std::string const & name, std::string const & value) -> int"""
        return _eaSDIF.NameValueTable_AddNameValue(self, name, value)

    def SetStreamID(self, streamid):
        r"""SetStreamID(NameValueTable self, SdifUInt4 const & streamid) -> SdifUInt4"""
        return _eaSDIF.NameValueTable_SetStreamID(self, streamid)

    def PrintNameValue(self, name):
        r"""PrintNameValue(NameValueTable self, std::string const & name)"""
        return _eaSDIF.NameValueTable_PrintNameValue(self, name)

    def PrintNameValueTable(self):
        r"""PrintNameValueTable(NameValueTable self)"""
        return _eaSDIF.NameValueTable_PrintNameValueTable(self)

    def GetNbNameValue(self):
        r"""GetNbNameValue(NameValueTable self) -> int"""
        return _eaSDIF.NameValueTable_GetNbNameValue(self)

    def GetStreamID(self):
        r"""GetStreamID(NameValueTable self) -> SdifUInt4"""
        return _eaSDIF.NameValueTable_GetStreamID(self)

    def GetValue(self, *args):
        r"""
        GetValue(NameValueTable self, std::string const & name) -> std::string
        GetValue(NameValueTable self, std::string const & name, std::string & value) -> bool
        """
        return _eaSDIF.NameValueTable_GetValue(self, *args)

# Register NameValueTable in _eaSDIF:
_eaSDIF.NameValueTable_swigregister(NameValueTable)
SDIFFRAME_H_ = _eaSDIF.SDIFFRAME_H_

class Frame(object):
    r"""Proxy of C++ Easdif::SDIFFrame 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__(Frame self) -> Frame"""
        _eaSDIF.Frame_swiginit(self, _eaSDIF.new_Frame())

    def Read(self, *args):
        r"""
        Read(Frame self, SdifFileT * file, bool & eof) -> int
        Read(Frame self, Entity entity) -> int
        """
        return _eaSDIF.Frame_Read(self, *args)

    def ReadData(self, *args):
        r"""
        ReadData(Frame self, SdifFileT * file, ISet hlsig=None) -> int
        ReadData(Frame self, Entity entity) -> int
        """
        return _eaSDIF.Frame_ReadData(self, *args)

    def ReadHeader(self, *args):
        r"""
        ReadHeader(Frame self, SdifFileT * file) -> int
        ReadHeader(Frame self, Entity entity) -> int
        """
        return _eaSDIF.Frame_ReadHeader(self, *args)

    def Write(self, *args):
        r"""
        Write(Frame self, SdifFileT * file) -> int
        Write(Frame self, Entity entity) -> int
        """
        return _eaSDIF.Frame_Write(self, *args)

    def WriteHeader(self, *args):
        r"""
        WriteHeader(Frame self, SdifFileT * file) -> int
        WriteHeader(Frame self, Entity entity) -> int
        """
        return _eaSDIF.Frame_WriteHeader(self, *args)

    def AddMatrix(self, aMatrix):
        r"""AddMatrix(Frame self, Matrix aMatrix) -> int"""
        return _eaSDIF.Frame_AddMatrix(self, aMatrix)

    def Print(self):
        r"""Print(Frame self)"""
        return _eaSDIF.Frame_Print(self)

    def PrintHeader(self):
        r"""PrintHeader(Frame self)"""
        return _eaSDIF.Frame_PrintHeader(self)

    def ClearData(self):
        r"""ClearData(Frame self)"""
        return _eaSDIF.Frame_ClearData(self)

    def clear(self):
        r"""clear(Frame self)"""
        return _eaSDIF.Frame_clear(self)

    def Resize(self, _size):
        r"""Resize(Frame self, int _size)"""
        return _eaSDIF.Frame_Resize(self, _size)

    def resize(self, _size):
        r"""resize(Frame self, int _size)"""
        return _eaSDIF.Frame_resize(self, _size)

    def MatrixExists(self, *args):
        r"""
        MatrixExists(Frame self, SdifSignature const & sig) -> bool
        MatrixExists(Frame self, std::string const & signature) -> bool
        """
        return _eaSDIF.Frame_MatrixExists(self, *args)

    def GetMatrixWithSig(self, sig):
        r"""GetMatrixWithSig(Frame self, SdifSignature const sig) -> Matrix"""
        return _eaSDIF.Frame_GetMatrixWithSig(self, sig)

    def GetMatrix(self, *args):
        r"""
        GetMatrix(Frame self, unsigned int index) -> Matrix
        GetMatrix(Frame self, unsigned int index) -> Matrix
        GetMatrix(Frame self, std::string const & signature) -> Matrix
        GetMatrix(Frame self, std::string const & signature) -> Matrix
        """
        return _eaSDIF.Frame_GetMatrix(self, *args)

    def begin(self, *args):
        r"""
        begin(Frame self) -> Easdif::SDIFFrame::iterator
        begin(Frame self) -> Easdif::SDIFFrame::const_iterator
        """
        return _eaSDIF.Frame_begin(self, *args)

    def end(self, *args):
        r"""
        end(Frame self) -> Easdif::SDIFFrame::iterator
        end(Frame self) -> Easdif::SDIFFrame::const_iterator
        """
        return _eaSDIF.Frame_end(self, *args)

    def GetNbMatrix(self):
        r"""GetNbMatrix(Frame self) -> SdifUInt4"""
        return _eaSDIF.Frame_GetNbMatrix(self)

    def size(self):
        r"""size(Frame self) -> SdifUInt4"""
        return _eaSDIF.Frame_size(self)

    def GetSignature(self, *args):
        r"""
        GetSignature(Frame self) -> SdifSignature
        GetSignature(Frame self, std::string & sig)
        """
        return _eaSDIF.Frame_GetSignature(self, *args)

    def GetStreamID(self):
        r"""GetStreamID(Frame self) -> SdifUInt4"""
        return _eaSDIF.Frame_GetStreamID(self)

    def GetTime(self):
        r"""GetTime(Frame self) -> SdifFloat8"""
        return _eaSDIF.Frame_GetTime(self)

    def GetSize(self):
        r"""GetSize(Frame self) -> SdifUInt4"""
        return _eaSDIF.Frame_GetSize(self)

    def SetHeader(self, *args):
        r"""
        SetHeader(Frame self, SdifSignature sig, SdifUInt4 streamID, SdifFloat8 time)
        SetHeader(Frame self, std::string const & sig, SdifUInt4 streamID, SdifFloat8 time)
        """
        return _eaSDIF.Frame_SetHeader(self, *args)

    def SetSignature(self, *args):
        r"""
        SetSignature(Frame self, SdifSignature sig)
        SetSignature(Frame self, std::string const & signature)
        """
        return _eaSDIF.Frame_SetSignature(self, *args)

    def SetStreamID(self, streamID):
        r"""SetStreamID(Frame self, SdifUInt4 streamID)"""
        return _eaSDIF.Frame_SetStreamID(self, streamID)

    def SetTime(self, time):
        r"""SetTime(Frame self, SdifFloat8 time)"""
        return _eaSDIF.Frame_SetTime(self, time)

    def __lt__(self, compareTo):
        r"""__lt__(Frame self, Frame compareTo) -> bool"""
        return _eaSDIF.Frame___lt__(self, compareTo)

    def __iter__(self):
        r"""__iter__(Frame self) -> Frame"""
        return _eaSDIF.Frame___iter__(self)

    def __next__(self):
        r"""__next__(Frame self) -> Matrix"""
        return _eaSDIF.Frame___next__(self)

    def copy(self):
        r"""copy(Frame self) -> Frame"""
        return _eaSDIF.Frame_copy(self)
    __swig_destroy__ = _eaSDIF.delete_Frame

# Register Frame in _eaSDIF:
_eaSDIF.Frame_swigregister(Frame)
SDIFENTITY_H_ = _eaSDIF.SDIFENTITY_H_


def Version():
    r"""Version() -> char const *"""
    return _eaSDIF.Version()
class MatrixType(object):
    r"""Proxy of C++ Easdif::MatrixType class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    mSig = property(_eaSDIF.MatrixType_mSig_get, _eaSDIF.MatrixType_mSig_set, doc=r"""mSig : SdifSignature""")
    mvColumnNames = property(_eaSDIF.MatrixType_mvColumnNames_get, _eaSDIF.MatrixType_mvColumnNames_set, doc=r"""mvColumnNames : std::vector<(std::string,std::allocator<(std::string)>)>""")

    def __init__(self, *args):
        r"""
        __init__(MatrixType self) -> MatrixType
        __init__(MatrixType self, SdifSignature sig) -> MatrixType
        """
        _eaSDIF.MatrixType_swiginit(self, _eaSDIF.new_MatrixType(*args))
    __swig_destroy__ = _eaSDIF.delete_MatrixType

    def AddColumn(self, column_name):
        r"""AddColumn(MatrixType self, char const * column_name)"""
        return _eaSDIF.MatrixType_AddColumn(self, column_name)

    def SetSignature(self, sig):
        r"""SetSignature(MatrixType self, SdifSignature sig)"""
        return _eaSDIF.MatrixType_SetSignature(self, sig)

    def Clear(self):
        r"""Clear(MatrixType self)"""
        return _eaSDIF.MatrixType_Clear(self)

    def GetNbCols(self):
        r"""GetNbCols(MatrixType self) -> int"""
        return _eaSDIF.MatrixType_GetNbCols(self)

    def GetSignature(self):
        r"""GetSignature(MatrixType self) -> SdifSignature"""
        return _eaSDIF.MatrixType_GetSignature(self)

    def __str__(self):
        r"""__str__(MatrixType self) -> PyObject *"""
        return _eaSDIF.MatrixType___str__(self)

# Register MatrixType in _eaSDIF:
_eaSDIF.MatrixType_swigregister(MatrixType)
class FrameType(object):
    r"""Proxy of C++ Easdif::FrameType class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    mSig = property(_eaSDIF.FrameType_mSig_get, _eaSDIF.FrameType_mSig_set, doc=r"""mSig : SdifSignature""")
    mvMatrixNames = property(_eaSDIF.FrameType_mvMatrixNames_get, _eaSDIF.FrameType_mvMatrixNames_set, doc=r"""mvMatrixNames : std::vector<(std::string,std::allocator<(std::string)>)>""")
    mvMatrixTypes = property(_eaSDIF.FrameType_mvMatrixTypes_get, _eaSDIF.FrameType_mvMatrixTypes_set, doc=r"""mvMatrixTypes : std::vector<(Easdif::MatrixType,std::allocator<(Easdif::MatrixType)>)>""")

    def __init__(self, *args):
        r"""
        __init__(FrameType self, SdifSignature sig) -> FrameType
        __init__(FrameType self) -> FrameType
        """
        _eaSDIF.FrameType_swiginit(self, _eaSDIF.new_FrameType(*args))
    __swig_destroy__ = _eaSDIF.delete_FrameType

    def AddMatrixType(self, mat, matrix_name):
        r"""AddMatrixType(FrameType self, MatrixType mat, char const * matrix_name)"""
        return _eaSDIF.FrameType_AddMatrixType(self, mat, matrix_name)

    def SetSignature(self, sig):
        r"""SetSignature(FrameType self, SdifSignature sig)"""
        return _eaSDIF.FrameType_SetSignature(self, sig)

    def Clear(self):
        r"""Clear(FrameType self)"""
        return _eaSDIF.FrameType_Clear(self)

    def GetNbMatrices(self):
        r"""GetNbMatrices(FrameType self) -> int"""
        return _eaSDIF.FrameType_GetNbMatrices(self)

    def GetSignature(self):
        r"""GetSignature(FrameType self) -> SdifSignature"""
        return _eaSDIF.FrameType_GetSignature(self)

    def __str__(self):
        r"""__str__(FrameType self) -> PyObject *"""
        return _eaSDIF.FrameType___str__(self)

# Register FrameType in _eaSDIF:
_eaSDIF.FrameType_swigregister(FrameType)
class SDIFLocation(object):
    r"""Proxy of C++ Easdif::SDIFLocation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    mPos = property(_eaSDIF.SDIFLocation_mPos_get, _eaSDIF.SDIFLocation_mPos_set, doc=r"""mPos : SdiffPosT""")
    mFrameHdr = property(_eaSDIF.SDIFLocation_mFrameHdr_get, _eaSDIF.SDIFLocation_mFrameHdr_set, doc=r"""mFrameHdr : SdifFrameHeaderS""")
    mMatrixSig0 = property(_eaSDIF.SDIFLocation_mMatrixSig0_get, _eaSDIF.SDIFLocation_mMatrixSig0_set, doc=r"""mMatrixSig0 : SdifSignature""")
    mMatrixSig1 = property(_eaSDIF.SDIFLocation_mMatrixSig1_get, _eaSDIF.SDIFLocation_mMatrixSig1_set, doc=r"""mMatrixSig1 : SdifSignature""")
    mMatrixSig2 = property(_eaSDIF.SDIFLocation_mMatrixSig2_get, _eaSDIF.SDIFLocation_mMatrixSig2_set, doc=r"""mMatrixSig2 : SdifSignature""")
    mMatrixN = property(_eaSDIF.SDIFLocation_mMatrixN_get, _eaSDIF.SDIFLocation_mMatrixN_set, doc=r"""mMatrixN : std::vector<(SdifSignature,std::allocator<(SdifSignature)>)>""")

    def __init__(self, *args):
        r"""
        __init__(SDIFLocation self) -> SDIFLocation
        __init__(SDIFLocation self, SdifUInt4 _pos, SdifUInt4 _id, SdifFloat8 _time, SdifSignature _sig, SdifUInt4 _nmatrix) -> SDIFLocation
        """
        _eaSDIF.SDIFLocation_swiginit(self, _eaSDIF.new_SDIFLocation(*args))

    def LocStreamID(self):
        r"""LocStreamID(SDIFLocation self) -> SdifUInt4"""
        return _eaSDIF.SDIFLocation_LocStreamID(self)

    def LocNbMatrix(self):
        r"""LocNbMatrix(SDIFLocation self) -> SdifUInt4"""
        return _eaSDIF.SDIFLocation_LocNbMatrix(self)

    def LocTime(self):
        r"""LocTime(SDIFLocation self) -> SdifFloat8"""
        return _eaSDIF.SDIFLocation_LocTime(self)

    def LocSignature(self):
        r"""LocSignature(SDIFLocation self) -> SdifSignature"""
        return _eaSDIF.SDIFLocation_LocSignature(self)

    def LocPos(self):
        r"""LocPos(SDIFLocation self) -> SdiffPosT"""
        return _eaSDIF.SDIFLocation_LocPos(self)

    def LocMSignature(self, ind):
        r"""LocMSignature(SDIFLocation self, SdifUInt4 ind) -> SdifSignature"""
        return _eaSDIF.SDIFLocation_LocMSignature(self, ind)

    def LocMatrixExists(self, *args):
        r"""
        LocMatrixExists(SDIFLocation self, SdifSignature inSig) -> bool
        LocMatrixExists(SDIFLocation self, std::string const & inStr) -> bool
        """
        return _eaSDIF.SDIFLocation_LocMatrixExists(self, *args)

    def SetMSignature(self, ind, _sig):
        r"""SetMSignature(SDIFLocation self, SdifUInt4 ind, SdifSignature _sig)"""
        return _eaSDIF.SDIFLocation_SetMSignature(self, ind, _sig)
    __swig_destroy__ = _eaSDIF.delete_SDIFLocation

# Register SDIFLocation in _eaSDIF:
_eaSDIF.SDIFLocation_swigregister(SDIFLocation)
class Entity(object):
    r"""Proxy of C++ Easdif::SDIFEntity class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    eSP_Stream = _eaSDIF.Entity_eSP_Stream
    
    eSP_Frame = _eaSDIF.Entity_eSP_Frame
    
    eSP_Matrix = _eaSDIF.Entity_eSP_Matrix
    
    eSP_Time = _eaSDIF.Entity_eSP_Time
    
    eSP_Row = _eaSDIF.Entity_eSP_Row
    
    eSP_Column = _eaSDIF.Entity_eSP_Column
    
    eSP_All = _eaSDIF.Entity_eSP_All
    
    mFrameDirectory = property(_eaSDIF.Entity_mFrameDirectory_get, _eaSDIF.Entity_mFrameDirectory_set, doc=r"""mFrameDirectory : Easdif::Directory""")

    def __init__(self):
        r"""__init__(Entity self) -> Entity"""
        _eaSDIF.Entity_swiginit(self, _eaSDIF.new_Entity())
    __swig_destroy__ = _eaSDIF.delete_Entity

    def begin(self, *args):
        r"""
        begin(Entity self) -> Easdif::SDIFEntity::const_iterator
        begin(Entity self) -> Easdif::SDIFEntity::iterator
        """
        return _eaSDIF.Entity_begin(self, *args)

    def end(self, *args):
        r"""
        end(Entity self) -> Easdif::SDIFEntity::const_iterator
        end(Entity self) -> Easdif::SDIFEntity::iterator
        """
        return _eaSDIF.Entity_end(self, *args)

    def currLoc(self):
        r"""currLoc(Entity self) -> SDIFLocation"""
        return _eaSDIF.Entity_currLoc(self)

    def lastRead(self, *args):
        r"""
        lastRead(Entity self) -> Easdif::SDIFEntity::const_iterator
        lastRead(Entity self) -> Easdif::SDIFEntity::iterator
        """
        return _eaSDIF.Entity_lastRead(self, *args)

    def GetDirectory(self):
        r"""GetDirectory(Entity self) -> Directory"""
        return _eaSDIF.Entity_GetDirectory(self)

    def AddFrameType(self, *args):
        r"""
        AddFrameType(Entity self, std::string const & frametype, std::string const & matrix_description) -> bool
        AddFrameType(Entity self, FrameType frameType) -> bool
        """
        return _eaSDIF.Entity_AddFrameType(self, *args)

    def AddMatrixType(self, *args):
        r"""
        AddMatrixType(Entity self, std::string const & matrixtype, std::string const & colnames) -> bool
        AddMatrixType(Entity self, MatrixType matrixtype) -> bool
        """
        return _eaSDIF.Entity_AddMatrixType(self, *args)

    def PrintTypes(self):
        r"""PrintTypes(Entity self) -> int"""
        return _eaSDIF.Entity_PrintTypes(self)

    def GetTypes(self, *args):
        r"""
        GetTypes(Entity self, FrameTypeVector frametypes)
        GetTypes(Entity self, MatrixTypeVector matrixtypes)
        """
        return _eaSDIF.Entity_GetTypes(self, *args)

    def GetTypeString(self):
        r"""GetTypeString(Entity self) -> std::string const &"""
        return _eaSDIF.Entity_GetTypeString(self)

    def clearTypes(self):
        r"""clearTypes(Entity self)"""
        return _eaSDIF.Entity_clearTypes(self)

    def SetTypeString(self, TypeString):
        r"""SetTypeString(Entity self, std::string const & TypeString) -> bool"""
        return _eaSDIF.Entity_SetTypeString(self, TypeString)

    def ChangeSelection(self, selection):
        r"""ChangeSelection(Entity self, std::string const & selection) -> bool"""
        return _eaSDIF.Entity_ChangeSelection(self, selection)

    def MergeSelection(self, selection):
        r"""MergeSelection(Entity self, std::string const & selection) -> bool"""
        return _eaSDIF.Entity_MergeSelection(self, selection)

    def ClearSelection(self, part):
        r"""ClearSelection(Entity self, Easdif::SDIFEntity::SelectionPartsE part) -> bool"""
        return _eaSDIF.Entity_ClearSelection(self, part)

    def GetMatrixSelection(self, out):
        r"""GetMatrixSelection(Entity self, SelectionSetI out) -> bool"""
        return _eaSDIF.Entity_GetMatrixSelection(self, out)

    def TestMatrixSelection(self, sig):
        r"""TestMatrixSelection(Entity self, SdifSignature sig) -> bool"""
        return _eaSDIF.Entity_TestMatrixSelection(self, sig)

    def GetFrameSelection(self, out):
        r"""GetFrameSelection(Entity self, SelectionSetI out) -> bool"""
        return _eaSDIF.Entity_GetFrameSelection(self, out)

    def TestFrameSelection(self, sig):
        r"""TestFrameSelection(Entity self, SdifSignature sig) -> bool"""
        return _eaSDIF.Entity_TestFrameSelection(self, sig)

    def GetStreamSelection(self, out):
        r"""GetStreamSelection(Entity self, SelectionSetI out) -> bool"""
        return _eaSDIF.Entity_GetStreamSelection(self, out)

    def TestStreamSelection(self, streamid):
        r"""TestStreamSelection(Entity self, unsigned int streamid) -> bool"""
        return _eaSDIF.Entity_TestStreamSelection(self, streamid)

    def ReestablishFrameSelection(self):
        r"""ReestablishFrameSelection(Entity self) -> bool"""
        return _eaSDIF.Entity_ReestablishFrameSelection(self)

    def ReestablishMatrixSelection(self):
        r"""ReestablishMatrixSelection(Entity self) -> bool"""
        return _eaSDIF.Entity_ReestablishMatrixSelection(self)

    def ReestablishStreamSelection(self):
        r"""ReestablishStreamSelection(Entity self) -> bool"""
        return _eaSDIF.Entity_ReestablishStreamSelection(self)

    def Open(self, filename, Mode):
        r"""Open(Entity self, char const * filename, SdifFileModeET Mode) -> bool"""
        return _eaSDIF.Entity_Open(self, filename, Mode)

    def OpenRead(self, filename):
        r"""OpenRead(Entity self, char const * filename) -> bool"""
        return _eaSDIF.Entity_OpenRead(self, filename)

    def ReOpenRead(self, filename):
        r"""ReOpenRead(Entity self, char const * filename) -> bool"""
        return _eaSDIF.Entity_ReOpenRead(self, filename)

    def OpenWrite(self, filename):
        r"""OpenWrite(Entity self, char const * filename) -> bool"""
        return _eaSDIF.Entity_OpenWrite(self, filename)

    def Close(self):
        r"""Close(Entity self) -> bool"""
        return _eaSDIF.Entity_Close(self)

    def Rewind(self):
        r"""Rewind(Entity self) -> bool"""
        return _eaSDIF.Entity_Rewind(self)

    def FillFrameDirAndRewind(self):
        r"""FillFrameDirAndRewind(Entity self) -> bool"""
        return _eaSDIF.Entity_FillFrameDirAndRewind(self)

    def isSeekable(self):
        r"""isSeekable(Entity self) -> bool"""
        return _eaSDIF.Entity_isSeekable(self)

    def GetFile(self):
        r"""GetFile(Entity self) -> SdifFileT *"""
        return _eaSDIF.Entity_GetFile(self)

    def IsOpen(self):
        r"""IsOpen(Entity self) -> bool"""
        return _eaSDIF.Entity_IsOpen(self)

    def good(self):
        r"""good(Entity self) -> bool"""
        return _eaSDIF.Entity_good(self)

    def eof(self):
        r"""eof(Entity self) -> bool"""
        return _eaSDIF.Entity_eof(self)

    def EnableFrameDir(self):
        r"""EnableFrameDir(Entity self) -> bool"""
        return _eaSDIF.Entity_EnableFrameDir(self)

    def IsFrameDir(self):
        r"""IsFrameDir(Entity self) -> bool"""
        return _eaSDIF.Entity_IsFrameDir(self)

    def PrintFrameDir(self):
        r"""PrintFrameDir(Entity self)"""
        return _eaSDIF.Entity_PrintFrameDir(self)

    def LastError(self):
        r"""LastError(Entity self) -> SdifErrorT *"""
        return _eaSDIF.Entity_LastError(self)

    def PrintAllNVTs(self):
        r"""PrintAllNVTs(Entity self)"""
        return _eaSDIF.Entity_PrintAllNVTs(self)

    def AddNVT(self, *args):
        r"""
        AddNVT(Entity self, NameValueTable nvt, SdifUInt4 StreamID) -> bool
        AddNVT(Entity self, NameValueTable nvt) -> bool
        """
        return _eaSDIF.Entity_AddNVT(self, *args)

    def GetNbNVT(self):
        r"""GetNbNVT(Entity self) -> int"""
        return _eaSDIF.Entity_GetNbNVT(self)

    def GetNVT(self, i):
        r"""GetNVT(Entity self, unsigned int i) -> NameValueTable"""
        return _eaSDIF.Entity_GetNVT(self, i)

    def clearAllNVT(self):
        r"""clearAllNVT(Entity self)"""
        return _eaSDIF.Entity_clearAllNVT(self)

    def ReadNextFrame(self, frame):
        r"""ReadNextFrame(Entity self, Frame frame) -> int"""
        return _eaSDIF.Entity_ReadNextFrame(self, frame)

    def ReadPrevSelectedFrame(self, frame):
        r"""ReadPrevSelectedFrame(Entity self, Frame frame) -> int"""
        return _eaSDIF.Entity_ReadPrevSelectedFrame(self, frame)

    def ReadNextSelectedFrame(self, *args):
        r"""
        ReadNextSelectedFrame(Entity self, Frame frame) -> int
        ReadNextSelectedFrame(Entity self, Frame frame, SdifFloat8 timePos) -> int
        """
        return _eaSDIF.Entity_ReadNextSelectedFrame(self, *args)

    def WriteFrame(self, frame):
        r"""WriteFrame(Entity self, Frame frame) -> int"""
        return _eaSDIF.Entity_WriteFrame(self, frame)

    def RestrictFrameSelection(self, *args):
        r"""
        RestrictFrameSelection(Entity self, SelectionSetI sigs) -> bool
        RestrictFrameSelection(self, set)
        """
        return _eaSDIF.Entity_RestrictFrameSelection(self, *args)

    def RestrictStreamSelection(self, *args):
        r"""
        RestrictStreamSelection(Entity self, SelectionSetI streamid) -> bool
        RestrictStreamSelection(self, set)
        """
        return _eaSDIF.Entity_RestrictStreamSelection(self, *args)

    def RestrictMatrixSelection(self, *args):
        r"""
        RestrictMatrixSelection(Entity self, SelectionSetI sigs) -> bool
        RestrictMatrixSelection(self, set)
        """
        return _eaSDIF.Entity_RestrictMatrixSelection(self, *args)

    def __iter__(self):
        r"""__iter__(Entity self) -> Entity"""
        return _eaSDIF.Entity___iter__(self)

    def __next__(self):
        r"""__next__(Entity self) -> Frame"""
        return _eaSDIF.Entity___next__(self)

# Register Entity in _eaSDIF:
_eaSDIF.Entity_swigregister(Entity)
class MatrixTypeVector(object):
    r"""Proxy of C++ std::vector< Easdif::MatrixType > 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(MatrixTypeVector self) -> SwigPyIterator"""
        return _eaSDIF.MatrixTypeVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(MatrixTypeVector self) -> bool"""
        return _eaSDIF.MatrixTypeVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(MatrixTypeVector self) -> bool"""
        return _eaSDIF.MatrixTypeVector___bool__(self)

    def __len__(self):
        r"""__len__(MatrixTypeVector self) -> std::vector< Easdif::MatrixType >::size_type"""
        return _eaSDIF.MatrixTypeVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(MatrixTypeVector self, std::vector< Easdif::MatrixType >::difference_type i, std::vector< Easdif::MatrixType >::difference_type j) -> MatrixTypeVector"""
        return _eaSDIF.MatrixTypeVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(MatrixTypeVector self, std::vector< Easdif::MatrixType >::difference_type i, std::vector< Easdif::MatrixType >::difference_type j)
        __setslice__(MatrixTypeVector self, std::vector< Easdif::MatrixType >::difference_type i, std::vector< Easdif::MatrixType >::difference_type j, MatrixTypeVector v)
        """
        return _eaSDIF.MatrixTypeVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(MatrixTypeVector self, std::vector< Easdif::MatrixType >::difference_type i, std::vector< Easdif::MatrixType >::difference_type j)"""
        return _eaSDIF.MatrixTypeVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(MatrixTypeVector self, std::vector< Easdif::MatrixType >::difference_type i)
        __delitem__(MatrixTypeVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _eaSDIF.MatrixTypeVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(MatrixTypeVector self, SWIGPY_SLICEOBJECT * slice) -> MatrixTypeVector
        __getitem__(MatrixTypeVector self, std::vector< Easdif::MatrixType >::difference_type i) -> MatrixType
        """
        return _eaSDIF.MatrixTypeVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(MatrixTypeVector self, SWIGPY_SLICEOBJECT * slice, MatrixTypeVector v)
        __setitem__(MatrixTypeVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(MatrixTypeVector self, std::vector< Easdif::MatrixType >::difference_type i, MatrixType x)
        """
        return _eaSDIF.MatrixTypeVector___setitem__(self, *args)

    def pop(self):
        r"""pop(MatrixTypeVector self) -> MatrixType"""
        return _eaSDIF.MatrixTypeVector_pop(self)

    def append(self, x):
        r"""append(MatrixTypeVector self, MatrixType x)"""
        return _eaSDIF.MatrixTypeVector_append(self, x)

    def empty(self):
        r"""empty(MatrixTypeVector self) -> bool"""
        return _eaSDIF.MatrixTypeVector_empty(self)

    def size(self):
        r"""size(MatrixTypeVector self) -> std::vector< Easdif::MatrixType >::size_type"""
        return _eaSDIF.MatrixTypeVector_size(self)

    def swap(self, v):
        r"""swap(MatrixTypeVector self, MatrixTypeVector v)"""
        return _eaSDIF.MatrixTypeVector_swap(self, v)

    def begin(self):
        r"""begin(MatrixTypeVector self) -> std::vector< Easdif::MatrixType >::iterator"""
        return _eaSDIF.MatrixTypeVector_begin(self)

    def end(self):
        r"""end(MatrixTypeVector self) -> std::vector< Easdif::MatrixType >::iterator"""
        return _eaSDIF.MatrixTypeVector_end(self)

    def rbegin(self):
        r"""rbegin(MatrixTypeVector self) -> std::vector< Easdif::MatrixType >::reverse_iterator"""
        return _eaSDIF.MatrixTypeVector_rbegin(self)

    def rend(self):
        r"""rend(MatrixTypeVector self) -> std::vector< Easdif::MatrixType >::reverse_iterator"""
        return _eaSDIF.MatrixTypeVector_rend(self)

    def clear(self):
        r"""clear(MatrixTypeVector self)"""
        return _eaSDIF.MatrixTypeVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(MatrixTypeVector self) -> std::vector< Easdif::MatrixType >::allocator_type"""
        return _eaSDIF.MatrixTypeVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(MatrixTypeVector self)"""
        return _eaSDIF.MatrixTypeVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(MatrixTypeVector self, std::vector< Easdif::MatrixType >::iterator pos) -> std::vector< Easdif::MatrixType >::iterator
        erase(MatrixTypeVector self, std::vector< Easdif::MatrixType >::iterator first, std::vector< Easdif::MatrixType >::iterator last) -> std::vector< Easdif::MatrixType >::iterator
        """
        return _eaSDIF.MatrixTypeVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(MatrixTypeVector self) -> MatrixTypeVector
        __init__(MatrixTypeVector self, MatrixTypeVector other) -> MatrixTypeVector
        __init__(MatrixTypeVector self, std::vector< Easdif::MatrixType >::size_type size) -> MatrixTypeVector
        __init__(MatrixTypeVector self, std::vector< Easdif::MatrixType >::size_type size, MatrixType value) -> MatrixTypeVector
        """
        _eaSDIF.MatrixTypeVector_swiginit(self, _eaSDIF.new_MatrixTypeVector(*args))

    def push_back(self, x):
        r"""push_back(MatrixTypeVector self, MatrixType x)"""
        return _eaSDIF.MatrixTypeVector_push_back(self, x)

    def front(self):
        r"""front(MatrixTypeVector self) -> MatrixType"""
        return _eaSDIF.MatrixTypeVector_front(self)

    def back(self):
        r"""back(MatrixTypeVector self) -> MatrixType"""
        return _eaSDIF.MatrixTypeVector_back(self)

    def assign(self, n, x):
        r"""assign(MatrixTypeVector self, std::vector< Easdif::MatrixType >::size_type n, MatrixType x)"""
        return _eaSDIF.MatrixTypeVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(MatrixTypeVector self, std::vector< Easdif::MatrixType >::size_type new_size)
        resize(MatrixTypeVector self, std::vector< Easdif::MatrixType >::size_type new_size, MatrixType x)
        """
        return _eaSDIF.MatrixTypeVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(MatrixTypeVector self, std::vector< Easdif::MatrixType >::iterator pos, MatrixType x) -> std::vector< Easdif::MatrixType >::iterator
        insert(MatrixTypeVector self, std::vector< Easdif::MatrixType >::iterator pos, std::vector< Easdif::MatrixType >::size_type n, MatrixType x)
        """
        return _eaSDIF.MatrixTypeVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(MatrixTypeVector self, std::vector< Easdif::MatrixType >::size_type n)"""
        return _eaSDIF.MatrixTypeVector_reserve(self, n)

    def capacity(self):
        r"""capacity(MatrixTypeVector self) -> std::vector< Easdif::MatrixType >::size_type"""
        return _eaSDIF.MatrixTypeVector_capacity(self)
    __swig_destroy__ = _eaSDIF.delete_MatrixTypeVector

# Register MatrixTypeVector in _eaSDIF:
_eaSDIF.MatrixTypeVector_swigregister(MatrixTypeVector)
class FrameTypeVector(object):
    r"""Proxy of C++ std::vector< Easdif::FrameType > 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(FrameTypeVector self) -> SwigPyIterator"""
        return _eaSDIF.FrameTypeVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(FrameTypeVector self) -> bool"""
        return _eaSDIF.FrameTypeVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(FrameTypeVector self) -> bool"""
        return _eaSDIF.FrameTypeVector___bool__(self)

    def __len__(self):
        r"""__len__(FrameTypeVector self) -> std::vector< Easdif::FrameType >::size_type"""
        return _eaSDIF.FrameTypeVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(FrameTypeVector self, std::vector< Easdif::FrameType >::difference_type i, std::vector< Easdif::FrameType >::difference_type j) -> FrameTypeVector"""
        return _eaSDIF.FrameTypeVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(FrameTypeVector self, std::vector< Easdif::FrameType >::difference_type i, std::vector< Easdif::FrameType >::difference_type j)
        __setslice__(FrameTypeVector self, std::vector< Easdif::FrameType >::difference_type i, std::vector< Easdif::FrameType >::difference_type j, FrameTypeVector v)
        """
        return _eaSDIF.FrameTypeVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(FrameTypeVector self, std::vector< Easdif::FrameType >::difference_type i, std::vector< Easdif::FrameType >::difference_type j)"""
        return _eaSDIF.FrameTypeVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(FrameTypeVector self, std::vector< Easdif::FrameType >::difference_type i)
        __delitem__(FrameTypeVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _eaSDIF.FrameTypeVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(FrameTypeVector self, SWIGPY_SLICEOBJECT * slice) -> FrameTypeVector
        __getitem__(FrameTypeVector self, std::vector< Easdif::FrameType >::difference_type i) -> FrameType
        """
        return _eaSDIF.FrameTypeVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(FrameTypeVector self, SWIGPY_SLICEOBJECT * slice, FrameTypeVector v)
        __setitem__(FrameTypeVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(FrameTypeVector self, std::vector< Easdif::FrameType >::difference_type i, FrameType x)
        """
        return _eaSDIF.FrameTypeVector___setitem__(self, *args)

    def pop(self):
        r"""pop(FrameTypeVector self) -> FrameType"""
        return _eaSDIF.FrameTypeVector_pop(self)

    def append(self, x):
        r"""append(FrameTypeVector self, FrameType x)"""
        return _eaSDIF.FrameTypeVector_append(self, x)

    def empty(self):
        r"""empty(FrameTypeVector self) -> bool"""
        return _eaSDIF.FrameTypeVector_empty(self)

    def size(self):
        r"""size(FrameTypeVector self) -> std::vector< Easdif::FrameType >::size_type"""
        return _eaSDIF.FrameTypeVector_size(self)

    def swap(self, v):
        r"""swap(FrameTypeVector self, FrameTypeVector v)"""
        return _eaSDIF.FrameTypeVector_swap(self, v)

    def begin(self):
        r"""begin(FrameTypeVector self) -> std::vector< Easdif::FrameType >::iterator"""
        return _eaSDIF.FrameTypeVector_begin(self)

    def end(self):
        r"""end(FrameTypeVector self) -> std::vector< Easdif::FrameType >::iterator"""
        return _eaSDIF.FrameTypeVector_end(self)

    def rbegin(self):
        r"""rbegin(FrameTypeVector self) -> std::vector< Easdif::FrameType >::reverse_iterator"""
        return _eaSDIF.FrameTypeVector_rbegin(self)

    def rend(self):
        r"""rend(FrameTypeVector self) -> std::vector< Easdif::FrameType >::reverse_iterator"""
        return _eaSDIF.FrameTypeVector_rend(self)

    def clear(self):
        r"""clear(FrameTypeVector self)"""
        return _eaSDIF.FrameTypeVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(FrameTypeVector self) -> std::vector< Easdif::FrameType >::allocator_type"""
        return _eaSDIF.FrameTypeVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(FrameTypeVector self)"""
        return _eaSDIF.FrameTypeVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(FrameTypeVector self, std::vector< Easdif::FrameType >::iterator pos) -> std::vector< Easdif::FrameType >::iterator
        erase(FrameTypeVector self, std::vector< Easdif::FrameType >::iterator first, std::vector< Easdif::FrameType >::iterator last) -> std::vector< Easdif::FrameType >::iterator
        """
        return _eaSDIF.FrameTypeVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(FrameTypeVector self) -> FrameTypeVector
        __init__(FrameTypeVector self, FrameTypeVector other) -> FrameTypeVector
        __init__(FrameTypeVector self, std::vector< Easdif::FrameType >::size_type size) -> FrameTypeVector
        __init__(FrameTypeVector self, std::vector< Easdif::FrameType >::size_type size, FrameType value) -> FrameTypeVector
        """
        _eaSDIF.FrameTypeVector_swiginit(self, _eaSDIF.new_FrameTypeVector(*args))

    def push_back(self, x):
        r"""push_back(FrameTypeVector self, FrameType x)"""
        return _eaSDIF.FrameTypeVector_push_back(self, x)

    def front(self):
        r"""front(FrameTypeVector self) -> FrameType"""
        return _eaSDIF.FrameTypeVector_front(self)

    def back(self):
        r"""back(FrameTypeVector self) -> FrameType"""
        return _eaSDIF.FrameTypeVector_back(self)

    def assign(self, n, x):
        r"""assign(FrameTypeVector self, std::vector< Easdif::FrameType >::size_type n, FrameType x)"""
        return _eaSDIF.FrameTypeVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(FrameTypeVector self, std::vector< Easdif::FrameType >::size_type new_size)
        resize(FrameTypeVector self, std::vector< Easdif::FrameType >::size_type new_size, FrameType x)
        """
        return _eaSDIF.FrameTypeVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(FrameTypeVector self, std::vector< Easdif::FrameType >::iterator pos, FrameType x) -> std::vector< Easdif::FrameType >::iterator
        insert(FrameTypeVector self, std::vector< Easdif::FrameType >::iterator pos, std::vector< Easdif::FrameType >::size_type n, FrameType x)
        """
        return _eaSDIF.FrameTypeVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(FrameTypeVector self, std::vector< Easdif::FrameType >::size_type n)"""
        return _eaSDIF.FrameTypeVector_reserve(self, n)

    def capacity(self):
        r"""capacity(FrameTypeVector self) -> std::vector< Easdif::FrameType >::size_type"""
        return _eaSDIF.FrameTypeVector_capacity(self)
    __swig_destroy__ = _eaSDIF.delete_FrameTypeVector

# Register FrameTypeVector in _eaSDIF:
_eaSDIF.FrameTypeVector_swigregister(FrameTypeVector)
class ISet(object):
    r"""Proxy of C++ std::set< unsigned 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(ISet self) -> SwigPyIterator"""
        return _eaSDIF.ISet_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(ISet self) -> bool"""
        return _eaSDIF.ISet___nonzero__(self)

    def __bool__(self):
        r"""__bool__(ISet self) -> bool"""
        return _eaSDIF.ISet___bool__(self)

    def __len__(self):
        r"""__len__(ISet self) -> std::set< unsigned int >::size_type"""
        return _eaSDIF.ISet___len__(self)

    def append(self, x):
        r"""append(ISet self, std::set< unsigned int >::value_type x)"""
        return _eaSDIF.ISet_append(self, x)

    def __contains__(self, x):
        r"""__contains__(ISet self, std::set< unsigned int >::value_type x) -> bool"""
        return _eaSDIF.ISet___contains__(self, x)

    def __getitem__(self, i):
        r"""__getitem__(ISet self, std::set< unsigned int >::difference_type i) -> std::set< unsigned int >::value_type"""
        return _eaSDIF.ISet___getitem__(self, i)

    def add(self, x):
        r"""add(ISet self, std::set< unsigned int >::value_type x)"""
        return _eaSDIF.ISet_add(self, x)

    def discard(self, x):
        r"""discard(ISet self, std::set< unsigned int >::value_type x)"""
        return _eaSDIF.ISet_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(ISet self, std::less< unsigned int > const & other) -> ISet
        __init__(ISet self) -> ISet
        __init__(ISet self, ISet other) -> ISet
        """
        _eaSDIF.ISet_swiginit(self, _eaSDIF.new_ISet(*args))

    def empty(self):
        r"""empty(ISet self) -> bool"""
        return _eaSDIF.ISet_empty(self)

    def size(self):
        r"""size(ISet self) -> std::set< unsigned int >::size_type"""
        return _eaSDIF.ISet_size(self)

    def clear(self):
        r"""clear(ISet self)"""
        return _eaSDIF.ISet_clear(self)

    def swap(self, v):
        r"""swap(ISet self, ISet v)"""
        return _eaSDIF.ISet_swap(self, v)

    def count(self, x):
        r"""count(ISet self, std::set< unsigned int >::key_type const & x) -> std::set< unsigned int >::size_type"""
        return _eaSDIF.ISet_count(self, x)

    def begin(self):
        r"""begin(ISet self) -> std::set< unsigned int >::iterator"""
        return _eaSDIF.ISet_begin(self)

    def end(self):
        r"""end(ISet self) -> std::set< unsigned int >::iterator"""
        return _eaSDIF.ISet_end(self)

    def rbegin(self):
        r"""rbegin(ISet self) -> std::set< unsigned int >::reverse_iterator"""
        return _eaSDIF.ISet_rbegin(self)

    def rend(self):
        r"""rend(ISet self) -> std::set< unsigned int >::reverse_iterator"""
        return _eaSDIF.ISet_rend(self)

    def erase(self, *args):
        r"""
        erase(ISet self, std::set< unsigned int >::key_type const & x) -> std::set< unsigned int >::size_type
        erase(ISet self, std::set< unsigned int >::iterator pos)
        erase(ISet self, std::set< unsigned int >::iterator first, std::set< unsigned int >::iterator last)
        """
        return _eaSDIF.ISet_erase(self, *args)

    def find(self, x):
        r"""find(ISet self, std::set< unsigned int >::key_type const & x) -> std::set< unsigned int >::iterator"""
        return _eaSDIF.ISet_find(self, x)

    def lower_bound(self, x):
        r"""lower_bound(ISet self, std::set< unsigned int >::key_type const & x) -> std::set< unsigned int >::iterator"""
        return _eaSDIF.ISet_lower_bound(self, x)

    def upper_bound(self, x):
        r"""upper_bound(ISet self, std::set< unsigned int >::key_type const & x) -> std::set< unsigned int >::iterator"""
        return _eaSDIF.ISet_upper_bound(self, x)

    def equal_range(self, x):
        r"""equal_range(ISet self, std::set< unsigned int >::key_type const & x) -> std::pair< std::set< unsigned int >::iterator,std::set< unsigned int >::iterator >"""
        return _eaSDIF.ISet_equal_range(self, x)

    def insert(self, __x):
        r"""insert(ISet self, std::set< unsigned int >::value_type const & __x) -> std::pair< std::set< unsigned int >::iterator,bool >"""
        return _eaSDIF.ISet_insert(self, __x)
    __swig_destroy__ = _eaSDIF.delete_ISet

# Register ISet in _eaSDIF:
_eaSDIF.ISet_swigregister(ISet)
class SelectionSetI(ISet):
    r"""Proxy of C++ Easdif::SelectionSet< unsigned int > class."""

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

    def __init__(self, *args):
        r"""
        __init__(SelectionSetI self) -> SelectionSetI
        __init__(SelectionSetI self, ISet inset, bool _open=False) -> SelectionSetI
        """
        _eaSDIF.SelectionSetI_swiginit(self, _eaSDIF.new_SelectionSetI(*args))

    def isActive(self):
        r"""isActive(SelectionSetI self) -> bool"""
        return _eaSDIF.SelectionSetI_isActive(self)

    def isOpen(self):
        r"""isOpen(SelectionSetI self) -> bool"""
        return _eaSDIF.SelectionSetI_isOpen(self)

    def setOpen(self):
        r"""setOpen(SelectionSetI self)"""
        return _eaSDIF.SelectionSetI_setOpen(self)

    def isSelected(self, inType):
        r"""isSelected(SelectionSetI self, unsigned int const inType) -> bool"""
        return _eaSDIF.SelectionSetI_isSelected(self, inType)

    def insert(self, *args):
        r"""
        insert(SelectionSetI self, unsigned int const & __x) -> std::pair< std::set< unsigned int,std::less< unsigned int >,std::allocator< unsigned int > >::iterator,bool >
        insert(SelectionSetI self, std::set< unsigned int,std::less< unsigned int >,std::allocator< unsigned int > >::iterator __position, unsigned int const & __x) -> std::set< unsigned int,std::less< unsigned int >,std::allocator< unsigned int > >::iterator
        """
        return _eaSDIF.SelectionSetI_insert(self, *args)

    def clear(self, deactivate=True):
        r"""clear(SelectionSetI self, bool deactivate=True)"""
        return _eaSDIF.SelectionSetI_clear(self, deactivate)
    __swig_destroy__ = _eaSDIF.delete_SelectionSetI

# Register SelectionSetI in _eaSDIF:
_eaSDIF.SelectionSetI_swigregister(SelectionSetI)
class EasdifStringVector(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(EasdifStringVector self) -> SwigPyIterator"""
        return _eaSDIF.EasdifStringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(EasdifStringVector self) -> bool"""
        return _eaSDIF.EasdifStringVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(EasdifStringVector self) -> bool"""
        return _eaSDIF.EasdifStringVector___bool__(self)

    def __len__(self):
        r"""__len__(EasdifStringVector self) -> std::vector< std::string >::size_type"""
        return _eaSDIF.EasdifStringVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(EasdifStringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> EasdifStringVector"""
        return _eaSDIF.EasdifStringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(EasdifStringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        __setslice__(EasdifStringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, EasdifStringVector v)
        """
        return _eaSDIF.EasdifStringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(EasdifStringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _eaSDIF.EasdifStringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(EasdifStringVector self, std::vector< std::string >::difference_type i)
        __delitem__(EasdifStringVector self, SWIGPY_SLICEOBJECT * slice)
        """
        return _eaSDIF.EasdifStringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(EasdifStringVector self, SWIGPY_SLICEOBJECT * slice) -> EasdifStringVector
        __getitem__(EasdifStringVector self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _eaSDIF.EasdifStringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(EasdifStringVector self, SWIGPY_SLICEOBJECT * slice, EasdifStringVector v)
        __setitem__(EasdifStringVector self, SWIGPY_SLICEOBJECT * slice)
        __setitem__(EasdifStringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _eaSDIF.EasdifStringVector___setitem__(self, *args)

    def pop(self):
        r"""pop(EasdifStringVector self) -> std::vector< std::string >::value_type"""
        return _eaSDIF.EasdifStringVector_pop(self)

    def append(self, x):
        r"""append(EasdifStringVector self, std::vector< std::string >::value_type const & x)"""
        return _eaSDIF.EasdifStringVector_append(self, x)

    def empty(self):
        r"""empty(EasdifStringVector self) -> bool"""
        return _eaSDIF.EasdifStringVector_empty(self)

    def size(self):
        r"""size(EasdifStringVector self) -> std::vector< std::string >::size_type"""
        return _eaSDIF.EasdifStringVector_size(self)

    def swap(self, v):
        r"""swap(EasdifStringVector self, EasdifStringVector v)"""
        return _eaSDIF.EasdifStringVector_swap(self, v)

    def begin(self):
        r"""begin(EasdifStringVector self) -> std::vector< std::string >::iterator"""
        return _eaSDIF.EasdifStringVector_begin(self)

    def end(self):
        r"""end(EasdifStringVector self) -> std::vector< std::string >::iterator"""
        return _eaSDIF.EasdifStringVector_end(self)

    def rbegin(self):
        r"""rbegin(EasdifStringVector self) -> std::vector< std::string >::reverse_iterator"""
        return _eaSDIF.EasdifStringVector_rbegin(self)

    def rend(self):
        r"""rend(EasdifStringVector self) -> std::vector< std::string >::reverse_iterator"""
        return _eaSDIF.EasdifStringVector_rend(self)

    def clear(self):
        r"""clear(EasdifStringVector self)"""
        return _eaSDIF.EasdifStringVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(EasdifStringVector self) -> std::vector< std::string >::allocator_type"""
        return _eaSDIF.EasdifStringVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(EasdifStringVector self)"""
        return _eaSDIF.EasdifStringVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(EasdifStringVector self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(EasdifStringVector self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _eaSDIF.EasdifStringVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(EasdifStringVector self) -> EasdifStringVector
        __init__(EasdifStringVector self, EasdifStringVector other) -> EasdifStringVector
        __init__(EasdifStringVector self, std::vector< std::string >::size_type size) -> EasdifStringVector
        __init__(EasdifStringVector self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> EasdifStringVector
        """
        _eaSDIF.EasdifStringVector_swiginit(self, _eaSDIF.new_EasdifStringVector(*args))

    def push_back(self, x):
        r"""push_back(EasdifStringVector self, std::vector< std::string >::value_type const & x)"""
        return _eaSDIF.EasdifStringVector_push_back(self, x)

    def front(self):
        r"""front(EasdifStringVector self) -> std::vector< std::string >::value_type const &"""
        return _eaSDIF.EasdifStringVector_front(self)

    def back(self):
        r"""back(EasdifStringVector self) -> std::vector< std::string >::value_type const &"""
        return _eaSDIF.EasdifStringVector_back(self)

    def assign(self, n, x):
        r"""assign(EasdifStringVector self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _eaSDIF.EasdifStringVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(EasdifStringVector self, std::vector< std::string >::size_type new_size)
        resize(EasdifStringVector self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _eaSDIF.EasdifStringVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(EasdifStringVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(EasdifStringVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
        """
        return _eaSDIF.EasdifStringVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(EasdifStringVector self, std::vector< std::string >::size_type n)"""
        return _eaSDIF.EasdifStringVector_reserve(self, n)

    def capacity(self):
        r"""capacity(EasdifStringVector self) -> std::vector< std::string >::size_type"""
        return _eaSDIF.EasdifStringVector_capacity(self)
    __swig_destroy__ = _eaSDIF.delete_EasdifStringVector

# Register EasdifStringVector in _eaSDIF:
_eaSDIF.EasdifStringVector_swigregister(EasdifStringVector)

