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

"""

Copyright (C) 2017-2023 Basler AG
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
    1. Redistributions of source code must retain the above copyright notice,
       this list of conditions and the following disclaimer.
    2. Redistributions in binary form must reproduce the above copyright notice,
       this list of conditions and the following disclaimer in the documentation
       and/or other materials provided with the distribution.
    3. Neither the name of the copyright holder nor the names of its contributors
       may be used to endorse or promote products derived from this software
       without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

"""

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _genicam
else:
    import _genicam

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


import weakref

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _genicam:
_genicam.SwigPyIterator_swigregister(SwigPyIterator)
class ios_base(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

GenericException = _genicam.GenericException


BadAllocException = _genicam.BadAllocException


InvalidArgumentException = _genicam.InvalidArgumentException


OutOfRangeException = _genicam.OutOfRangeException


PropertyException = _genicam.PropertyException


RuntimeException = _genicam.RuntimeException


LogicalErrorException = _genicam.LogicalErrorException


AccessException = _genicam.AccessException


TimeoutException = _genicam.TimeoutException


DynamicCastException = _genicam.DynamicCastException


def TranslateGenicamException(_gcex_e):
    return _genicam.TranslateGenicamException(_gcex_e)

import warnings

Signed = _genicam.Signed
Unsigned = _genicam.Unsigned
_UndefinedSign = _genicam._UndefinedSign
NI = _genicam.NI
NA = _genicam.NA
WO = _genicam.WO
RO = _genicam.RO
RW = _genicam.RW
_UndefinedAccesMode = _genicam._UndefinedAccesMode
_CycleDetectAccesMode = _genicam._CycleDetectAccesMode
Beginner = _genicam.Beginner
Expert = _genicam.Expert
Guru = _genicam.Guru
Invisible = _genicam.Invisible
_UndefinedVisibility = _genicam._UndefinedVisibility
NoCache = _genicam.NoCache
WriteThrough = _genicam.WriteThrough
WriteAround = _genicam.WriteAround
_UndefinedCachingMode = _genicam._UndefinedCachingMode
Linear = _genicam.Linear
Logarithmic = _genicam.Logarithmic
Boolean = _genicam.Boolean
PureNumber = _genicam.PureNumber
HexNumber = _genicam.HexNumber
IPV4Address = _genicam.IPV4Address
MACAddress = _genicam.MACAddress
_UndefinedRepresentation = _genicam._UndefinedRepresentation
BigEndian = _genicam.BigEndian
LittleEndian = _genicam.LittleEndian
_UndefinedEndian = _genicam._UndefinedEndian
Custom = _genicam.Custom
Standard = _genicam.Standard
_UndefinedNameSpace = _genicam._UndefinedNameSpace
_None = _genicam._None
GEV = _genicam.GEV
IIDC = _genicam.IIDC
CL = _genicam.CL
USB = _genicam.USB
_UndefinedStandardNameSpace = _genicam._UndefinedStandardNameSpace
Yes = _genicam.Yes
No = _genicam.No
_UndefinedYesNo = _genicam._UndefinedYesNo
Increasing = _genicam.Increasing
Decreasing = _genicam.Decreasing
Varying = _genicam.Varying
Automatic = _genicam.Automatic
_UndefinedESlope = _genicam._UndefinedESlope
xvLoad = _genicam.xvLoad
xvCycles = _genicam.xvCycles
xvSFNC = _genicam.xvSFNC
xvDefault = _genicam.xvDefault
xvAll = _genicam.xvAll
_UndefinedEXMLValidation = _genicam._UndefinedEXMLValidation
fnAutomatic = _genicam.fnAutomatic
fnFixed = _genicam.fnFixed
fnScientific = _genicam.fnScientific
_UndefinedEDisplayNotation = _genicam._UndefinedEDisplayNotation
intfIValue = _genicam.intfIValue
intfIBase = _genicam.intfIBase
intfIInteger = _genicam.intfIInteger
intfIBoolean = _genicam.intfIBoolean
intfICommand = _genicam.intfICommand
intfIFloat = _genicam.intfIFloat
intfIString = _genicam.intfIString
intfIRegister = _genicam.intfIRegister
intfICategory = _genicam.intfICategory
intfIEnumeration = _genicam.intfIEnumeration
intfIEnumEntry = _genicam.intfIEnumEntry
intfIPort = _genicam.intfIPort
ctParentNodes = _genicam.ctParentNodes
ctReadingChildren = _genicam.ctReadingChildren
ctWritingChildren = _genicam.ctWritingChildren
ctInvalidatingChildren = _genicam.ctInvalidatingChildren
ctDependingNodes = _genicam.ctDependingNodes
ctTerminalNodes = _genicam.ctTerminalNodes
ctValueChangingChildren = _genicam.ctValueChangingChildren
noIncrement = _genicam.noIncrement
fixedIncrement = _genicam.fixedIncrement
listIncrement = _genicam.listIncrement
idFrom = _genicam.idFrom
idTo = _genicam.idTo
idNone = _genicam.idNone
class ESignClass(object):
    r"""


    ESignClass holds conversion methods for the sign enumeration.  

    C++ includes: EnumClasses.h

    """

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

    @staticmethod
    def FromString(ValueStr, pValue):
        r"""


        Converts a string to enum value.  

        """
        return _genicam.ESignClass_FromString(ValueStr, pValue)

    @staticmethod
    def ToString(*args):
        r"""


        Converts a string to an int32_t property.  

        """
        return _genicam.ESignClass_ToString(*args)

    def __init__(self):
        _genicam.ESignClass_swiginit(self, _genicam.new_ESignClass())
    __swig_destroy__ = _genicam.delete_ESignClass

# Register ESignClass in _genicam:
_genicam.ESignClass_swigregister(ESignClass)
class EEndianessClass(object):
    r"""


    EEndianessClass holds conversion methods for the endianess enumeration.  

    C++ includes: EnumClasses.h

    """

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

    @staticmethod
    def FromString(ValueStr, pValue):
        r"""


        Converts a string to enum value.  

        """
        return _genicam.EEndianessClass_FromString(ValueStr, pValue)

    @staticmethod
    def ToString(*args):
        r"""


        Converts a string to an int32_t property.  

        """
        return _genicam.EEndianessClass_ToString(*args)

    def __init__(self):
        _genicam.EEndianessClass_swiginit(self, _genicam.new_EEndianessClass())
    __swig_destroy__ = _genicam.delete_EEndianessClass

# Register EEndianessClass in _genicam:
_genicam.EEndianessClass_swigregister(EEndianessClass)
class ERepresentationClass(object):
    r"""


    ERepresentationClass holds conversion methods for the representation
    enumeration.  

    C++ includes: EnumClasses.h

    """

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

    @staticmethod
    def FromString(ValueStr, pValue):
        r"""


        Converts a string to enum value.  

        """
        return _genicam.ERepresentationClass_FromString(ValueStr, pValue)

    @staticmethod
    def ToString(*args):
        r"""


        Converts a string to an int32_t property.  

        """
        return _genicam.ERepresentationClass_ToString(*args)

    def __init__(self):
        _genicam.ERepresentationClass_swiginit(self, _genicam.new_ERepresentationClass())
    __swig_destroy__ = _genicam.delete_ERepresentationClass

# Register ERepresentationClass in _genicam:
_genicam.ERepresentationClass_swigregister(ERepresentationClass)
class EVisibilityClass(object):
    r"""


    EVisibilityClass holds conversion methods for the visibility enumeration.  

    C++ includes: EnumClasses.h

    """

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

    @staticmethod
    def FromString(ValueStr, pValue):
        r"""


        Converts a string to enum value.  

        """
        return _genicam.EVisibilityClass_FromString(ValueStr, pValue)

    @staticmethod
    def ToString(*args):
        r"""


        Converts a string to an int32_t property.  

        """
        return _genicam.EVisibilityClass_ToString(*args)

    def __init__(self):
        _genicam.EVisibilityClass_swiginit(self, _genicam.new_EVisibilityClass())
    __swig_destroy__ = _genicam.delete_EVisibilityClass

# Register EVisibilityClass in _genicam:
_genicam.EVisibilityClass_swigregister(EVisibilityClass)
class EAccessModeClass(object):
    r"""


    EAccessModeClass holds conversion methods for the access mode enumeration.  

    C++ includes: EnumClasses.h

    """

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

    @staticmethod
    def FromString(ValueStr, pValue):
        r"""


        Converts a string to enum value.  

        """
        return _genicam.EAccessModeClass_FromString(ValueStr, pValue)

    @staticmethod
    def ToString(*args):
        r"""


        Converts a string to an int32_t property.  

        """
        return _genicam.EAccessModeClass_ToString(*args)

    def __init__(self):
        _genicam.EAccessModeClass_swiginit(self, _genicam.new_EAccessModeClass())
    __swig_destroy__ = _genicam.delete_EAccessModeClass

# Register EAccessModeClass in _genicam:
_genicam.EAccessModeClass_swigregister(EAccessModeClass)
class ECachingModeClass(object):
    r"""


    ECachingModeClass holds conversion methods for the caching mode enumeration.  

    C++ includes: EnumClasses.h

    """

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

    @staticmethod
    def FromString(ValueStr, pValue):
        r"""


        Converts a string to enum value.  

        """
        return _genicam.ECachingModeClass_FromString(ValueStr, pValue)

    @staticmethod
    def ToString(*args):
        r"""


        Converts a string to an int32_t property.  

        """
        return _genicam.ECachingModeClass_ToString(*args)

    def __init__(self):
        _genicam.ECachingModeClass_swiginit(self, _genicam.new_ECachingModeClass())
    __swig_destroy__ = _genicam.delete_ECachingModeClass

# Register ECachingModeClass in _genicam:
_genicam.ECachingModeClass_swigregister(ECachingModeClass)
class ENameSpaceClass(object):
    r"""


    Holds conversion methods for the namespace enumeration.  

    C++ includes: EnumClasses.h

    """

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

    @staticmethod
    def FromString(ValueStr, pValue):
        r"""


        Converts a string to enum value.  

        """
        return _genicam.ENameSpaceClass_FromString(ValueStr, pValue)

    @staticmethod
    def ToString(*args):
        r"""


        Converts a string to an int32_t property.  

        """
        return _genicam.ENameSpaceClass_ToString(*args)

    def __init__(self):
        _genicam.ENameSpaceClass_swiginit(self, _genicam.new_ENameSpaceClass())
    __swig_destroy__ = _genicam.delete_ENameSpaceClass

# Register ENameSpaceClass in _genicam:
_genicam.ENameSpaceClass_swigregister(ENameSpaceClass)
class EYesNoClass(object):
    r"""


    Holds conversion methods for the standard namespace enumeration.  

    C++ includes: EnumClasses.h

    """

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

    @staticmethod
    def FromString(ValueStr, pValue):
        r"""


        Converts a string to enum value.  

        """
        return _genicam.EYesNoClass_FromString(ValueStr, pValue)

    @staticmethod
    def ToString(*args):
        r"""


        Converts a string to an int32_t property.  

        """
        return _genicam.EYesNoClass_ToString(*args)

    def __init__(self):
        _genicam.EYesNoClass_swiginit(self, _genicam.new_EYesNoClass())
    __swig_destroy__ = _genicam.delete_EYesNoClass

# Register EYesNoClass in _genicam:
_genicam.EYesNoClass_swigregister(EYesNoClass)
class EStandardNameSpaceClass(object):
    r"""


    Holds conversion methods for the standard namespace enumeration.  

    C++ includes: EnumClasses.h

    """

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

    @staticmethod
    def FromString(ValueStr, pValue):
        r"""


        Converts a string to enum value.  

        """
        return _genicam.EStandardNameSpaceClass_FromString(ValueStr, pValue)

    @staticmethod
    def ToString(*args):
        r"""


        Converts a string to an int32_t property.  

        """
        return _genicam.EStandardNameSpaceClass_ToString(*args)

    def __init__(self):
        _genicam.EStandardNameSpaceClass_swiginit(self, _genicam.new_EStandardNameSpaceClass())
    __swig_destroy__ = _genicam.delete_EStandardNameSpaceClass

# Register EStandardNameSpaceClass in _genicam:
_genicam.EStandardNameSpaceClass_swigregister(EStandardNameSpaceClass)
class ESlopeClass(object):
    r"""


    Holds conversion methods for the converter formulas.  

    C++ includes: EnumClasses.h

    """

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

    @staticmethod
    def FromString(ValueStr, pValue):
        r"""


        Converts a string to enum value.  

        """
        return _genicam.ESlopeClass_FromString(ValueStr, pValue)

    @staticmethod
    def ToString(*args):
        r"""


        Converts a string to an int32_t property.  

        """
        return _genicam.ESlopeClass_ToString(*args)

    def __init__(self):
        _genicam.ESlopeClass_swiginit(self, _genicam.new_ESlopeClass())
    __swig_destroy__ = _genicam.delete_ESlopeClass

# Register ESlopeClass in _genicam:
_genicam.ESlopeClass_swigregister(ESlopeClass)
class EDisplayNotationClass(object):
    r"""


    Holds conversion methods for the notation type of floats.  

    C++ includes: EnumClasses.h

    """

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

    @staticmethod
    def FromString(ValueStr, pValue):
        r"""


        Converts a string to enum value.  

        """
        return _genicam.EDisplayNotationClass_FromString(ValueStr, pValue)

    @staticmethod
    def ToString(*args):
        r"""


        Converts a string to an int32_t property.  

        """
        return _genicam.EDisplayNotationClass_ToString(*args)

    def __init__(self):
        _genicam.EDisplayNotationClass_swiginit(self, _genicam.new_EDisplayNotationClass())
    __swig_destroy__ = _genicam.delete_EDisplayNotationClass

# Register EDisplayNotationClass in _genicam:
_genicam.EDisplayNotationClass_swigregister(EDisplayNotationClass)
class EInputDirectionClass(object):
    r"""


    Holds conversion methods for the notation type of floats.  

    C++ includes: EnumClasses.h

    """

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

    @staticmethod
    def FromString(ValueStr, pValue):
        r"""


        Converts a string to enum value.  

        """
        return _genicam.EInputDirectionClass_FromString(ValueStr, pValue)

    @staticmethod
    def ToString(*args):
        r"""


        Converts a string to an int32_t property.  

        """
        return _genicam.EInputDirectionClass_ToString(*args)

    def __init__(self):
        _genicam.EInputDirectionClass_swiginit(self, _genicam.new_EInputDirectionClass())
    __swig_destroy__ = _genicam.delete_EInputDirectionClass

# Register EInputDirectionClass in _genicam:
_genicam.EInputDirectionClass_swigregister(EInputDirectionClass)
class Version(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Major = property(_genicam.Version_Major_get, _genicam.Version_Major_set)
    Minor = property(_genicam.Version_Minor_get, _genicam.Version_Minor_set)
    SubMinor = property(_genicam.Version_SubMinor_get, _genicam.Version_SubMinor_set)

    def __init__(self):
        _genicam.Version_swiginit(self, _genicam.new_Version())
    __swig_destroy__ = _genicam.delete_Version

# Register Version in _genicam:
_genicam.Version_swigregister(Version)
class IBase(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

    def GetAccessMode(self):
        return _genicam.IBase_GetAccessMode(self)

# Register IBase in _genicam:
_genicam.IBase_swigregister(IBase)
class INode(IBase):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def GetName(self, FullQualified=False):
        return _genicam.INode_GetName(self, FullQualified)
    Name = property(GetName) 

    def GetNameSpace(self):
        return _genicam.INode_GetNameSpace(self)
    NameSpace = property(GetNameSpace) 

    def GetVisibility(self):
        return _genicam.INode_GetVisibility(self)
    Visibility = property(GetVisibility) 

    def InvalidateNode(self):
        return _genicam.INode_InvalidateNode(self)

    def IsCachable(self):
        return _genicam.INode_IsCachable(self)

    def IsAccessModeCacheable(self):
        return _genicam.INode_IsAccessModeCacheable(self)

    def GetCachingMode(self):
        return _genicam.INode_GetCachingMode(self)
    CachingMode = property(GetCachingMode) 

    def GetPollingTime(self):
        return _genicam.INode_GetPollingTime(self)
    PollingTime = property(GetPollingTime) 

    def GetToolTip(self):
        return _genicam.INode_GetToolTip(self)
    ToolTip = property(GetToolTip) 

    def GetDescription(self):
        return _genicam.INode_GetDescription(self)
    Description = property(GetDescription) 

    def GetDisplayName(self):
        return _genicam.INode_GetDisplayName(self)
    DisplayName = property(GetDisplayName) 

    def GetDeviceName(self):
        return _genicam.INode_GetDeviceName(self)
    DeviceName = property(GetDeviceName) 

    def GetChildren(self, *args):
        return _genicam.INode_GetChildren(self, *args)
    Children = property(GetChildren) 

    def GetParents(self):
        return _genicam.INode_GetParents(self)
    Parents = property(GetParents) 

    def RegisterCallback(self, INPUT):
        return _genicam.INode_RegisterCallback(self, INPUT)

    def DeregisterCallback(self, hCallback):
        return _genicam.INode_DeregisterCallback(self, hCallback)

    def GetNodeMap(self):
        return _genicam.INode_GetNodeMap(self)
    NodeMap = property(GetNodeMap) 

    def GetEventID(self):
        return _genicam.INode_GetEventID(self)
    EventID = property(GetEventID) 

    def IsStreamable(self):
        return _genicam.INode_IsStreamable(self)

    def GetPropertyNames(self):
        return _genicam.INode_GetPropertyNames(self)
    PropertyNames = property(GetPropertyNames) 

    def GetProperty(self, PropertyName):
        return _genicam.INode_GetProperty(self, PropertyName)

    def ImposeAccessMode(self, ImposedAccessMode):
        return _genicam.INode_ImposeAccessMode(self, ImposedAccessMode)

    def ImposeVisibility(self, ImposedVisibility):
        return _genicam.INode_ImposeVisibility(self, ImposedVisibility)

    def GetAlias(self):
        return _genicam.INode_GetAlias(self)
    Alias = property(GetAlias) 

    def GetCastAlias(self):
        return _genicam.INode_GetCastAlias(self)
    CastAlias = property(GetCastAlias) 

    def GetDocuURL(self):
        return _genicam.INode_GetDocuURL(self)
    DocuURL = property(GetDocuURL) 

    def IsDeprecated(self):
        return _genicam.INode_IsDeprecated(self)

    def GetPrincipalInterfaceType(self):
        return _genicam.INode_GetPrincipalInterfaceType(self)
    PrincipalInterfaceType = property(GetPrincipalInterfaceType) 

    def IsFeature(self):
        return _genicam.INode_IsFeature(self)

    def IsSelector(self):
        return _genicam.INode_IsSelector(self)

    def GetSelectedFeatures(self):
        return _genicam.INode_GetSelectedFeatures(self)

    def GetSelectingFeatures(self):
        return _genicam.INode_GetSelectingFeatures(self)

# Register INode in _genicam:
_genicam.INode_swigregister(INode)

def IsReadable(*args):
    r"""


    Checks if a node is readable.  

    """
    return _genicam.IsReadable(*args)

def IsWritable(*args):
    r"""


    Checks if a node is Writable.  

    """
    return _genicam.IsWritable(*args)

def IsImplemented(*args):
    r"""


    Checks if a node is Implemented.  

    """
    return _genicam.IsImplemented(*args)

def IsAvailable(*args):
    r"""


    Checks if a node is Available.  

    """
    return _genicam.IsAvailable(*args)

def Combine(Peter, Paul):
    r"""


    Computes which CachingMode results from a combination.  

    """
    return _genicam.Combine(Peter, Paul)

def IsVisible(Visibility, MaxVisiblity):
    r"""


    Tests Visibility.  

    CAVE : this relys on the EVisibility enum's coding  

    """
    return _genicam.IsVisible(Visibility, MaxVisiblity)

def CombineVisibility(Peter, Paul):
    r"""


    Computes which CachingMode results from a combination.  

    """
    return _genicam.CombineVisibility(Peter, Paul)

def IsCacheable(CachingMode):
    r"""


    Tests Cacheability.  

    """
    return _genicam.IsCacheable(CachingMode)

def CombineCachingMode(Peter, Paul):
    r"""


    Computes which CachingMode results from a combination.  

    """
    return _genicam.CombineCachingMode(Peter, Paul)
class INodeMap(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

    def GetNodes(self):
        return _genicam.INodeMap_GetNodes(self)

    def GetNode(self, Name):
        return _genicam.INodeMap_GetNode(self, Name)

    def InvalidateNodes(self):
        return _genicam.INodeMap_InvalidateNodes(self)

    def Connect(self, *args):
        return _genicam.INodeMap_Connect(self, *args)

    def GetDeviceName(self):
        return _genicam.INodeMap_GetDeviceName(self)

    def Poll(self, ElapsedTime):
        return _genicam.INodeMap_Poll(self, ElapsedTime)

    def GetLock(self):
        return _genicam.INodeMap_GetLock(self)

    def GetNumNodes(self):
        return _genicam.INodeMap_GetNumNodes(self)

    def ParseSwissKnifes(self, pErrorList=None):
        return _genicam.INodeMap_ParseSwissKnifes(self, pErrorList)
    DeviceName = property(GetDeviceName) 

    def GetDeviceInfo(self):
        return _genicam.INodeMap_GetDeviceInfo(self)
    DeviceInfo = property(GetDeviceInfo) 

    def __getattr__(self, attribute):
        if attribute in self.__dict__ or attribute in ( "thisown","this") or attribute.startswith("__"):
            return object.__getattr__(self, attribute)
        else:
            return self.GetNode(attribute)

    def __setattr__(self, attribute, val):
        if attribute in self.__dict__ or attribute in ( "thisown","this") or attribute.startswith("__"):
            object.__setattr__(self, attribute, val)
        else:
            warnings.warn(f"Setting a feature value by direct assignment is deprecated. Use <nodemap>.{attribute}.Value = {val}", DeprecationWarning, stacklevel=2)
            self.GetNode(attribute).SetValue(val)

    def __dir__(self):
        l = dir(type(self))
        l.extend(self.__dict__.keys())
        nodes = []
        try:
            nodes = self.GetNodeMap().GetNodes()
            features = filter(lambda n: n.GetNode().IsFeature(), nodes)
            l.extend(x.GetNode().GetName() for x in features)
        except:
            pass
        try:
            chunks = filter(lambda n: "ChunkData" in (f.Name for f in n.GetParents()), nodes)
            l.extend(x.GetNode().GetName() for x in chunks)
        except:
            pass
        return sorted(set(l))


# Register INodeMap in _genicam:
_genicam.INodeMap_swigregister(INodeMap)
cbPostInsideLock = _genicam.cbPostInsideLock
cbPostOutsideLock = _genicam.cbPostOutsideLock
class PyNodeCallback(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, pNode, PyFunc, CallbackType):
        _genicam.PyNodeCallback_swiginit(self, _genicam.new_PyNodeCallback(pNode, PyFunc, CallbackType))
    __swig_destroy__ = _genicam.delete_PyNodeCallback

    def GetNode(self):
        return _genicam.PyNodeCallback_GetNode(self)

# Register PyNodeCallback in _genicam:
_genicam.PyNodeCallback_swigregister(PyNodeCallback)

def Register(node, callback_fun, callback_type=cbPostInsideLock):
    assert callback_type in ( cbPostOutsideLock, cbPostInsideLock)
    cb = PyNodeCallback(node, callback_fun, callback_type)
    cb.thisown = 0
    return node.RegisterCallback(cb)



def Deregister(pCallbackInfo):
    r"""


    Unregistering callback by handle.  

    """
    return _genicam.Deregister(pCallbackInfo)
class IValue(IBase):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def GetNode(self):
        return _genicam.IValue_GetNode(self)

    def ToString(self, Verify=False, IgnoreCache=False):
        return _genicam.IValue_ToString(self, Verify, IgnoreCache)

    def FromString(self, ValueStr, Verify=True):
        return _genicam.IValue_FromString(self, ValueStr, Verify)

    def IsValueCacheValid(self):
        return _genicam.IValue_IsValueCacheValid(self)
    Node = property(GetNode) 

# Register IValue in _genicam:
_genicam.IValue_swigregister(IValue)
class node_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 _genicam.node_vector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _genicam.node_vector___nonzero__(self)

    def __bool__(self):
        return _genicam.node_vector___bool__(self)

    def __len__(self):
        return _genicam.node_vector___len__(self)

    def __getslice__(self, i, j):
        return _genicam.node_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _genicam.node_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _genicam.node_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _genicam.node_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _genicam.node_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _genicam.node_vector___setitem__(self, *args)

    def pop(self):
        return _genicam.node_vector_pop(self)

    def append(self, x):
        return _genicam.node_vector_append(self, x)

    def empty(self):
        return _genicam.node_vector_empty(self)

    def size(self):
        return _genicam.node_vector_size(self)

    def swap(self, v):
        return _genicam.node_vector_swap(self, v)

    def begin(self):
        return _genicam.node_vector_begin(self)

    def end(self):
        return _genicam.node_vector_end(self)

    def rbegin(self):
        return _genicam.node_vector_rbegin(self)

    def rend(self):
        return _genicam.node_vector_rend(self)

    def clear(self):
        return _genicam.node_vector_clear(self)

    def get_allocator(self):
        return _genicam.node_vector_get_allocator(self)

    def pop_back(self):
        return _genicam.node_vector_pop_back(self)

    def erase(self, *args):
        return _genicam.node_vector_erase(self, *args)

    def __init__(self, *args):
        _genicam.node_vector_swiginit(self, _genicam.new_node_vector(*args))

    def push_back(self, x):
        return _genicam.node_vector_push_back(self, x)

    def front(self):
        return _genicam.node_vector_front(self)

    def back(self):
        return _genicam.node_vector_back(self)

    def assign(self, n, x):
        return _genicam.node_vector_assign(self, n, x)

    def resize(self, *args):
        return _genicam.node_vector_resize(self, *args)

    def insert(self, *args):
        return _genicam.node_vector_insert(self, *args)

    def reserve(self, n):
        return _genicam.node_vector_reserve(self, n)

    def capacity(self):
        return _genicam.node_vector_capacity(self)
    __swig_destroy__ = _genicam.delete_node_vector

# Register node_vector in _genicam:
_genicam.node_vector_swigregister(node_vector)
class value_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 _genicam.value_vector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _genicam.value_vector___nonzero__(self)

    def __bool__(self):
        return _genicam.value_vector___bool__(self)

    def __len__(self):
        return _genicam.value_vector___len__(self)

    def __getslice__(self, i, j):
        return _genicam.value_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _genicam.value_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _genicam.value_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _genicam.value_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _genicam.value_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _genicam.value_vector___setitem__(self, *args)

    def pop(self):
        return _genicam.value_vector_pop(self)

    def append(self, x):
        return _genicam.value_vector_append(self, x)

    def empty(self):
        return _genicam.value_vector_empty(self)

    def size(self):
        return _genicam.value_vector_size(self)

    def swap(self, v):
        return _genicam.value_vector_swap(self, v)

    def begin(self):
        return _genicam.value_vector_begin(self)

    def end(self):
        return _genicam.value_vector_end(self)

    def rbegin(self):
        return _genicam.value_vector_rbegin(self)

    def rend(self):
        return _genicam.value_vector_rend(self)

    def clear(self):
        return _genicam.value_vector_clear(self)

    def get_allocator(self):
        return _genicam.value_vector_get_allocator(self)

    def pop_back(self):
        return _genicam.value_vector_pop_back(self)

    def erase(self, *args):
        return _genicam.value_vector_erase(self, *args)

    def __init__(self, *args):
        _genicam.value_vector_swiginit(self, _genicam.new_value_vector(*args))

    def push_back(self, x):
        return _genicam.value_vector_push_back(self, x)

    def front(self):
        return _genicam.value_vector_front(self)

    def back(self):
        return _genicam.value_vector_back(self)

    def assign(self, n, x):
        return _genicam.value_vector_assign(self, n, x)

    def resize(self, *args):
        return _genicam.value_vector_resize(self, *args)

    def insert(self, *args):
        return _genicam.value_vector_insert(self, *args)

    def reserve(self, n):
        return _genicam.value_vector_reserve(self, n)

    def capacity(self):
        return _genicam.value_vector_capacity(self)
    __swig_destroy__ = _genicam.delete_value_vector

# Register value_vector in _genicam:
_genicam.value_vector_swigregister(value_vector)
class string_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 _genicam.string_vector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _genicam.string_vector___nonzero__(self)

    def __bool__(self):
        return _genicam.string_vector___bool__(self)

    def __len__(self):
        return _genicam.string_vector___len__(self)

    def __getslice__(self, i, j):
        return _genicam.string_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _genicam.string_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _genicam.string_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _genicam.string_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _genicam.string_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _genicam.string_vector___setitem__(self, *args)

    def pop(self):
        return _genicam.string_vector_pop(self)

    def append(self, x):
        return _genicam.string_vector_append(self, x)

    def empty(self):
        return _genicam.string_vector_empty(self)

    def size(self):
        return _genicam.string_vector_size(self)

    def swap(self, v):
        return _genicam.string_vector_swap(self, v)

    def begin(self):
        return _genicam.string_vector_begin(self)

    def end(self):
        return _genicam.string_vector_end(self)

    def rbegin(self):
        return _genicam.string_vector_rbegin(self)

    def rend(self):
        return _genicam.string_vector_rend(self)

    def clear(self):
        return _genicam.string_vector_clear(self)

    def get_allocator(self):
        return _genicam.string_vector_get_allocator(self)

    def pop_back(self):
        return _genicam.string_vector_pop_back(self)

    def erase(self, *args):
        return _genicam.string_vector_erase(self, *args)

    def __init__(self, *args):
        _genicam.string_vector_swiginit(self, _genicam.new_string_vector(*args))

    def push_back(self, x):
        return _genicam.string_vector_push_back(self, x)

    def front(self):
        return _genicam.string_vector_front(self)

    def back(self):
        return _genicam.string_vector_back(self)

    def assign(self, n, x):
        return _genicam.string_vector_assign(self, n, x)

    def resize(self, *args):
        return _genicam.string_vector_resize(self, *args)

    def insert(self, *args):
        return _genicam.string_vector_insert(self, *args)

    def reserve(self, n):
        return _genicam.string_vector_reserve(self, n)

    def capacity(self):
        return _genicam.string_vector_capacity(self)
    __swig_destroy__ = _genicam.delete_string_vector

# Register string_vector in _genicam:
_genicam.string_vector_swigregister(string_vector)
class IPort(IBase):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def Read(self, Address, pBuffer):
        return _genicam.IPort_Read(self, Address, pBuffer)

    def Write(self, Address, pBuffer):
        return _genicam.IPort_Write(self, Address, pBuffer)

    def GetNode(self):
        return _genicam.IPort_GetNode(self)

    def GetChunkID(self):
        return _genicam.IPort_GetChunkID(self)

    def CacheChunkData(self):
        return _genicam.IPort_CacheChunkData(self)

    def GetSwapEndianess(self):
        return _genicam.IPort_GetSwapEndianess(self)
    Node = property(GetNode) 
    ChunkID = property(GetChunkID) 

# Register IPort in _genicam:
_genicam.IPort_swigregister(IPort)
CHUNK_BASE_ADDRESS_REGISTER_LEN = _genicam.CHUNK_BASE_ADDRESS_REGISTER_LEN
CHUNK_LENGTH_REGISTER_LEN = _genicam.CHUNK_LENGTH_REGISTER_LEN
class IChunkPort(IPort):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def GetChunkID(self):
        return _genicam.IChunkPort_GetChunkID(self)

    def CacheChunkData(self):
        return _genicam.IChunkPort_CacheChunkData(self)

# Register IChunkPort in _genicam:
_genicam.IChunkPort_swigregister(IChunkPort)
class IPortConstruct(IPort):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def GetSwapEndianess(self):
        return _genicam.IPortConstruct_GetSwapEndianess(self)

# Register IPortConstruct in _genicam:
_genicam.IPortConstruct_swigregister(IPortConstruct)
class IPortWriteList(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

    def Write(self, pBuffer, Address, Length):
        return _genicam.IPortWriteList_Write(self, pBuffer, Address, Length)

    def Replay(self, pPort):
        return _genicam.IPortWriteList_Replay(self, pPort)

    def SetCookie(self, Value):
        return _genicam.IPortWriteList_SetCookie(self, Value)

    def GetCookie(self):
        return _genicam.IPortWriteList_GetCookie(self)

# Register IPortWriteList in _genicam:
_genicam.IPortWriteList_swigregister(IPortWriteList)
class IPortReplay(IPort):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def Replay(self, pPortRecorder, Invalidate=True):
        return _genicam.IPortReplay_Replay(self, pPortRecorder, Invalidate)

# Register IPortReplay in _genicam:
_genicam.IPortReplay_swigregister(IPortReplay)
class IPortRecorder(IPortReplay):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def StartRecording(self, pPortRecorder):
        return _genicam.IPortRecorder_StartRecording(self, pPortRecorder)

    def StopRecording(self):
        return _genicam.IPortRecorder_StopRecording(self)

# Register IPortRecorder in _genicam:
_genicam.IPortRecorder_swigregister(IPortRecorder)
class CPortImpl(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        if self.__class__ == CPortImpl:
            _self = None
        else:
            _self = self
        _genicam.CPortImpl_swiginit(self, _genicam.new_CPortImpl(_self, ))
    __swig_destroy__ = _genicam.delete_CPortImpl

    def GetAccessMode(self):
        r"""


        Get the access mode of the node.  

        Driver closed => NI, Driver open => RW, analysing a struct, RO  

        """
        return _genicam.CPortImpl_GetAccessMode(self)

    def Read(self, Address, pBuffer):
        return _genicam.CPortImpl_Read(self, Address, pBuffer)

    def Write(self, Address, pBuffer):
        return _genicam.CPortImpl_Write(self, Address, pBuffer)

    def InvalidateNode(self):
        r"""


        """
        return _genicam.CPortImpl_InvalidateNode(self)
    def __disown__(self):
        self.this.disown()
        _genicam.disown_CPortImpl(self)
        return weakref.proxy(self)

# Register CPortImpl in _genicam:
_genicam.CPortImpl_swigregister(CPortImpl)
class IDeviceInfo(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

    def GetModelName(self):
        return _genicam.IDeviceInfo_GetModelName(self)

    def GetVendorName(self):
        return _genicam.IDeviceInfo_GetVendorName(self)

    def GetToolTip(self):
        return _genicam.IDeviceInfo_GetToolTip(self)

    def GetStandardNameSpace(self):
        return _genicam.IDeviceInfo_GetStandardNameSpace(self)

    def GetGenApiVersion(self):
        return _genicam.IDeviceInfo_GetGenApiVersion(self)

    def GetSchemaVersion(self):
        return _genicam.IDeviceInfo_GetSchemaVersion(self)

    def GetDeviceVersion(self):
        return _genicam.IDeviceInfo_GetDeviceVersion(self)

    def GetProductGuid(self):
        return _genicam.IDeviceInfo_GetProductGuid(self)

    def GetVersionGuid(self):
        return _genicam.IDeviceInfo_GetVersionGuid(self)

# Register IDeviceInfo in _genicam:
_genicam.IDeviceInfo_swigregister(IDeviceInfo)
class CNodeMapRef(object):
    r"""


    Smartpointer for NodeMaps with create function.  

    note: This class is a simple typedef definition. The class syntax is only used,
        because Doxygen has to generate a useful documentation.  

    C++ includes: NodeMapRef.h

    """

    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"""


        Copy constructor.  

        """
        _genicam.CNodeMapRef_swiginit(self, _genicam.new_CNodeMapRef(*args))
    __swig_destroy__ = _genicam.delete_CNodeMapRef

    def _LoadXMLFromFile(self, FileName):
        return _genicam.CNodeMapRef__LoadXMLFromFile(self, FileName)

    def _LoadXMLFromString(self, XMLData):
        return _genicam.CNodeMapRef__LoadXMLFromString(self, XMLData)

    def _GetDeviceName(self):
        return _genicam.CNodeMapRef__GetDeviceName(self)

    def _Poll(self, ElapsedTime):
        return _genicam.CNodeMapRef__Poll(self, ElapsedTime)

    def _Destroy(self):
        return _genicam.CNodeMapRef__Destroy(self)

    @staticmethod
    def _ClearXMLCache():
        return _genicam.CNodeMapRef__ClearXMLCache()

    def _GetNodes(self):
        return _genicam.CNodeMapRef__GetNodes(self)

    def _GetNode(self, key):
        return _genicam.CNodeMapRef__GetNode(self, key)

    def GetNode(self, key):
        return _genicam.CNodeMapRef_GetNode(self, key)

    def _InvalidateNodes(self):
        return _genicam.CNodeMapRef__InvalidateNodes(self)

    def _Connect(self, *args):
        return _genicam.CNodeMapRef__Connect(self, *args)
    _Ptr = property(_genicam.CNodeMapRef__Ptr_get, _genicam.CNodeMapRef__Ptr_set)

    def GetDeviceInfo(self):
        return _genicam.CNodeMapRef_GetDeviceInfo(self)
    DeviceInfo = property(GetDeviceInfo) 

    def __getattr__(self, attribute):
        if attribute in self.__dict__ or attribute in ( "thisown","this") or attribute.startswith("__"):
            return object.__getattr__(self, attribute)
        else:
            return self.GetNode(attribute)

    def __setattr__(self, attribute, val):
        if attribute in self.__dict__ or attribute in ( "thisown","this") or attribute.startswith("__"):
            object.__setattr__(self, attribute, val)
        else:
            warnings.warn(f"Setting a feature value by direct assignment is deprecated. Use <nodemap>.{attribute}.Value = {val}", DeprecationWarning, stacklevel=2)
            self.GetNode(attribute).SetValue(val)

    def __dir__(self):
        l = []
        l += [x for x in dir(type(self))]
        l += [x for x in self.__dict__.keys()]
        try:
            l += [x.GetNode().GetName() for x in filter(lambda n: n.GetNode().IsFeature(), self.GetNodeMap().GetNodes())]
        except:
            pass
        return sorted(set(l))


# Register CNodeMapRef in _genicam:
_genicam.CNodeMapRef_swigregister(CNodeMapRef)
class IFloat(IValue):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def SetValue(self, Value, Verify=True):
        return _genicam.IFloat_SetValue(self, Value, Verify)

    def GetValue(self, Verify=False, IgnoreCache=False):
        return _genicam.IFloat_GetValue(self, Verify, IgnoreCache)

    def __call__(self):
        return _genicam.IFloat___call__(self)

    def GetMin(self):
        return _genicam.IFloat_GetMin(self)

    def GetMax(self):
        return _genicam.IFloat_GetMax(self)

    def HasInc(self):
        return _genicam.IFloat_HasInc(self)

    def GetIncMode(self):
        return _genicam.IFloat_GetIncMode(self)

    def GetInc(self):
        return _genicam.IFloat_GetInc(self)

    def GetListOfValidValues(self, bounded=True):
        return _genicam.IFloat_GetListOfValidValues(self, bounded)

    def GetRepresentation(self):
        return _genicam.IFloat_GetRepresentation(self)

    def GetUnit(self):
        return _genicam.IFloat_GetUnit(self)

    def GetDisplayNotation(self):
        return _genicam.IFloat_GetDisplayNotation(self)

    def GetDisplayPrecision(self):
        return _genicam.IFloat_GetDisplayPrecision(self)

    def ImposeMin(self, Value):
        return _genicam.IFloat_ImposeMin(self, Value)

    def ImposeMax(self, Value):
        return _genicam.IFloat_ImposeMax(self, Value)

    def GetIntAlias(self):
        return _genicam.IFloat_GetIntAlias(self)

    def GetEnumAlias(self):
        return _genicam.IFloat_GetEnumAlias(self)
    Value = property(GetValue,SetValue) 
    Min = property(GetMin) 
    Max = property(GetMax) 
    IncMode = property(GetIncMode) 
    Inc = property(GetInc) 
    ListOfValidValues = property(GetListOfValidValues) 
    Representation = property(GetRepresentation) 
    Unit = property(GetUnit) 
    DisplayNotation = property(GetDisplayNotation) 
    DisplayPrecision = property(GetDisplayPrecision) 
    IntAlias = property(GetIntAlias) 
    EnumAlias = property(GetEnumAlias) 

# Register IFloat in _genicam:
_genicam.IFloat_swigregister(IFloat)
class IInteger(IValue):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def SetValue(self, Value, Verify=True):
        return _genicam.IInteger_SetValue(self, Value, Verify)

    def GetValue(self, Verify=False, IgnoreCache=False):
        return _genicam.IInteger_GetValue(self, Verify, IgnoreCache)

    def __call__(self):
        return _genicam.IInteger___call__(self)

    def GetMin(self):
        return _genicam.IInteger_GetMin(self)

    def GetMax(self):
        return _genicam.IInteger_GetMax(self)

    def GetIncMode(self):
        return _genicam.IInteger_GetIncMode(self)

    def GetInc(self):
        return _genicam.IInteger_GetInc(self)

    def GetListOfValidValues(self, bounded=True):
        return _genicam.IInteger_GetListOfValidValues(self, bounded)

    def GetRepresentation(self):
        return _genicam.IInteger_GetRepresentation(self)

    def GetUnit(self):
        return _genicam.IInteger_GetUnit(self)

    def ImposeMin(self, Value):
        return _genicam.IInteger_ImposeMin(self, Value)

    def ImposeMax(self, Value):
        return _genicam.IInteger_ImposeMax(self, Value)

    def GetFloatAlias(self):
        return _genicam.IInteger_GetFloatAlias(self)

    def Set(self, pBuffer, Verify=True):
        return _genicam.IInteger_Set(self, pBuffer, Verify)

    def Get(self, pBuffer, Verify=False, IgnoreCache=False):
        return _genicam.IInteger_Get(self, pBuffer, Verify, IgnoreCache)

    def GetLength(self):
        return _genicam.IInteger_GetLength(self)

    def GetAddress(self):
        return _genicam.IInteger_GetAddress(self)
    Value = property(GetValue,SetValue) 
    Min = property(GetMin) 
    Max = property(GetMax) 
    IncMode = property(GetIncMode) 
    Inc = property(GetInc) 
    ListOfValidValues = property(GetListOfValidValues) 
    Representation = property(GetRepresentation) 
    Unit = property(GetUnit) 
    FloatAlias = property(GetFloatAlias) 
    Address = property(GetAddress) 
    Length = property(GetLength) 

# Register IInteger in _genicam:
_genicam.IInteger_swigregister(IInteger)
class IRegister(IValue):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def Set(self, pBuffer, Verify=True):
        return _genicam.IRegister_Set(self, pBuffer, Verify)

    def Get(self, pBuffer, Verify=False, IgnoreCache=False):
        return _genicam.IRegister_Get(self, pBuffer, Verify, IgnoreCache)

    def GetLength(self):
        return _genicam.IRegister_GetLength(self)

    def GetAddress(self):
        return _genicam.IRegister_GetAddress(self)
    Length = property(GetLength) 
    Address = property(GetAddress) 

# Register IRegister in _genicam:
_genicam.IRegister_swigregister(IRegister)

def GetAll(self):
    return self.Get(self.GetLength())
IRegister.GetAll = GetAll

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

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

    def GetValue(self):
        return _genicam.IEnumEntry_GetValue(self)

    def GetSymbolic(self):
        return _genicam.IEnumEntry_GetSymbolic(self)

    def GetNumericValue(self):
        return _genicam.IEnumEntry_GetNumericValue(self)

    def IsSelfClearing(self):
        return _genicam.IEnumEntry_IsSelfClearing(self)
    Value = property(GetValue) 
    Symbolic = property(GetSymbolic) 
    NumericValue = property(GetNumericValue) 

    def __call__( self ):
        return self.GetValue()


# Register IEnumEntry in _genicam:
_genicam.IEnumEntry_swigregister(IEnumEntry)
class IEnumeration(IValue):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def GetSymbolics(self):
        return _genicam.IEnumeration_GetSymbolics(self)

    def GetEntries(self):
        return _genicam.IEnumeration_GetEntries(self)

    def SetIntValue(self, Value, Verify=True):
        return _genicam.IEnumeration_SetIntValue(self, Value, Verify)

    def GetIntValue(self, Verify=False, IgnoreCache=False):
        return _genicam.IEnumeration_GetIntValue(self, Verify, IgnoreCache)

    def GetEntryByName(self, Symbolic):
        return _genicam.IEnumeration_GetEntryByName(self, Symbolic)

    def GetEntry(self, IntValue):
        return _genicam.IEnumeration_GetEntry(self, IntValue)

    def GetCurrentEntry(self, Verify=False, IgnoreCache=False):
        return _genicam.IEnumeration_GetCurrentEntry(self, Verify, IgnoreCache)

    def __call__(self):
        return _genicam.IEnumeration___call__(self)

    def GetValue(self):
        return _genicam.IEnumeration_GetValue(self)

    def SetValue(self, entry):
        return _genicam.IEnumeration_SetValue(self, entry)
    Symbolics = property(GetSymbolics) 
    Entries = property(GetEntries) 
    IntValue = property(GetIntValue,SetIntValue) 
    Value = property(GetValue,SetValue) 

# Register IEnumeration in _genicam:
_genicam.IEnumeration_swigregister(IEnumeration)
class IBoolean(IValue):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def SetValue(self, Value, Verify=True):
        return _genicam.IBoolean_SetValue(self, Value, Verify)

    def GetValue(self, Verify=False, IgnoreCache=False):
        return _genicam.IBoolean_GetValue(self, Verify, IgnoreCache)

    def __call__(self):
        return _genicam.IBoolean___call__(self)
    Value = property(GetValue,SetValue) 

# Register IBoolean in _genicam:
_genicam.IBoolean_swigregister(IBoolean)
class ICommand(IValue):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def Execute(self, Verify=True):
        return _genicam.ICommand_Execute(self, Verify)

    def __call__(self):
        return _genicam.ICommand___call__(self)

    def IsDone(self, Verify=True):
        return _genicam.ICommand_IsDone(self, Verify)

# Register ICommand in _genicam:
_genicam.ICommand_swigregister(ICommand)
class IString(IValue):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def SetValue(self, Value, Verify=True):
        return _genicam.IString_SetValue(self, Value, Verify)

    def GetValue(self, Verify=False, IgnoreCache=False):
        return _genicam.IString_GetValue(self, Verify, IgnoreCache)

    def __call__(self):
        return _genicam.IString___call__(self)

    def GetMaxLength(self):
        return _genicam.IString_GetMaxLength(self)

    def GetLength(self):
        return _genicam.IString_GetLength(self)
    Value = property(GetValue,SetValue) 
    MaxLength = property(GetMaxLength) 
    Length = property(GetLength) 

# Register IString in _genicam:
_genicam.IString_swigregister(IString)
class ICategory(IValue):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def GetFeatures(self):
        return _genicam.ICategory_GetFeatures(self)
    Features = property(GetFeatures) 

# Register ICategory in _genicam:
_genicam.ICategory_swigregister(ICategory)
class IReference(object):
    r"""


    """

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

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

    def SetReference(self, pBase):
        return _genicam.IReference_SetReference(self, pBase)

# Register IReference in _genicam:
_genicam.IReference_swigregister(IReference)
class IEnumReference(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

    def SetEnumReference(self, Index, Name):
        return _genicam.IEnumReference_SetEnumReference(self, Index, Name)

    def SetNumEnums(self, NumEnums):
        return _genicam.IEnumReference_SetNumEnums(self, NumEnums)

# Register IEnumReference in _genicam:
_genicam.IEnumReference_swigregister(IEnumReference)
class ISelector(IBase):
    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

# Register ISelector in _genicam:
_genicam.ISelector_swigregister(ISelector)
class ISelectorDigit(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

    def SetFirst(self):
        return _genicam.ISelectorDigit_SetFirst(self)

    def SetNext(self, Tick=True):
        return _genicam.ISelectorDigit_SetNext(self, Tick)

    def Restore(self):
        return _genicam.ISelectorDigit_Restore(self)

    def ToString(self):
        return _genicam.ISelectorDigit_ToString(self)

    def GetSelectorList(self, Incremental=False):
        return _genicam.ISelectorDigit_GetSelectorList(self, Incremental)

# Register ISelectorDigit in _genicam:
_genicam.ISelectorDigit_swigregister(ISelectorDigit)
class CSelectorSet(ISelectorDigit):
    r"""


    The set of selectors selecting a given node.  

    C++ includes: SelectorSet.h

    """

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

    def __init__(self, pBase):
        r"""


        Constructor.  

        """
        _genicam.CSelectorSet_swiginit(self, _genicam.new_CSelectorSet(pBase))
    __swig_destroy__ = _genicam.delete_CSelectorSet

    def IsEmpty(self):
        r"""


        returns true if no selectors are present  

        """
        return _genicam.CSelectorSet_IsEmpty(self)

    def SetFirst(self):
        r"""


        """
        return _genicam.CSelectorSet_SetFirst(self)

    def SetNext(self, Tick=True):
        r"""


        """
        return _genicam.CSelectorSet_SetNext(self, Tick)

    def Restore(self):
        r"""


        """
        return _genicam.CSelectorSet_Restore(self)

    def ToString(self):
        r"""


        """
        return _genicam.CSelectorSet_ToString(self)

    def GetSelectorList(self, Incremental=False):
        r"""


        """
        return _genicam.CSelectorSet_GetSelectorList(self, Incremental)

# Register CSelectorSet in _genicam:
_genicam.CSelectorSet_swigregister(CSelectorSet)
class ChunkPort(IPortConstruct):
    r"""


    Port attachable to a chunk in a buffer.  

    C++ includes: ChunkPort.h

    """

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

    def __init__(self, pPort=None):
        r"""


        Constructor; can attach to a port.  

        """
        _genicam.ChunkPort_swiginit(self, _genicam.new_ChunkPort(pPort))
    __swig_destroy__ = _genicam.delete_ChunkPort

    def GetAccessMode(self):
        r"""


        Get the access mode of the node.  

        """
        return _genicam.ChunkPort_GetAccessMode(self)

    def GetPrincipalInterfaceType(self):
        r"""


        Get the type of the main interface of a node.  

        """
        return _genicam.ChunkPort_GetPrincipalInterfaceType(self)

    def Read(self, pBuffer, Address, Length):
        r"""


        Reads a chunk of bytes from the port.  

        """
        return _genicam.ChunkPort_Read(self, pBuffer, Address, Length)

    def Write(self, pBuffer, Address, Length):
        r"""


        Writes a chunk of bytes to the port.  

        """
        return _genicam.ChunkPort_Write(self, pBuffer, Address, Length)

    def SetPortImpl(self, pPort):
        r"""


        Called from the port node to give the chunk port a pointer to itself.  

        """
        return _genicam.ChunkPort_SetPortImpl(self, pPort)

    def GetSwapEndianess(self):
        r"""


        Determines if the port adapter must perform an endianess swap.  

        """
        return _genicam.ChunkPort_GetSwapEndianess(self)

    def InvalidateNode(self):
        r"""


        """
        return _genicam.ChunkPort_InvalidateNode(self)

    def AttachPort(self, pPort):
        r"""


        Attaches the ChunkPort to the Port.  

        """
        return _genicam.ChunkPort_AttachPort(self, pPort)

    def DetachPort(self):
        r"""


        Detaches the ChunkPort to the Port.  

        """
        return _genicam.ChunkPort_DetachPort(self)

    def AttachChunk(self, pBaseAddress, ChunkOffset, Length, Cache):
        r"""


        Attaches the Chunk to the ChunkPort.  

        """
        return _genicam.ChunkPort_AttachChunk(self, pBaseAddress, ChunkOffset, Length, Cache)

    def DetachChunk(self):
        r"""


        Detaches the Chunk from the ChunkPort.  

        """
        return _genicam.ChunkPort_DetachChunk(self)

    def GetChunkIDLength(self):
        r"""


        Gets the ChunkID length.  

        """
        return _genicam.ChunkPort_GetChunkIDLength(self)

    def CheckChunkID(self, *args):
        r"""


        Checks if a ChunkID matches, version using uint64_t ID representation.  

        """
        return _genicam.ChunkPort_CheckChunkID(self, *args)

    def UpdateBuffer(self, pBaseAddress):
        r"""


        Updates the base address of the chunk.  

        """
        return _genicam.ChunkPort_UpdateBuffer(self, pBaseAddress)

    def ClearCache(self):
        r"""


        Clears the chunk cache.  

        """
        return _genicam.ChunkPort_ClearCache(self)
    AccessMode = property(GetAccessMode) 
    PrincipalInterfaceType = property(GetPrincipalInterfaceType) 

# Register ChunkPort in _genicam:
_genicam.ChunkPort_swigregister(ChunkPort)

CChunkPort = ChunkPort

class AttachStatistics_t(object):
    r"""


    Delivers information about the attached chunks and nodes  

    C++ includes: ChunkAdapter.h

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NumChunkPorts = property(_genicam.AttachStatistics_t_NumChunkPorts_get, _genicam.AttachStatistics_t_NumChunkPorts_set)
    NumChunks = property(_genicam.AttachStatistics_t_NumChunks_get, _genicam.AttachStatistics_t_NumChunks_set)
    NumAttachedChunks = property(_genicam.AttachStatistics_t_NumAttachedChunks_get, _genicam.AttachStatistics_t_NumAttachedChunks_set)

    def __init__(self):
        _genicam.AttachStatistics_t_swiginit(self, _genicam.new_AttachStatistics_t())
    __swig_destroy__ = _genicam.delete_AttachStatistics_t

# Register AttachStatistics_t in _genicam:
_genicam.AttachStatistics_t_swigregister(AttachStatistics_t)
class ChunkAdapter(object):
    r"""


    Connects a chunked buffer to a node map.  

    C++ includes: ChunkAdapter.h

    """

    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__ = _genicam.delete_ChunkAdapter

    def AttachNodeMap(self, pNodeMap):
        r"""


        Attaches to a node map and retrieves the chunk ports.  

        """
        return _genicam.ChunkAdapter_AttachNodeMap(self, pNodeMap)

    def DetachNodeMap(self):
        r"""


        Detaches from the node map.  

        """
        return _genicam.ChunkAdapter_DetachNodeMap(self)

    def CheckBufferLayout(self, pBuffer):
        r"""


        Checks if a buffer contains chunks in a known format.  

        Implement that for a specific buffer layout  

        """
        return _genicam.ChunkAdapter_CheckBufferLayout(self, pBuffer)

    def AttachBuffer(self, pBuffer, pAttachStatistics=None):
        r"""


        Attaches a buffer to the matching ChunkPort.  

        Implement that for a specific buffer layout  

        """
        return _genicam.ChunkAdapter_AttachBuffer(self, pBuffer, pAttachStatistics)

    def DetachBuffer(self):
        r"""


        Detaches a buffer.  

        """
        return _genicam.ChunkAdapter_DetachBuffer(self)

    def UpdateBuffer(self, pBaseAddress):
        r"""


        Updates the base address of the buffer.  

        """
        return _genicam.ChunkAdapter_UpdateBuffer(self, pBaseAddress)

    def ClearCaches(self):
        r"""


        Clears the chunk caches.  

        """
        return _genicam.ChunkAdapter_ClearCaches(self)

# Register ChunkAdapter in _genicam:
_genicam.ChunkAdapter_swigregister(ChunkAdapter)

CChunkAdapter = ChunkAdapter

class GVCP_CHUNK_TRAILER(object):
    r"""


    header of a GVCP request packet  

    C++ includes: ChunkAdapterGEV.h

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ChunkID = property(_genicam.GVCP_CHUNK_TRAILER_ChunkID_get, _genicam.GVCP_CHUNK_TRAILER_ChunkID_set)
    ChunkLength = property(_genicam.GVCP_CHUNK_TRAILER_ChunkLength_get, _genicam.GVCP_CHUNK_TRAILER_ChunkLength_set)

    def __init__(self):
        _genicam.GVCP_CHUNK_TRAILER_swiginit(self, _genicam.new_GVCP_CHUNK_TRAILER())
    __swig_destroy__ = _genicam.delete_GVCP_CHUNK_TRAILER

# Register GVCP_CHUNK_TRAILER in _genicam:
_genicam.GVCP_CHUNK_TRAILER_swigregister(GVCP_CHUNK_TRAILER)
class ChunkAdapterGEV(ChunkAdapter):
    r"""


    Connects a chunked DCAM buffer to a node map.  

    C++ includes: ChunkAdapterGEV.h

    """

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

    def __init__(self, pNodeMap=None, MaxChunkCacheSize=-1):
        r"""


        Constructor.  

        """
        _genicam.ChunkAdapterGEV_swiginit(self, _genicam.new_ChunkAdapterGEV(pNodeMap, MaxChunkCacheSize))
    __swig_destroy__ = _genicam.delete_ChunkAdapterGEV

    def CheckBufferLayout(self, pBuffer):
        r"""


        Checks if a buffer contains chunks in a known format.  

        """
        return _genicam.ChunkAdapterGEV_CheckBufferLayout(self, pBuffer)

    def AttachBuffer(self, pBuffer, pAttachStatistics=None):
        r"""


        Attaches a buffer to the matching ChunkPort.  

        """
        return _genicam.ChunkAdapterGEV_AttachBuffer(self, pBuffer, pAttachStatistics)

# Register ChunkAdapterGEV in _genicam:
_genicam.ChunkAdapterGEV_swigregister(ChunkAdapterGEV)

CChunkAdapterGEV = ChunkAdapterGEV

class U3V_CHUNK_TRAILER(object):
    r"""


    header of a GVCP request packet  

    C++ includes: ChunkAdapterU3V.h

    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ChunkID = property(_genicam.U3V_CHUNK_TRAILER_ChunkID_get, _genicam.U3V_CHUNK_TRAILER_ChunkID_set)
    ChunkLength = property(_genicam.U3V_CHUNK_TRAILER_ChunkLength_get, _genicam.U3V_CHUNK_TRAILER_ChunkLength_set)

    def __init__(self):
        _genicam.U3V_CHUNK_TRAILER_swiginit(self, _genicam.new_U3V_CHUNK_TRAILER())
    __swig_destroy__ = _genicam.delete_U3V_CHUNK_TRAILER

# Register U3V_CHUNK_TRAILER in _genicam:
_genicam.U3V_CHUNK_TRAILER_swigregister(U3V_CHUNK_TRAILER)
class ChunkAdapterU3V(ChunkAdapter):
    r"""


    Connects a chunked U3V buffer to a node map.  

    C++ includes: ChunkAdapterU3V.h

    """

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

    def __init__(self, pNodeMap=None, MaxChunkCacheSize=-1):
        r"""


        Constructor.  

        """
        _genicam.ChunkAdapterU3V_swiginit(self, _genicam.new_ChunkAdapterU3V(pNodeMap, MaxChunkCacheSize))
    __swig_destroy__ = _genicam.delete_ChunkAdapterU3V

    def CheckBufferLayout(self, pBuffer):
        r"""


        Checks if a buffer contains chunks in a known format.  

        """
        return _genicam.ChunkAdapterU3V_CheckBufferLayout(self, pBuffer)

    def AttachBuffer(self, pBuffer, pAttachStatistics=None):
        r"""


        Attaches a buffer to the matching ChunkPort.  

        """
        return _genicam.ChunkAdapterU3V_AttachBuffer(self, pBuffer, pAttachStatistics)

# Register ChunkAdapterU3V in _genicam:
_genicam.ChunkAdapterU3V_swigregister(ChunkAdapterU3V)

CChunkAdapterU3V = ChunkAdapterU3V

class SingleChunkData_t(object):
    r"""


    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ChunkID = property(_genicam.SingleChunkData_t_ChunkID_get, _genicam.SingleChunkData_t_ChunkID_set)
    ChunkOffset = property(_genicam.SingleChunkData_t_ChunkOffset_get, _genicam.SingleChunkData_t_ChunkOffset_set)
    ChunkLength = property(_genicam.SingleChunkData_t_ChunkLength_get, _genicam.SingleChunkData_t_ChunkLength_set)

    def __init__(self):
        _genicam.SingleChunkData_t_swiginit(self, _genicam.new_SingleChunkData_t())
    __swig_destroy__ = _genicam.delete_SingleChunkData_t

# Register SingleChunkData_t in _genicam:
_genicam.SingleChunkData_t_swigregister(SingleChunkData_t)
class SingleChunkDataStr_t(object):
    r"""


    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ChunkID = property(_genicam.SingleChunkDataStr_t_ChunkID_get, _genicam.SingleChunkDataStr_t_ChunkID_set)
    ChunkOffset = property(_genicam.SingleChunkDataStr_t_ChunkOffset_get, _genicam.SingleChunkDataStr_t_ChunkOffset_set)
    ChunkLength = property(_genicam.SingleChunkDataStr_t_ChunkLength_get, _genicam.SingleChunkDataStr_t_ChunkLength_set)

    def __init__(self):
        _genicam.SingleChunkDataStr_t_swiginit(self, _genicam.new_SingleChunkDataStr_t())
    __swig_destroy__ = _genicam.delete_SingleChunkDataStr_t

# Register SingleChunkDataStr_t in _genicam:
_genicam.SingleChunkDataStr_t_swigregister(SingleChunkDataStr_t)
class ChunkAdapterGeneric(ChunkAdapter):
    r"""


    Connects a generic chunked buffer to a node map.  

    C++ includes: ChunkAdapterGeneric.h

    """

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

    def __init__(self, pNodeMap=None, MaxChunkCacheSize=-1):
        r"""


        Constructor.  

        """
        _genicam.ChunkAdapterGeneric_swiginit(self, _genicam.new_ChunkAdapterGeneric(pNodeMap, MaxChunkCacheSize))
    __swig_destroy__ = _genicam.delete_ChunkAdapterGeneric

    def CheckBufferLayout(self, pBuffer):
        r"""


        Checks if a buffer contains chunks in a known format.  

        Implement that for a specific buffer layout  

        """
        return _genicam.ChunkAdapterGeneric_CheckBufferLayout(self, pBuffer)

    def AttachBuffer(self, *args):
        r"""


        """
        return _genicam.ChunkAdapterGeneric_AttachBuffer(self, *args)

# Register ChunkAdapterGeneric in _genicam:
_genicam.ChunkAdapterGeneric_swigregister(ChunkAdapterGeneric)

CChunkAdapterGeneric = ChunkAdapterGeneric

class EventPort(IPortConstruct):
    r"""


    Port attachable to an event.  

    C++ includes: EventPort.h

    """

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

    def __init__(self, pNode=None):
        r"""


        Constructor; can attach to a node.  

        """
        _genicam.EventPort_swiginit(self, _genicam.new_EventPort(pNode))
    __swig_destroy__ = _genicam.delete_EventPort

    def GetAccessMode(self):
        r"""


        Get the access mode of the node.  

        """
        return _genicam.EventPort_GetAccessMode(self)

    def GetPrincipalInterfaceType(self):
        r"""


        Get the type of the main interface of a node.  

        """
        return _genicam.EventPort_GetPrincipalInterfaceType(self)

    def Read(self, pBuffer, Address, Length):
        r"""


        Reads a chunk of bytes from the port.  

        """
        return _genicam.EventPort_Read(self, pBuffer, Address, Length)

    def Write(self, pBuffer, Address, Length):
        r"""


        Writes a chunk of bytes to the port.  

        """
        return _genicam.EventPort_Write(self, pBuffer, Address, Length)

    def SetPortImpl(self, pPort):
        r"""


        Called from the port node to give the chunk port a pointer to itself.  

        """
        return _genicam.EventPort_SetPortImpl(self, pPort)

    def GetSwapEndianess(self):
        r"""


        Determines if the port adapter must perform an endianess swap.  

        """
        return _genicam.EventPort_GetSwapEndianess(self)

    def InvalidateNode(self):
        r"""


        """
        return _genicam.EventPort_InvalidateNode(self)

    def AttachNode(self, pNode):
        r"""


        Attaches to the Node.  

        """
        return _genicam.EventPort_AttachNode(self, pNode)

    def DetachNode(self):
        r"""


        Detaches from the Node.  

        """
        return _genicam.EventPort_DetachNode(self)

    def GetEventIDLength(self):
        r"""


        Gets the EventID length.  

        """
        return _genicam.EventPort_GetEventIDLength(self)

    def CheckEventID(self, *args):
        r"""


        Checks if a EventID matches, version using uint64_t ID representation.  

        """
        return _genicam.EventPort_CheckEventID(self, *args)

    def AttachEvent(self, pBaseAddress, Length):
        r"""


        Attaches the an Event to the EventPort.  

        """
        return _genicam.EventPort_AttachEvent(self, pBaseAddress, Length)

    def DetachEvent(self):
        r"""


        Detaches the Event from the EventPort.  

        """
        return _genicam.EventPort_DetachEvent(self)

# Register EventPort in _genicam:
_genicam.EventPort_swigregister(EventPort)

CEventPort = EventPort

class EventAdapter(object):
    r"""


    Delivers Events to ports.  

    C++ includes: EventAdapter.h

    """

    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__ = _genicam.delete_EventAdapter

    def AttachNodeMap(self, pNodeMap):
        r"""


        Attaches to a node map and retrieves the chunk ports.  

        """
        return _genicam.EventAdapter_AttachNodeMap(self, pNodeMap)

    def DetachNodeMap(self):
        r"""


        Detaches from the node emap.  

        """
        return _genicam.EventAdapter_DetachNodeMap(self)

    def DeliverMessage(self, msg):
        r"""


        Deliver message.  

        """
        return _genicam.EventAdapter_DeliverMessage(self, msg)

# Register EventAdapter in _genicam:
_genicam.EventAdapter_swigregister(EventAdapter)

CEventAdapter = EventAdapter

class EventAdapterGEV(EventAdapter):
    r"""


    Connects a GigE Event to a node map.  

    C++ includes: EventAdapterGEV.h

    """

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

    def __init__(self, pNodeMap=None):
        r"""


        Constructor.  

        """
        _genicam.EventAdapterGEV_swiginit(self, _genicam.new_EventAdapterGEV(pNodeMap))
    __swig_destroy__ = _genicam.delete_EventAdapterGEV

    def DeliverMessage(self, msg):
        r"""


        Deliver message.  

        """
        return _genicam.EventAdapterGEV_DeliverMessage(self, msg)

# Register EventAdapterGEV in _genicam:
_genicam.EventAdapterGEV_swigregister(EventAdapterGEV)
COMMAND_MAGIC = cvar.COMMAND_MAGIC


CEventAdapterGEV = EventAdapterGEV

class EventAdapterU3V(EventAdapter):
    r"""


    Connects a U3V Event to a node map.  

    C++ includes: EventAdapterU3V.h

    """

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

    def __init__(self, pNodeMap=None):
        r"""


        Constructor.  

        """
        _genicam.EventAdapterU3V_swiginit(self, _genicam.new_EventAdapterU3V(pNodeMap))
    __swig_destroy__ = _genicam.delete_EventAdapterU3V

    def DeliverMessage(self, msg):
        r"""


        Deliver message.  

        """
        return _genicam.EventAdapterU3V_DeliverMessage(self, msg)

# Register EventAdapterU3V in _genicam:
_genicam.EventAdapterU3V_swigregister(EventAdapterU3V)
U3V_EVENT_PREFIX = cvar.U3V_EVENT_PREFIX
GENCP_EVENT_CMD_ID = cvar.GENCP_EVENT_CMD_ID
GENCP_COMMAND_HEADER_SIZE = cvar.GENCP_COMMAND_HEADER_SIZE
GENCP_EVENT_BASIC_SIZE = cvar.GENCP_EVENT_BASIC_SIZE


CEventAdapterU3V = EventAdapterU3V

class EventAdapterGeneric(EventAdapter):
    r"""


    Connects a generic event to a node map.  

    C++ includes: EventAdapterGeneric.h

    """

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

    def __init__(self, pNodeMap=None):
        r"""


        Constructor.  

        """
        _genicam.EventAdapterGeneric_swiginit(self, _genicam.new_EventAdapterGeneric(pNodeMap))
    __swig_destroy__ = _genicam.delete_EventAdapterGeneric

    def DeliverMessage(self, *args):
        r"""


        """
        return _genicam.EventAdapterGeneric_DeliverMessage(self, *args)

# Register EventAdapterGeneric in _genicam:
_genicam.EventAdapterGeneric_swigregister(EventAdapterGeneric)

CEventAdapterGeneric = EventAdapterGeneric

class FileProtocolAdapter(object):
    r"""


    Adapter between the std::iostreambuf and the SFNC Features representing the
    device filesystem.  

    Adapter between the std::iostreambuf and the SFNC Features representing the
    device filesystem The adapter assumes, that the features provide stdio
    fileaccess compatible semantic  

    C++ includes: Filestream.h

    """

    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"""


        Constructor.  

        """
        _genicam.FileProtocolAdapter_swiginit(self, _genicam.new_FileProtocolAdapter())

    def attach(self, pInterface):
        r"""


        attach file protocol adapter to nodemap  

        Parameters
        ----------
        * `pInterface` :  
            NodeMap of the device to which the FileProtocolAdapter is attached  

        Returns
        -------
        true if attach was successful, false if not  

        """
        return _genicam.FileProtocolAdapter_attach(self, pInterface)

    def openFile(self, pFileName, mode):
        r"""


        open a file on the device  

        Parameters
        ----------
        * `pFileName` :  
            filename of the file to open. The filename must exist in the Enumeration
            FileSelector  
        * `mode` :  
            mode to open the file. The mode must exist in the Enumeration FileOpenMode  

        Returns
        -------
        true on success, false on error  

        """
        return _genicam.FileProtocolAdapter_openFile(self, pFileName, mode)

    def closeFile(self, pFileName):
        r"""


        close a file on the device  

        Parameters
        ----------
        * `pFileName` :  
            filename of the file to open. The filename must exist in the Enumeration
            FileSelector  

        Returns
        -------
        true on success, false on error  

        """
        return _genicam.FileProtocolAdapter_closeFile(self, pFileName)

    def write(self, pBuffer, offs, pFileName):
        r"""


        writes data into a file.  

        Parameters
        ----------
        * `buf` :  
            source buffer  
        * `offs` :  
            offset into the device file  
        * `len` :  
            count of bytes to write  
        * `pFileName` :  
            filename of the file to write into The filename must exist in the
            Enumeration FileSelector  

        Returns
        -------
        count of bytes written  

        """
        return _genicam.FileProtocolAdapter_write(self, pBuffer, offs, pFileName)

    def read(self, pBuffer, offs, pFileName):
        r"""


        read data from the device into a buffer  

        Parameters
        ----------
        * `buf` :  
            target buffer  
        * `offs` :  
            offset in the device file to read from  
        * `len` :  
            count of bytes to read  
        * `pFileName` :  
            filename of the file to write into The filename must exist in the
            Enumeration FileSelector  

        Returns
        -------
        count of bytes successfully read  

        """
        return _genicam.FileProtocolAdapter_read(self, pBuffer, offs, pFileName)

    def getBufSize(self, pFileName, mode):
        r"""


        fetch max FileAccessBuffer length for a file  

        Parameters
        ----------
        * `pFileName` :  
            filename of the file to open. The filename must exist in the Enumeration
            FileSelector  
        * `mode` :  
            mode to open the file. The mode must exist in the Enunmeration FileOpenMode  

        Returns
        -------
        max length of FileAccessBuffer in the given mode on the given file  

        """
        return _genicam.FileProtocolAdapter_getBufSize(self, pFileName, mode)

    def deleteFile(self, pFileName):
        r"""


        Delete the content of the file.  

        Parameters
        ----------
        * `pFileName` :  
            filename of the file to open. The filename must exist in the Enumeration
            FileSelector  

        Returns
        -------
        true on success, false on error  

        """
        return _genicam.FileProtocolAdapter_deleteFile(self, pFileName)
    __swig_destroy__ = _genicam.delete_FileProtocolAdapter

# Register FileProtocolAdapter in _genicam:
_genicam.FileProtocolAdapter_swigregister(FileProtocolAdapter)

class FileAccess(object):
    def __init__(self, read_bufsize = 4096):
        if read_bufsize == 0:
            raise IOError("invalid read_bufsize")

        self.isopen   = False
        self.filename = ""
        self.mode     = ""
        self.fpa      = FileProtocolAdapter()
        self.fpa_bufsize  = 0
        self.fpos     = 0
        self.read_bufsize = read_bufsize

    def open(self, nodemap, filename, openmode):
        self.fpa.attach(nodemap)
        self.filename = filename
        self.fpa.openFile(filename,openmode)
        self.fpa_bufsize = self.fpa.getBufSize(filename, openmode)
        self.fpos = 0
        self.isopen = True

    def close(self):
        self.isopen = False
        self.fpa.closeFile(self.filename)

    def _read(self, size):
        assert(self.isopen)
        read_len, data  = self.fpa.read(size, self.fpos, self.filename)
        data = data[:read_len]
        self.fpos += read_len
        return data

    def read(self, size = -1):
        assert(self.isopen)
        if size < 0:
            buf = b""
            while True:
                data  = self._read(self.read_bufsize)
                buf += data
                if len(data) < self.read_bufsize:
                    return buf

        else:
            data  = self._read(size)
            return data


    def write(self,data):
        assert(self.isopen)
        ret = self.fpa.write(data, self.fpos, self.filename)
        self.fpos += len(data)
        return ret



__version__ = '4.2.0'